{"version":3,"sources":["webpack:///index.min.js","webpack:///webpack/bootstrap e10c8ac77355846295d0","webpack:///./node_modules/rxjs/operators/withLatestFrom.js","webpack:///./node_modules/rxjs/Observable.js","webpack:///./node_modules/rxjs/operators/map.js","webpack:///./node_modules/rxjs/Subscriber.js","webpack:///./node_modules/rxjs/operators/filter.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/rxjs/operators/tap.js","webpack:///./node_modules/rxjs/operators/pluck.js","webpack:///./node_modules/rxjs/util/root.js","webpack:///./lib/effects.ts","webpack:///./node_modules/debug/src/browser.js","webpack:///./node_modules/rxjs/observable/of.js","webpack:///./lib/socket-messages.ts","webpack:///./node_modules/rxjs/operators/ignoreElements.js","webpack:///./node_modules/rxjs/Subscription.js","webpack:///./node_modules/rxjs/BehaviorSubject.js","webpack:///./lib/log.ts","webpack:///./node_modules/rxjs/operators/mergeMap.js","webpack:///./node_modules/rxjs/observable/empty.js","webpack:///./node_modules/component-emitter/index.js","webpack:///./node_modules/engine.io-parser/lib/browser.js","webpack:///./lib/dom-effects.ts","webpack:///./node_modules/rxjs/operators/switchMap.js","webpack:///./lib/utils.ts","webpack:///./lib/browser.utils.ts","webpack:///./node_modules/rxjs/observable/ArrayObservable.js","webpack:///./node_modules/rxjs/observable/EmptyObservable.js","webpack:///./node_modules/rxjs/util/isScheduler.js","webpack:///./node_modules/rxjs/util/isArray.js","webpack:///./node_modules/rxjs/util/errorObject.js","webpack:///./node_modules/rxjs/OuterSubscriber.js","webpack:///./node_modules/rxjs/util/subscribeToResult.js","webpack:///./node_modules/rxjs/symbol/iterator.js","webpack:///./node_modules/parseqs/index.js","webpack:///./node_modules/component-inherit/index.js","webpack:///./node_modules/rxjs/Subject.js","webpack:///./node_modules/rxjs/observable/merge.js","webpack:///./node_modules/rxjs/operators/skip.js","webpack:///./node_modules/rxjs/operators/distinctUntilChanged.js","webpack:///./node_modules/rxjs/observable/fromEvent.js","webpack:///./node_modules/rxjs/util/isFunction.js","webpack:///./node_modules/rxjs/util/tryCatch.js","webpack:///./node_modules/rxjs/symbol/rxSubscriber.js","webpack:///./node_modules/rxjs/symbol/observable.js","webpack:///./node_modules/rxjs/observable/ScalarObservable.js","webpack:///./node_modules/socket.io-parser/index.js","webpack:///./node_modules/engine.io-client/lib/xmlhttprequest.js","webpack:///./node_modules/engine.io-client/lib/transport.js","webpack:///./node_modules/rxjs/observable/timer.js","webpack:///./lib/effects/set-options.effect.ts","webpack:///./node_modules/rxjs/observable/concat.js","webpack:///./lib/messages/BrowserReload.ts","webpack:///./node_modules/rxjs/util/isObject.js","webpack:///./node_modules/rxjs/Observer.js","webpack:///./node_modules/rxjs/util/noop.js","webpack:///./node_modules/rxjs/util/isArrayLike.js","webpack:///./node_modules/rxjs/util/isPromise.js","webpack:///./node_modules/parseuri/index.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/has-binary2/index.js","webpack:///./node_modules/socket.io-parser/is-buffer.js","webpack:///./node_modules/socket.io-client/lib/manager.js","webpack:///./node_modules/engine.io-client/lib/transports/index.js","webpack:///./node_modules/engine.io-client/lib/transports/polling.js","webpack:///./node_modules/yeast/index.js","webpack:///./node_modules/indexof/index.js","webpack:///./node_modules/socket.io-client/lib/socket.js","webpack:///./node_modules/socket.io-client/lib/on.js","webpack:///./node_modules/component-bind/index.js","webpack:///./node_modules/rxjs/util/ObjectUnsubscribedError.js","webpack:///./node_modules/rxjs/operators/share.js","webpack:///./node_modules/rxjs/operators/refCount.js","webpack:///./lib/dom-effects/prop-set.dom-effect.ts","webpack:///./node_modules/rxjs/util/isNumeric.js","webpack:///./node_modules/rxjs/scheduler/async.js","webpack:///./node_modules/rxjs/scheduler/AsyncAction.js","webpack:///./node_modules/rxjs/scheduler/AsyncScheduler.js","webpack:///./lib/dom-effects/style-set.dom-effect.ts","webpack:///./lib/dom-effects/link-replace.dom-effect.ts","webpack:///./lib/dom-effects/set-scroll.dom-effect.ts","webpack:///./lib/dom-effects/set-window-name.dom-effect.ts","webpack:///./lib/messages/ScrollEvent.ts","webpack:///./lib/effects/file-reload.effect.ts","webpack:///./node_modules/rxjs/observable/from.js","webpack:///./node_modules/rxjs/operators/mergeAll.js","webpack:///./node_modules/rxjs/operators/mapTo.js","webpack:///./lib/effects/browser-set-location.effect.ts","webpack:///./lib/effects/simulate-click.effect.ts","webpack:///./lib/effects/set-element-value.effect.ts","webpack:///./lib/effects/set-element-toggle-value.effect.ts","webpack:///./lib/effects/browser-reload.effect.ts","webpack:///./lib/messages/ClickEvent.ts","webpack:///./lib/messages/KeyupEvent.ts","webpack:///./node_modules/timers-browserify/main.js","webpack:///./lib/messages/FormToggleEvent.ts","webpack:///./lib/index.ts","webpack:///./node_modules/rxjs/observable/zip.js","webpack:///./node_modules/rxjs/operators/zip.js","webpack:///./node_modules/rxjs/util/toSubscriber.js","webpack:///./node_modules/rxjs/util/UnsubscriptionError.js","webpack:///./node_modules/rxjs/util/pipe.js","webpack:///./node_modules/rxjs/InnerSubscriber.js","webpack:///./lib/socket.ts","webpack:///./node_modules/socket.io-client/lib/index.js","webpack:///./node_modules/socket.io-client/lib/url.js","webpack:///./node_modules/debug/src/debug.js","webpack:///./node_modules/ms/index.js","webpack:///./node_modules/has-binary2/node_modules/isarray/index.js","webpack:///./node_modules/socket.io-parser/binary.js","webpack:///./node_modules/socket.io-parser/node_modules/isarray/index.js","webpack:///./node_modules/engine.io-client/lib/index.js","webpack:///./node_modules/engine.io-client/lib/socket.js","webpack:///./node_modules/has-cors/index.js","webpack:///./node_modules/engine.io-client/lib/transports/polling-xhr.js","webpack:///./node_modules/engine.io-parser/lib/keys.js","webpack:///./node_modules/arraybuffer.slice/index.js","webpack:///./node_modules/after/index.js","webpack:///./node_modules/engine.io-parser/lib/utf8.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","webpack:///./node_modules/blob/index.js","webpack:///./node_modules/engine.io-client/lib/transports/polling-jsonp.js","webpack:///./node_modules/engine.io-client/lib/transports/websocket.js","webpack:///./node_modules/to-array/index.js","webpack:///./node_modules/backo2/index.js","webpack:///./node_modules/rxjs/SubjectSubscription.js","webpack:///./node_modules/rxjs/operators/multicast.js","webpack:///./node_modules/rxjs/observable/ConnectableObservable.js","webpack:///./lib/notify.ts","webpack:///./node_modules/rxjs/observable/TimerObservable.js","webpack:///./node_modules/rxjs/scheduler/Action.js","webpack:///./node_modules/rxjs/Scheduler.js","webpack:///./node_modules/rxjs/util/isDate.js","webpack:///./vendor/logger.ts","webpack:///./vendor/Reloader.ts","webpack:///./node_modules/rxjs/observable/FromObservable.js","webpack:///./node_modules/rxjs/observable/PromiseObservable.js","webpack:///./node_modules/rxjs/observable/IteratorObservable.js","webpack:///./node_modules/rxjs/observable/ArrayLikeObservable.js","webpack:///./node_modules/rxjs/operators/observeOn.js","webpack:///./node_modules/rxjs/Notification.js","webpack:///./node_modules/rxjs/operators/concatAll.js","webpack:///./node_modules/rxjs/util/identity.js","webpack:///./node_modules/rxjs/operators/startWith.js","webpack:///./node_modules/rxjs/operators/take.js","webpack:///./node_modules/rxjs/util/ArgumentOutOfRangeError.js","webpack:///./lib/effects/set-scroll.ts","webpack:///./node_modules/rxjs/operators/partition.js","webpack:///./node_modules/rxjs/util/not.js","webpack:///./lib/messages/BrowserNotify.ts","webpack:///./lib/messages/BrowserLocation.ts","webpack:///./node_modules/rxjs/operators/subscribeOn.js","webpack:///./node_modules/rxjs/observable/SubscribeOnObservable.js","webpack:///./node_modules/rxjs/scheduler/asap.js","webpack:///./node_modules/rxjs/scheduler/AsapAction.js","webpack:///./node_modules/rxjs/util/Immediate.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/rxjs/scheduler/AsapScheduler.js","webpack:///./lib/messages/FileReload.ts","webpack:///./lib/messages/Connection.ts","webpack:///./lib/messages/Disconnect.ts","webpack:///./lib/messages/OptionsSet.ts","webpack:///./lib/scroll-restore.ts","webpack:///./lib/listeners.ts","webpack:///./lib/listeners/form-inputs.listener.ts","webpack:///./node_modules/rxjs/observable/FromEventObservable.js","webpack:///./lib/listeners/clicks.listener.ts","webpack:///./lib/listeners/scroll.listener.ts","webpack:///./lib/listeners/form-toggles.listener.ts","webpack:///./node_modules/rxjs/operators/groupBy.js","webpack:///./node_modules/rxjs/util/Map.js","webpack:///./node_modules/rxjs/util/MapPolyfill.js","webpack:///./node_modules/rxjs/util/FastMap.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","withLatestFrom","args","_i","arguments","length","source","project","pop","observables","lift","WithLatestFromOperator","__extends","this","b","__","constructor","create","OuterSubscriber_1","subscribeToResult_1","subscriber","subscribe","WithLatestFromSubscriber","_super","destination","toRespond","len","values","Array","push","observable","add","subscribeToResult","notifyNext","outerValue","innerValue","outerIndex","innerIndex","innerSub","found","indexOf","splice","notifyComplete","_next","value","concat","_tryProject","next","result","apply","err","error","OuterSubscriber","root_1","toSubscriber_1","observable_1","pipe_1","Observable","_isScalar","_subscribe","operator","observerOrNext","complete","sink","toSubscriber","syncErrorThrowable","_trySubscribe","syncErrorThrown","syncErrorValue","forEach","PromiseCtor","_this","root","Rx","config","Promise","Error","resolve","reject","subscription","unsubscribe","pipe","operations","pipeFromArray","toPromise","x","map","thisArg","TypeError","MapOperator","Subscriber_1","MapSubscriber","count","Subscriber","isFunction_1","Subscription_1","Observer_1","rxSubscriber_1","destinationOrNext","isStopped","empty","SafeSubscriber","rxSubscriber","_error","_complete","closed","_unsubscribeAndRecycle","_a","_parent","_parents","Subscription","_parentSubscriber","context","isFunction","bind","_context","__tryOrSetError","__tryOrUnsub","wrappedComplete","fn","parent","_unsubscribe","filter","predicate","FilterOperator","FilterSubscriber","g","Function","eval","e","window","tap","nextOrObserver","DoOperator","DoSubscriber","safeSubscriber","pluck","properties","map_1","plucker","props","currentProp","global","__window","__self","self","WorkerGlobalScope","__global","_root","EffectNames","BehaviorSubject_1","set_options_effect_1","file_reload_effect_1","browser_set_location_effect_1","simulate_click_effect_1","set_element_value_effect_1","set_element_toggle_value_effect_1","set_scroll_1","browser_reload_effect_1","effectOutputHandlers$","BehaviorSubject","SetOptions","setOptionsEffect","FileReload","fileReloadEffect","BrowserReload","browserReloadEffect","BrowserSetLocation","browserSetLocationEffect","SimulateClick","simulateClickEffect","SetElementValue","setElementValueEffect","SetElementToggleValue","setElementToggleValueEffect","BrowserSetScroll","setScrollEffect","process","useColors","type","document","documentElement","style","WebkitAppearance","console","firebug","exception","table","navigator","userAgent","toLowerCase","match","parseInt","RegExp","$1","formatArgs","namespace","humanize","diff","color","index","lastC","replace","log","save","namespaces","storage","removeItem","debug","load","r","env","DEBUG","chrome","local","localStorage","colors","formatters","j","v","JSON","stringify","message","enable","ArrayObservable_1","of","ArrayObservable","emitWithPathname","xs","inputs","withLatestFrom_1","io$","window$","pluck_1","tap_1","event","io","pathname","emit","__assign","ignoreElements_1","ignoreElements","assign","t","IncomingSocketNames","ScrollEvent_1","ClickEvent_1","KeyupEvent_1","BrowserNotify_1","BrowserLocation_1","BrowserReload_1","FileReload_1","Connection_1","Disconnect_1","FormToggleEvent_1","OptionsSet_1","OutgoingSocketEvents","socketHandlers$","Connection","incomingConnection","Disconnect","incomingDisconnect","incomingFileReload","incomingBrowserReload","BrowserLocation","incomingBrowserLocation","BrowserNotify","incomingBrowserNotify","Scroll","incomingScrollHandler","Click","incomingHandler$","Keyup","incomingKeyupHandler","InputToggle","incomingInputsToggles","OptionsSet","incomingOptionsSet","IgnoreElementsOperator","noop_1","IgnoreElementsSubscriber","unused","noop","flattenUnsubscriptionErrors","errors","reduce","errs","UnsubscriptionError_1","UnsubscriptionError","isArray_1","isObject_1","tryCatch_1","errorObject_1","_subscriptions","hasErrors","remove","trial","tryCatch","errorObject","isArray","sub","isObject","teardown","EMPTY","_addParent","tmp","subscriptions","subscriptionIndex","Subject_1","ObjectUnsubscribedError_1","_value","getValue","hasError","thrownError","ObjectUnsubscribedError","Subject","initLogger","options","logger_1","Nanologger","logPrefix","magenta","of_1","consoleInfo","LogNames","Log","Info","consoleDebug","Debug","overlayInfo","timeout","Overlay","timer_1","filter_1","switchMap_1","logHandler$","logInstance$","option$","info","notifyElement$","document$","Boolean","notify","element","innerHTML","display","body","appendChild","switchMap","timer","parentNode","removeChild","mergeMap","resultSelector","concurrent","Number","POSITIVE_INFINITY","MergeMapOperator","observer","MergeMapSubscriber","hasCompleted","buffer","active","_tryNext","_innerSub","ish","_notifyResultSelector","shift","EmptyObservable_1","EmptyObservable","Emitter","obj","mixin","key","on","addEventListener","_callbacks","once","off","removeListener","removeAllListeners","removeEventListener","callbacks","cb","slice","listeners","hasListeners","encodeBase64Object","packet","callback","packets","data","encodeArrayBuffer","supportsBinary","encodeBase64Packet","contentArray","Uint8Array","resultBuffer","byteLength","encodeBlobAsArrayBuffer","fr","FileReader","onload","encodePacket","readAsArrayBuffer","encodeBlob","dontSendBlobs","Blob","tryDecode","utf8","decode","strict","ary","each","done","after","el","msg","base64encoder","keys","hasBinary","sliceBuffer","ArrayBuffer","isAndroid","test","isPhantomJS","protocol","open","close","ping","pong","upgrade","packetslist","utf8encode","undefined","base64","encoded","encode","String","b64","split","readAsDataURL","b64data","fromCharCode","typed","basic","btoa","decodePacket","binaryType","utf8decode","charAt","decodeBase64Packet","substr","substring","asArray","rest","encodePayload","setLengthHeader","encodeOne","doneCallback","isBinary","encodePayloadAsBlob","encodePayloadAsArrayBuffer","results","join","decodePayload","decodePayloadAsBinary","chr","encodedPackets","totalLength","acc","toString","resultArray","bufferIndex","isString","ab","view","charCodeAt","lenStr","binaryIdentifier","size","lengthAry","blob","bufferTail","buffers","tailArray","msgLength","total","Events","prop_set_dom_effect_1","style_set_dom_effect_1","link_replace_dom_effect_1","set_scroll_dom_effect_1","set_window_name_dom_effect_1","domHandlers$","PropSet","propSetDomEffect","StyleSet","styleSetDomEffect","LinkReplace","linkReplaceDomEffect","SetScroll","setScrollDomEffect","SetWindowName","setWindowNameDomEffect","SwitchMapOperator","SwitchMapSubscriber","innerSubscription","_tryNotifyNext","incoming","getLocation","url","location","createElement","href","host","updateSearch","search","suffix","item","tuple","isBlacklisted","blacklist","some","createTimedBooleanSwitch","source$","concat_1","mapTo_1","mapTo","startWith_1","startWith","array","splitUrl","hash","params","pathFromUrl","path","decodeURIComponent","pickBestMatch","objects","pathFunc","score","bestMatch","numberOfMatchingSegments","path1","path2","comps1","reverse","comps2","Math","min","eqCount","pathsMatch","ext","getWindow","getDocument","getBrowserScrollPosition","scrollX","scrollY","dElement","dBody","pageYOffset","pageXOffset","scrollLeft","scrollTop","y","getDocumentScrollSpace","scrollHeight","clientWidth","clientHeight","saveScrollPosition","pos","cookie","restoreScrollPosition","scrollTo","getElementIndex","tagName","elem","allElems","getElementsByTagName","forceChange","blur","focus","getElementData","getSingleElement","getBody","setScroll","reloadBrowser","reload","coll","isOldIe","attachEvent","isUndefined","val","getByPath","tempPath","getScrollPosition","raw","proportional","getScrollTopPercentage","getScrollPositionForElement","getScrollPercentage","scrollWidth","scrollSpace","scrollPosition","Observable_1","ScalarObservable_1","isScheduler_1","scheduler","isScheduler","ScalarObservable","dispatch","state","schedule","arg","notifyError","outerSubscriber","InnerSubscriber_1","InnerSubscriber","isArrayLike_1","isArrayLike","isPromise_1","isPromise","then","setTimeout","iterator_1","iterator","obs","symbolIteratorPonyfill","Symbol","Set_1","Set","Map_1","Map","getOwnPropertyNames","$$iterator","str","encodeURIComponent","qs","qry","pairs","pair","a","SubjectSubscription_1","SubjectSubscriber","observers","subject","AnonymousSubject","copy","SubjectSubscription","asObservable","merge","last","mergeAll_1","mergeAll","skip","SkipOperator","SkipSubscriber","distinctUntilChanged","compare","keySelector","DistinctUntilChangedOperator","DistinctUntilChangedSubscriber","hasKey","FromEventObservable_1","fromEvent","FromEventObservable","tryCatcher","tryCatchTarget","for","$$rxSubscriber","getSymbolObservable","$$observable","Encoder","encodeAsString","BINARY_EVENT","BINARY_ACK","attachments","nsp","id","encodeAsBinary","writeEncoding","bloblessData","deconstruction","binary","deconstructPacket","pack","unshift","removeBlobs","Decoder","reconstructor","decodeString","types","buf","tryParse","parse","BinaryReconstructor","reconPack","ERROR","hasBin","isBuf","CONNECT","DISCONNECT","EVENT","ACK","takeBinaryData","destroy","finishedReconstruction","binData","reconstructPacket","hasCORS","opts","xdomain","xscheme","enablesXDR","XMLHttpRequest","XDomainRequest","Transport","hostname","port","secure","query","timestampParam","timestampRequests","readyState","agent","socket","pfx","passphrase","cert","ca","ciphers","rejectUnauthorized","forceNode","extraHeaders","localAddress","parser","onError","desc","description","doOpen","doClose","onClose","send","write","onOpen","writable","onData","onPacket","TimerObservable_1","TimerObservable","setOptions","effects_1","from_1","from","concatAll_1","concatAll","codeSync","mergeMap_1","reloadBrowserSafe","preBrowserReload","browserReload","subscribeOn_1","subscribeOn","async_1","async","re","parts","src","exec","uri","authority","ipv6uri","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","run","Item","nextTick","title","browser","argv","version","versions","addListener","prependListener","prependOnceListener","binding","cwd","chdir","dir","umask","Buffer","isBuffer","withNativeBlob","withNativeFile","File","toJSON","Manager","nsps","subs","reconnection","reconnectionAttempts","Infinity","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","Backoff","max","jitter","connecting","lastPing","encoding","packetBuffer","_parser","encoder","decoder","autoConnect","eio","Socket","has","emitAll","updateSocketIds","generateId","engine","_reconnection","_reconnectionAttempts","_reconnectionDelay","setMin","_randomizationFactor","setJitter","_reconnectionDelayMax","setMax","_timeout","maybeReconnectOnOpen","reconnecting","attempts","reconnect","connect","skipReconnect","openSub","onopen","errorSub","cleanup","onping","Date","onpong","ondata","ondecoded","onerror","onConnecting","processPacketQueue","subsLength","disconnect","reset","onclose","reason","delay","duration","onreconnect","attempt","polling","xd","jsonp","isSSL","forceJSONP","XHR","JSONP","websocket","Polling","forceBase64","hasXHR2","parseqs","inherit","yeast","responseType","poll","pause","onPause","doPoll","callbackfn","doWrite","schema","sid","num","alphabet","floor","decoded","now","prev","seed","arr","json","ids","acks","receiveBuffer","sendBuffer","connected","disconnected","toArray","events","connect_error","connect_timeout","reconnect_attempt","reconnect_failed","reconnect_error","subEvents","ev","compress","flags","onpacket","onconnect","onevent","onack","ondisconnect","ack","sent","emitBuffered","stack","shareSubjectFactory","share","refCount_1","refCount","multicast_1","multicast","RefCountOperator","connectable","_refCount","refCounter","RefCountSubscriber","connection","sharedConnection","_connection","target","prop","propSet","dom_effects_1","isNumeric","parseFloat","AsyncAction_1","AsyncScheduler_1","AsyncScheduler","AsyncAction","Action_1","work","pending","recycleAsyncId","requestAsyncId","setInterval","flush","clearInterval","execute","_execute","errored","errorValue","actions","Action","Scheduler_1","scheduled","action","Scheduler","styleName","newValue","pathName","styleSet","inject","basename","linkReplace","setWindowName","outgoing","mappingIndex","socket_messages_1","position","canScroll","fileReload","navigator$","Reloader_1","tagNames","liveCSS","liveImg","FromObservable_1","FromObservable","identity_1","identity","MapToOperator","MapToSubscriber","browserSetLocation","input","elems","createEvent","evObj","initEvent","dispatchEvent","createEventObject","cancelBubble","fireEvent","simulateClick","setElementValue","checked","setElementToggleValue","PreBrowserReload","canClick","canKeyup","Timeout","clearFn","_id","_clearFn","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","_onTimeout","setImmediate","clearImmediate","getStream","handlers$","inputStream$","groupBy_1","groupBy","share_1","zip_1","socket_1","notify_1","merge_1","log_1","scroll_restore_1","listeners_1","initWindow","initDocument","initSocket","socket$","initOptions","initNotify","outgoing$","initListeners","combinedEffectHandler$","zip","scrollRestoreHandlers$","output$","effect$","dom$","merged$","zipStatic","ZipOperator","ZipSubscriber","iterators","StaticArrayIterator","StaticIterator","ZipBufferIterator","stillUnsubscribed","notifyInactive","checkIterators","hasValue","shouldComplete","nextResult","isComplete","fns","initNavigator","___browserSync___","socketConfig","socketUrl","lookup","parsed","sameNamespace","cache","newConnection","forceNew","multiplex","managers","loc","parseuri","ipv6","selectColor","abs","createDebug","enabled","curr","ms","prevTime","coerce","format","formatter","init","names","skips","disable","h","fmtShort","round","fmtLong","plural","ceil","isNaN","long","_deconstructPacket","placeholder","_placeholder","newData","_reconstructPacket","packetData","_removeBlobs","curKey","containingObject","pendingBlobs","fileReader","transports","transportOptions","writeBuffer","prevBufferLen","policyPort","rememberUpgrade","onlyBinaryUpgrades","perMessageDeflate","threshold","freeGlobal","upgrades","pingInterval","pingTimeout","pingIntervalTimer","pingTimeoutTimer","clone","priorWebsocketSuccess","createTransport","EIO","transport","requestTimeout","protocols","setTransport","onDrain","probe","onTransportOpen","upgradeLosesBinary","failed","upgrading","freezeTransport","onTransportClose","onupgrade","to","onHandshake","setPing","code","filterUpgrades","onHeartbeat","sendPacket","cleanupAndClose","waitForUpgrade","filteredUpgrades","Request","method","unloadHandler","requests","abort","request","req","sendXhr","pollXhr","xhr","setDisableHeaderCheck","setRequestHeader","withCredentials","hasXDR","onLoad","responseText","onreadystatechange","contentType","getResponseHeader","status","requestsCount","onSuccess","fromError","response","arraybuffer","start","end","bytes","abv","ii","err_cb","proxy","bail","__WEBPACK_AMD_DEFINE_RESULT__","ucs2decode","string","extra","output","counter","ucs2encode","stringFromCharCode","checkScalarValue","codePoint","toUpperCase","createByte","encodeCodePoint","symbol","codePoints","byteString","readContinuationByte","byteIndex","byteCount","continuationByte","byteArray","decodeSymbol","byte1","byte2","byte3","byte4","freeExports","webpackPolyfill","deprecate","paths","children","chars","encoded1","encoded2","encoded3","encoded4","bufferLength","mapArrayBufferViews","chunk","set","byteOffset","BlobBuilderConstructor","bb","BlobBuilder","append","getBlob","BlobConstructor","WebKitBlobBuilder","MSBlobBuilder","MozBlobBuilder","blobSupported","blobSupportsArrayBufferView","blobBuilderSupported","JSONPPolling","___eio","script","rNewline","rEscapedNewline","form","iframe","insertAt","insertBefore","head","initIframe","html","iframeId","area","className","top","left","setAttribute","submit","WS","usingBrowserWebSocket","BrowserWebSocket","WebSocket","NodeWebSocket","MozWebSocket","check","headers","ws","supports","addEventListeners","onmessage","list","factor","pow","rand","random","deviation","subscriberIndex","subjectOrSubjectFactory","selector","subjectFactory","MulticastOperator","ConnectableObservable_1","connectableObservableDescriptor","ConnectableObservable","_isComplete","getSubject","_subject","ConnectableSubscriber","connectableProto","cssStyles","styles","cssText","rule","padding","fontFamily","fontSize","zIndex","right","borderBottomLeftRadius","backgroundColor","margin","textAlign","pointerEvents","isNumeric_1","isDate_1","dueTime","period","isDate","initialDelay","SchedulerAction","emojis","trace","warn","fatal","levels","defaultColors","foreground","background","black","red","green","yellow","blue","cyan","white","brightBlack","_name","_colors","logLevel","getItem","_logLevel","_print","level","emoji","msgColor","objs","getMatches","attr","matches","urlMatcher","getElems","fileExtension","attrs","reloadImages","expando","generateUniqueString","images","img","utils_1","payload","generateCacheBustUrl","IMAGE_STYLES","styleNames","querySelectorAll","reloadStyleImages","_src","swapFile","domData","currentValue","timeStamp","getTime","anchor","reloadStylesheet","timestamps","hiddenElem","reattachStylesheetLink","link","__LiveReload_pendingRemoval","empty_1","rel","media","disabled","cloneNode","prevHref","nextHref","linkHref","lastChild","nextSibling","additionalWaitingTime","take_1","take","reattachImportedRule","parentStyleSheet","newRule","__LiveReload_newHref","tempLink","insertRule","deleteRule","cssRules","oldParams","sep","links","styleImported","sheet","collectImportedStylesheets","linksImported","allRules","styleSheet","makeRules","rules","collect","CSSRule","CHARSET_RULE","IMPORT_RULE","getAttribute","PromiseObservable_1","IteratorObservable_1","ArrayLikeObservable_1","observeOn_1","PromiseObservable","IteratorObservable","ArrayLikeObservable","ObserveOnSubscriber","dispatchNext","dispatchError","promise","getIterator","StringIterator","ArrayIterator","toLength","numberIsFinite","sign","maxSafeInteger","isFinite","valueAsNumber","return","idx","arrayLike","observeOn","ObserveOnOperator","Notification_1","notification","observe","scheduleMessage","ObserveOnMessage","Notification","createNext","createError","createComplete","kind","do","accept","toObservable","throw","undefinedValueNotification","completeNotification","TakeOperator","ArgumentOutOfRangeError_1","ArgumentOutOfRangeError","TakeSubscriber","tupleStream$","partition_1","partition","element$","_b","mapped$","nonMapped$","scrollProportionally","browser_utils_1","matchingElements","scrollElement","scrollElementMapping","querySelector","not_1","not","pred","notPred","SubscribeOnOperator","SubscribeOnObservable_1","SubscribeOnObservable","asap_1","delayTime","asap","AsapAction_1","AsapScheduler_1","AsapScheduler","AsapAction","Immediate_1","Immediate","ImmediateDefinition","nextHandle","tasksByHandle","currentlyRunningATask","canUseProcessNextTick","createProcessNextTickSetImmediate","canUsePostMessage","createPostMessageSetImmediate","canUseMessageChannel","createMessageChannelSetImmediate","canUseReadyStateChange","createReadyStateChangeSetImmediate","createSetTimeoutSetImmediate","ci","handle","instance","identify","MessageChannel","postMessage","importScripts","postMessageIsAsynchronous_1","oldOnMessage","partiallyApplied","handler","addFromSetImmediateArguments","runIfPresent","messagePrefix","onGlobalMessage","globalMessageHandler","task","channel","port1","port2","doc","registerImmediate","attachTo","getPrototypeOf","postMessageIsAsynchronous","injectChanges","initWindowName","saved","regex","bs","hardReload","scroll","PREFIX","SUFFIX","scroll_listener_1","getScrollStream","clicks_listener_1","getClickStream","form_inputs_listener_1","getFormInputStream","form_toggles_listener_1","getFormTogglesStream","canSync$","skip_1","distinctUntilChanged_1","formInputs","fromEvent_1","srcElement","eventTarget","KeyupEvent","isNodeStyleEventEmitter","sourceObj","isJQueryStyleEventEmitter","isNodeList","isHTMLCollection","isEventTarget","eventName","setupSubscription","source_1","source_2","source_3","getElementById","ClickEvent","elemMap$","selectors","canSync","elemMap","ScrollEvent","canToggle","FormToggleEvent","elementSelector","durationSelector","subjectSelector","GroupByOperator","FastMap_1","GroupBySubscriber","groups","attemptedToUnsubscribe","_group","FastMap","group","groupedObservable","GroupedObservable","GroupDurationSubscriber","clear","removeGroup","delete","groupSubject","refCountSubscription","InnerRefCountSubscription","MapPolyfill_1","MapPolyfill","_values","_keys"],"mappings":"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","file":"index.min.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 = 95);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = __webpack_require__(30);\nvar subscribeToResult_1 = __webpack_require__(31);\n/* tslint:enable:max-line-length */\n/**\n * Combines the source Observable with other Observables to create an Observable\n * whose values are calculated from the latest values of each, only when the\n * source emits.\n *\n * <span class=\"informal\">Whenever the source Observable emits a value, it\n * computes a formula using that value plus the latest values from other input\n * Observables, then emits the output of that formula.</span>\n *\n * <img src=\"./img/withLatestFrom.png\" width=\"100%\">\n *\n * `withLatestFrom` combines each value from the source Observable (the\n * instance) with the latest values from the other input Observables only when\n * the source emits a value, optionally using a `project` function to determine\n * the value to be emitted on the output Observable. All input Observables must\n * emit at least one value before the output Observable will emit a value.\n *\n * @example <caption>On every click event, emit an array with the latest timer event plus the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var timer = Rx.Observable.interval(1000);\n * var result = clicks.withLatestFrom(timer);\n * result.subscribe(x => console.log(x));\n *\n * @see {@link combineLatest}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {Function} [project] Projection function for combining values\n * together. Receives all values in order of the Observables passed, where the\n * first parameter is a value from the source Observable. (e.g.\n * `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not\n * passed, arrays will be emitted on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method withLatestFrom\n * @owner Observable\n */\nfunction withLatestFrom() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i - 0] = arguments[_i];\n    }\n    return function (source) {\n        var project;\n        if (typeof args[args.length - 1] === 'function') {\n            project = args.pop();\n        }\n        var observables = args;\n        return source.lift(new WithLatestFromOperator(observables, project));\n    };\n}\nexports.withLatestFrom = withLatestFrom;\nvar WithLatestFromOperator = (function () {\n    function WithLatestFromOperator(observables, project) {\n        this.observables = observables;\n        this.project = project;\n    }\n    WithLatestFromOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));\n    };\n    return WithLatestFromOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar WithLatestFromSubscriber = (function (_super) {\n    __extends(WithLatestFromSubscriber, _super);\n    function WithLatestFromSubscriber(destination, observables, project) {\n        _super.call(this, destination);\n        this.observables = observables;\n        this.project = project;\n        this.toRespond = [];\n        var len = observables.length;\n        this.values = new Array(len);\n        for (var i = 0; i < len; i++) {\n            this.toRespond.push(i);\n        }\n        for (var i = 0; i < len; i++) {\n            var observable = observables[i];\n            this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i));\n        }\n    }\n    WithLatestFromSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.values[outerIndex] = innerValue;\n        var toRespond = this.toRespond;\n        if (toRespond.length > 0) {\n            var found = toRespond.indexOf(outerIndex);\n            if (found !== -1) {\n                toRespond.splice(found, 1);\n            }\n        }\n    };\n    WithLatestFromSubscriber.prototype.notifyComplete = function () {\n        // noop\n    };\n    WithLatestFromSubscriber.prototype._next = function (value) {\n        if (this.toRespond.length === 0) {\n            var args = [value].concat(this.values);\n            if (this.project) {\n                this._tryProject(args);\n            }\n            else {\n                this.destination.next(args);\n            }\n        }\n    };\n    WithLatestFromSubscriber.prototype._tryProject = function (args) {\n        var result;\n        try {\n            result = this.project.apply(this, args);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return WithLatestFromSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=withLatestFrom.js.map\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nvar toSubscriber_1 = __webpack_require__(99);\nvar observable_1 = __webpack_require__(43);\nvar pipe_1 = __webpack_require__(101);\n/**\n * A representation of any set of values over any amount of time. This is the most basic building block\n * of RxJS.\n *\n * @class Observable<T>\n */\nvar Observable = (function () {\n    /**\n     * @constructor\n     * @param {Function} subscribe the function that is called when the Observable is\n     * initially subscribed to. This function is given a Subscriber, to which new values\n     * can be `next`ed, or an `error` method can be called to raise an error, or\n     * `complete` can be called to notify of a successful completion.\n     */\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    /**\n     * Creates a new Observable, with this Observable as the source, and the passed\n     * operator defined as the new observable's operator.\n     * @method lift\n     * @param {Operator} operator the operator defining the operation to take on the observable\n     * @return {Observable} a new observable with the Operator applied\n     */\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    /**\n     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.\n     *\n     * <span class=\"informal\">Use it when you have all these Observables, but still nothing is happening.</span>\n     *\n     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It\n     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is\n     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling\n     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often\n     * thought.\n     *\n     * Apart from starting the execution of an Observable, this method allows you to listen for values\n     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two\n     * following ways.\n     *\n     * The first way is creating an object that implements {@link Observer} interface. It should have methods\n     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create\n     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do\n     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also\n     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't\n     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will\n     * be left uncaught.\n     *\n     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.\n     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent\n     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,\n     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,\n     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes\n     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.\n     *\n     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.\n     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean\n     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback\n     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.\n     *\n     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.\n     * It is an Observable itself that decides when these functions will be called. For example {@link of}\n     * by default emits all its values synchronously. Always check documentation for how given Observable\n     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.\n     *\n     * @example <caption>Subscribe with an Observer</caption>\n     * const sumObserver = {\n     *   sum: 0,\n     *   next(value) {\n     *     console.log('Adding: ' + value);\n     *     this.sum = this.sum + value;\n     *   },\n     *   error() { // We actually could just remove this method,\n     *   },        // since we do not really care about errors right now.\n     *   complete() {\n     *     console.log('Sum equals: ' + this.sum);\n     *   }\n     * };\n     *\n     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.\n     * .subscribe(sumObserver);\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Subscribe with functions</caption>\n     * let sum = 0;\n     *\n     * Rx.Observable.of(1, 2, 3)\n     * .subscribe(\n     *   function(value) {\n     *     console.log('Adding: ' + value);\n     *     sum = sum + value;\n     *   },\n     *   undefined,\n     *   function() {\n     *     console.log('Sum equals: ' + sum);\n     *   }\n     * );\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Cancel a subscription</caption>\n     * const subscription = Rx.Observable.interval(1000).subscribe(\n     *   num => console.log(num),\n     *   undefined,\n     *   () => console.log('completed!') // Will not be called, even\n     * );                                // when cancelling subscription\n     *\n     *\n     * setTimeout(() => {\n     *   subscription.unsubscribe();\n     *   console.log('unsubscribed!');\n     * }, 2500);\n     *\n     * // Logs:\n     * // 0 after 1s\n     * // 1 after 2s\n     * // \"unsubscribed!\" after 2.5s\n     *\n     *\n     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,\n     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed\n     *  Observable.\n     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,\n     *  the error will be thrown as unhandled.\n     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.\n     * @return {ISubscription} a subscription reference to the registered handlers\n     * @method subscribe\n     */\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            operator.call(sink, this.source);\n        }\n        else {\n            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));\n        }\n        if (sink.syncErrorThrowable) {\n            sink.syncErrorThrowable = false;\n            if (sink.syncErrorThrown) {\n                throw sink.syncErrorValue;\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            sink.syncErrorThrown = true;\n            sink.syncErrorValue = err;\n            sink.error(err);\n        }\n    };\n    /**\n     * @method forEach\n     * @param {Function} next a handler for each value emitted by the observable\n     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise\n     * @return {Promise} a promise that either resolves on observable completion or\n     *  rejects with the handled error\n     */\n    Observable.prototype.forEach = function (next, PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            // Must be declared in a separate statement to avoid a RefernceError when\n            // accessing subscription below in the closure due to Temporal Dead Zone.\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                if (subscription) {\n                    // if there is a subscription, then we can surmise\n                    // the next handling is asynchronous. Any errors thrown\n                    // need to be rejected explicitly and unsubscribe must be\n                    // called manually\n                    try {\n                        next(value);\n                    }\n                    catch (err) {\n                        reject(err);\n                        subscription.unsubscribe();\n                    }\n                }\n                else {\n                    // if there is NO subscription, then we're getting a nexted\n                    // value synchronously during subscription. We can just call it.\n                    // If it errors, Observable's `subscribe` will ensure the\n                    // unsubscription logic is called, then synchronously rethrow the error.\n                    // After that, Promise will trap the error and send it\n                    // down the rejection path.\n                    next(value);\n                }\n            }, reject, resolve);\n        });\n    };\n    Observable.prototype._subscribe = function (subscriber) {\n        return this.source.subscribe(subscriber);\n    };\n    /**\n     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable\n     * @method Symbol.observable\n     * @return {Observable} this instance of the observable\n     */\n    Observable.prototype[observable_1.observable] = function () {\n        return this;\n    };\n    /* tslint:enable:max-line-length */\n    /**\n     * Used to stitch together functional operators into a chain.\n     * @method pipe\n     * @return {Observable} the Observable result of all of the operators having\n     * been called in the order they were passed in.\n     *\n     * @example\n     *\n     * import { map, filter, scan } from 'rxjs/operators';\n     *\n     * Rx.Observable.interval(1000)\n     *   .pipe(\n     *     filter(x => x % 2 === 0),\n     *     map(x => x + x),\n     *     scan((acc, x) => acc + x)\n     *   )\n     *   .subscribe(x => console.log(x))\n     */\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i - 0] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipe_1.pipeFromArray(operations)(this);\n    };\n    /* tslint:enable:max-line-length */\n    Observable.prototype.toPromise = function (PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    // HACK: Since TypeScript inherits static properties too, we have to\n    // fight against TypeScript here so Subject can have a different static create signature\n    /**\n     * Creates a new cold Observable by calling the Observable constructor\n     * @static true\n     * @owner Observable\n     * @method create\n     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor\n     * @return {Observable} a new cold observable\n     */\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nexports.map = map;\nvar MapOperator = (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexports.MapOperator = MapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapSubscriber = (function (_super) {\n    __extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        _super.call(this, destination);\n        this.project = project;\n        this.count = 0;\n        this.thisArg = thisArg || this;\n    }\n    // NOTE: This looks unoptimized, but it's actually purposefully NOT\n    // using try/catch optimizations.\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=map.js.map\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isFunction_1 = __webpack_require__(40);\nvar Subscription_1 = __webpack_require__(14);\nvar Observer_1 = __webpack_require__(53);\nvar rxSubscriber_1 = __webpack_require__(42);\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber<T>\n */\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    /**\n     * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n     * defined Observer or a `next` callback function.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     */\n    function Subscriber(destinationOrNext, error, complete) {\n        _super.call(this);\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = Observer_1.empty;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = Observer_1.empty;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    if (destinationOrNext instanceof Subscriber) {\n                        this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n                        this.destination = destinationOrNext;\n                        this.destination.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };\n    /**\n     * A static factory for a Subscriber, given a (potentially partial) definition\n     * of an Observer.\n     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)\n     * Observer represented by the given arguments.\n     */\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `next` from\n     * the Observable, with a value. The Observable may call this method 0 or more\n     * times.\n     * @param {T} [value] The `next` value.\n     * @return {void}\n     */\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `error` from\n     * the Observable, with an attached {@link Error}. Notifies the Observer that\n     * the Observable has experienced an error condition.\n     * @param {any} [err] The `error` exception.\n     * @return {void}\n     */\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive a valueless notification of type\n     * `complete` from the Observable. Notifies the Observer that the Observable\n     * has finished sending push-based notifications.\n     * @return {void}\n     */\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        this._parent = null;\n        this._parents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parent = _parent;\n        this._parents = _parents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        _super.call(this);\n        this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = this;\n        if (isFunction_1.isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== Observer_1.empty) {\n                context = Object.create(observerOrNext);\n                if (isFunction_1.isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._error) {\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                throw err;\n            }\n            else {\n                _parentSubscriber.syncErrorValue = err;\n                _parentSubscriber.syncErrorThrown = true;\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            throw err;\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            parent.syncErrorValue = err;\n            parent.syncErrorThrown = true;\n            return true;\n        }\n        return false;\n    };\n    SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\n//# sourceMappingURL=Subscriber.js.map\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return function filterOperatorFunction(source) {\n        return source.lift(new FilterOperator(predicate, thisArg));\n    };\n}\nexports.filter = filter;\nvar FilterOperator = (function () {\n    function FilterOperator(predicate, thisArg) {\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n    }\n    FilterOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));\n    };\n    return FilterOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar FilterSubscriber = (function (_super) {\n    __extends(FilterSubscriber, _super);\n    function FilterSubscriber(destination, predicate, thisArg) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n        this.count = 0;\n    }\n    // the try catch block below is left specifically for\n    // optimization and perf reasons. a tryCatcher is not necessary here.\n    FilterSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.predicate.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.destination.next(value);\n        }\n    };\n    return FilterSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=filter.js.map\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\nvar 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/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @name tap\n */\nfunction tap(nextOrObserver, error, complete) {\n    return function tapOperatorFunction(source) {\n        return source.lift(new DoOperator(nextOrObserver, error, complete));\n    };\n}\nexports.tap = tap;\nvar DoOperator = (function () {\n    function DoOperator(nextOrObserver, error, complete) {\n        this.nextOrObserver = nextOrObserver;\n        this.error = error;\n        this.complete = complete;\n    }\n    DoOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DoSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));\n    };\n    return DoOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DoSubscriber = (function (_super) {\n    __extends(DoSubscriber, _super);\n    function DoSubscriber(destination, nextOrObserver, error, complete) {\n        _super.call(this, destination);\n        var safeSubscriber = new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n        safeSubscriber.syncErrorThrowable = true;\n        this.add(safeSubscriber);\n        this.safeSubscriber = safeSubscriber;\n    }\n    DoSubscriber.prototype._next = function (value) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.next(value);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.next(value);\n        }\n    };\n    DoSubscriber.prototype._error = function (err) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.error(err);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.error(err);\n        }\n    };\n    DoSubscriber.prototype._complete = function () {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.complete();\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    return DoSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=tap.js.map\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar map_1 = __webpack_require__(2);\n/**\n * Maps each source value (an object) to its specified nested property.\n *\n * <span class=\"informal\">Like {@link map}, but meant only for picking one of\n * the nested properties of every emitted object.</span>\n *\n * <img src=\"./img/pluck.png\" width=\"100%\">\n *\n * Given a list of strings describing a path to an object property, retrieves\n * the value of a specified nested property from all values in the source\n * Observable. If a property can't be resolved, it will return `undefined` for\n * that value.\n *\n * @example <caption>Map every click to the tagName of the clicked target element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var tagNames = clicks.pluck('target', 'tagName');\n * tagNames.subscribe(x => console.log(x));\n *\n * @see {@link map}\n *\n * @param {...string} properties The nested properties to pluck from each source\n * value (an object).\n * @return {Observable} A new Observable of property values from the source values.\n * @method pluck\n * @owner Observable\n */\nfunction pluck() {\n    var properties = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        properties[_i - 0] = arguments[_i];\n    }\n    var length = properties.length;\n    if (length === 0) {\n        throw new Error('list of properties cannot be empty.');\n    }\n    return function (source) { return map_1.map(plucker(properties, length))(source); };\n}\nexports.pluck = pluck;\nfunction plucker(props, length) {\n    var mapper = function (x) {\n        var currentProp = x;\n        for (var i = 0; i < length; i++) {\n            var p = currentProp[props[i]];\n            if (typeof p !== 'undefined') {\n                currentProp = p;\n            }\n            else {\n                return undefined;\n            }\n        }\n        return currentProp;\n    };\n    return mapper;\n}\n//# sourceMappingURL=pluck.js.map\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _root = __window || __global || __self;\nexports.root = _root;\n// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.\n// This is needed when used with angular/tsickle which inserts a goog.module statement.\n// Wrap in IIFE\n(function () {\n    if (!_root) {\n        throw new Error('RxJS could not find any global context (window, self, global)');\n    }\n})();\n//# sourceMappingURL=root.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar set_options_effect_1 = __webpack_require__(49);\r\nvar file_reload_effect_1 = __webpack_require__(82);\r\nvar browser_set_location_effect_1 = __webpack_require__(86);\r\nvar simulate_click_effect_1 = __webpack_require__(87);\r\nvar set_element_value_effect_1 = __webpack_require__(88);\r\nvar set_element_toggle_value_effect_1 = __webpack_require__(89);\r\nvar set_scroll_1 = __webpack_require__(148);\r\nvar browser_reload_effect_1 = __webpack_require__(90);\r\nvar EffectNames;\r\n(function (EffectNames) {\r\n    EffectNames[\"FileReload\"] = \"@@FileReload\";\r\n    EffectNames[\"PreBrowserReload\"] = \"@@PreBrowserReload\";\r\n    EffectNames[\"BrowserReload\"] = \"@@BrowserReload\";\r\n    EffectNames[\"BrowserSetLocation\"] = \"@@BrowserSetLocation\";\r\n    EffectNames[\"BrowserSetScroll\"] = \"@@BrowserSetScroll\";\r\n    EffectNames[\"SetOptions\"] = \"@@SetOptions\";\r\n    EffectNames[\"SimulateClick\"] = \"@@SimulateClick\";\r\n    EffectNames[\"SetElementValue\"] = \"@@SetElementValue\";\r\n    EffectNames[\"SetElementToggleValue\"] = \"@@SetElementToggleValue\";\r\n})(EffectNames = exports.EffectNames || (exports.EffectNames = {}));\r\nexports.effectOutputHandlers$ = new BehaviorSubject_1.BehaviorSubject((_a = {},\r\n    _a[EffectNames.SetOptions] = set_options_effect_1.setOptionsEffect,\r\n    _a[EffectNames.FileReload] = file_reload_effect_1.fileReloadEffect,\r\n    _a[EffectNames.BrowserReload] = browser_reload_effect_1.browserReloadEffect,\r\n    _a[EffectNames.BrowserSetLocation] = browser_set_location_effect_1.browserSetLocationEffect,\r\n    _a[EffectNames.SimulateClick] = simulate_click_effect_1.simulateClickEffect,\r\n    _a[EffectNames.SetElementValue] = set_element_value_effect_1.setElementValueEffect,\r\n    _a[EffectNames.SetElementToggleValue] = set_element_toggle_value_effect_1.setElementToggleValueEffect,\r\n    _a[EffectNames.BrowserSetScroll] = set_scroll_1.setScrollEffect,\r\n    _a));\r\nvar _a;\r\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(process) {/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = __webpack_require__(106);\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (!r && typeof process !== 'undefined' && 'env' in process) {\n    r = process.env.DEBUG;\n  }\n\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(58)))\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ArrayObservable_1 = __webpack_require__(25);\nexports.of = ArrayObservable_1.ArrayObservable.of;\n//# sourceMappingURL=of.js.map\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n            t[p] = s[p];\r\n    }\r\n    return t;\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar tap_1 = __webpack_require__(6);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar ScrollEvent_1 = __webpack_require__(81);\r\nvar ClickEvent_1 = __webpack_require__(91);\r\nvar KeyupEvent_1 = __webpack_require__(92);\r\nvar BrowserNotify_1 = __webpack_require__(151);\r\nvar BrowserLocation_1 = __webpack_require__(152);\r\nvar BrowserReload_1 = __webpack_require__(51);\r\nvar FileReload_1 = __webpack_require__(160);\r\nvar Connection_1 = __webpack_require__(161);\r\nvar Disconnect_1 = __webpack_require__(162);\r\nvar FormToggleEvent_1 = __webpack_require__(94);\r\nvar OptionsSet_1 = __webpack_require__(163);\r\nvar IncomingSocketNames;\r\n(function (IncomingSocketNames) {\r\n    IncomingSocketNames[\"Connection\"] = \"connection\";\r\n    IncomingSocketNames[\"Disconnect\"] = \"disconnect\";\r\n    IncomingSocketNames[\"FileReload\"] = \"file:reload\";\r\n    IncomingSocketNames[\"BrowserReload\"] = \"browser:reload\";\r\n    IncomingSocketNames[\"BrowserLocation\"] = \"browser:location\";\r\n    IncomingSocketNames[\"BrowserNotify\"] = \"browser:notify\";\r\n    IncomingSocketNames[\"Scroll\"] = \"scroll\";\r\n    IncomingSocketNames[\"Click\"] = \"click\";\r\n    IncomingSocketNames[\"Keyup\"] = \"input:text\";\r\n    IncomingSocketNames[\"InputToggle\"] = \"input:toggles\";\r\n    IncomingSocketNames[\"OptionsSet\"] = \"options:set\";\r\n})(IncomingSocketNames = exports.IncomingSocketNames || (exports.IncomingSocketNames = {}));\r\nvar OutgoingSocketEvents;\r\n(function (OutgoingSocketEvents) {\r\n    OutgoingSocketEvents[\"Scroll\"] = \"@@outgoing/scroll\";\r\n    OutgoingSocketEvents[\"Click\"] = \"@@outgoing/click\";\r\n    OutgoingSocketEvents[\"Keyup\"] = \"@@outgoing/keyup\";\r\n    OutgoingSocketEvents[\"InputToggle\"] = \"@@outgoing/Toggle\";\r\n})(OutgoingSocketEvents = exports.OutgoingSocketEvents || (exports.OutgoingSocketEvents = {}));\r\nexports.socketHandlers$ = new BehaviorSubject_1.BehaviorSubject((_a = {},\r\n    _a[IncomingSocketNames.Connection] = Connection_1.incomingConnection,\r\n    _a[IncomingSocketNames.Disconnect] = Disconnect_1.incomingDisconnect,\r\n    _a[IncomingSocketNames.FileReload] = FileReload_1.incomingFileReload,\r\n    _a[IncomingSocketNames.BrowserReload] = BrowserReload_1.incomingBrowserReload,\r\n    _a[IncomingSocketNames.BrowserLocation] = BrowserLocation_1.incomingBrowserLocation,\r\n    _a[IncomingSocketNames.BrowserNotify] = BrowserNotify_1.incomingBrowserNotify,\r\n    _a[IncomingSocketNames.Scroll] = ScrollEvent_1.incomingScrollHandler,\r\n    _a[IncomingSocketNames.Click] = ClickEvent_1.incomingHandler$,\r\n    _a[IncomingSocketNames.Keyup] = KeyupEvent_1.incomingKeyupHandler,\r\n    _a[IncomingSocketNames.InputToggle] = FormToggleEvent_1.incomingInputsToggles,\r\n    _a[IncomingSocketNames.OptionsSet] = OptionsSet_1.incomingOptionsSet,\r\n    _a[OutgoingSocketEvents.Scroll] = emitWithPathname(IncomingSocketNames.Scroll),\r\n    _a[OutgoingSocketEvents.Click] = emitWithPathname(IncomingSocketNames.Click),\r\n    _a[OutgoingSocketEvents.Keyup] = emitWithPathname(IncomingSocketNames.Keyup),\r\n    _a[OutgoingSocketEvents.InputToggle] = emitWithPathname(IncomingSocketNames.InputToggle),\r\n    _a));\r\nfunction emitWithPathname(name) {\r\n    return function (xs, inputs) {\r\n        return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.io$, inputs.window$.pipe(pluck_1.pluck(\"location\", \"pathname\"))), tap_1.tap(function (_a) {\r\n            var event = _a[0], io = _a[1], pathname = _a[2];\r\n            return io.emit(name, __assign({}, event, { pathname: pathname }));\r\n        }), ignoreElements_1.ignoreElements());\r\n    };\r\n}\r\nvar _a;\r\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nvar noop_1 = __webpack_require__(54);\n/**\n * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.\n *\n * <img src=\"./img/ignoreElements.png\" width=\"100%\">\n *\n * @return {Observable} An empty Observable that only calls `complete`\n * or `error`, based on which one is called by the source Observable.\n * @method ignoreElements\n * @owner Observable\n */\nfunction ignoreElements() {\n    return function ignoreElementsOperatorFunction(source) {\n        return source.lift(new IgnoreElementsOperator());\n    };\n}\nexports.ignoreElements = ignoreElements;\nvar IgnoreElementsOperator = (function () {\n    function IgnoreElementsOperator() {\n    }\n    IgnoreElementsOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new IgnoreElementsSubscriber(subscriber));\n    };\n    return IgnoreElementsOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar IgnoreElementsSubscriber = (function (_super) {\n    __extends(IgnoreElementsSubscriber, _super);\n    function IgnoreElementsSubscriber() {\n        _super.apply(this, arguments);\n    }\n    IgnoreElementsSubscriber.prototype._next = function (unused) {\n        noop_1.noop();\n    };\n    return IgnoreElementsSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ignoreElements.js.map\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar isArray_1 = __webpack_require__(28);\nvar isObject_1 = __webpack_require__(52);\nvar isFunction_1 = __webpack_require__(40);\nvar tryCatch_1 = __webpack_require__(41);\nvar errorObject_1 = __webpack_require__(29);\nvar UnsubscriptionError_1 = __webpack_require__(100);\n/**\n * Represents a disposable resource, such as the execution of an Observable. A\n * Subscription has one important method, `unsubscribe`, that takes no argument\n * and just disposes the resource held by the subscription.\n *\n * Additionally, subscriptions may be grouped together through the `add()`\n * method, which will attach a child Subscription to the current Subscription.\n * When a Subscription is unsubscribed, all its children (and its grandchildren)\n * will be unsubscribed as well.\n *\n * @class Subscription\n */\nvar Subscription = (function () {\n    /**\n     * @param {function(): void} [unsubscribe] A function describing how to\n     * perform the disposal of resources when the `unsubscribe` method is called.\n     */\n    function Subscription(unsubscribe) {\n        /**\n         * A flag to indicate whether this Subscription has already been unsubscribed.\n         * @type {boolean}\n         */\n        this.closed = false;\n        this._parent = null;\n        this._parents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    /**\n     * Disposes the resources held by the subscription. May, for instance, cancel\n     * an ongoing Observable execution or cancel any other type of work that\n     * started when the Subscription was created.\n     * @return {void}\n     */\n    Subscription.prototype.unsubscribe = function () {\n        var hasErrors = false;\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parent = null;\n        this._parents = null;\n        // null out _subscriptions first so any child subscriptions that attempt\n        // to remove themselves from this subscription will noop\n        this._subscriptions = null;\n        var index = -1;\n        var len = _parents ? _parents.length : 0;\n        // if this._parent is null, then so is this._parents, and we\n        // don't have to remove ourselves from any parent subscriptions.\n        while (_parent) {\n            _parent.remove(this);\n            // if this._parents is null or index >= len,\n            // then _parent is set to null, and the loop exits\n            _parent = ++index < len && _parents[index] || null;\n        }\n        if (isFunction_1.isFunction(_unsubscribe)) {\n            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);\n            if (trial === errorObject_1.errorObject) {\n                hasErrors = true;\n                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?\n                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);\n            }\n        }\n        if (isArray_1.isArray(_subscriptions)) {\n            index = -1;\n            len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject_1.isObject(sub)) {\n                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);\n                    if (trial === errorObject_1.errorObject) {\n                        hasErrors = true;\n                        errors = errors || [];\n                        var err = errorObject_1.errorObject.e;\n                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));\n                        }\n                        else {\n                            errors.push(err);\n                        }\n                    }\n                }\n            }\n        }\n        if (hasErrors) {\n            throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n        }\n    };\n    /**\n     * Adds a tear down to be called during the unsubscribe() of this\n     * Subscription.\n     *\n     * If the tear down being added is a subscription that is already\n     * unsubscribed, is the same reference `add` is being called on, or is\n     * `Subscription.EMPTY`, it will not be added.\n     *\n     * If this subscription is already in an `closed` state, the passed\n     * tear down logic will be executed immediately.\n     *\n     * @param {TeardownLogic} teardown The additional logic to execute on\n     * teardown.\n     * @return {Subscription} Returns the Subscription used or created to be\n     * added to the inner subscriptions list. This Subscription can be used with\n     * `remove()` to remove the passed teardown logic from the inner subscriptions\n     * list.\n     */\n    Subscription.prototype.add = function (teardown) {\n        if (!teardown || (teardown === Subscription.EMPTY)) {\n            return Subscription.EMPTY;\n        }\n        if (teardown === this) {\n            return this;\n        }\n        var subscription = teardown;\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (typeof subscription._addParent !== 'function' /* quack quack */) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default:\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n        }\n        var subscriptions = this._subscriptions || (this._subscriptions = []);\n        subscriptions.push(subscription);\n        subscription._addParent(this);\n        return subscription;\n    };\n    /**\n     * Removes a Subscription from the internal list of subscriptions that will\n     * unsubscribe during the unsubscribe process of this Subscription.\n     * @param {Subscription} subscription The subscription to remove.\n     * @return {void}\n     */\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        if (!_parent || _parent === parent) {\n            // If we don't have a parent, or the new parent is the same as the\n            // current parent, then set this._parent to the new parent.\n            this._parent = parent;\n        }\n        else if (!_parents) {\n            // If there's already one parent, but not multiple, allocate an Array to\n            // store the rest of the parent Subscriptions.\n            this._parents = [parent];\n        }\n        else if (_parents.indexOf(parent) === -1) {\n            // Only add the new parent to the _parents list if it's not already there.\n            _parents.push(parent);\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = __webpack_require__(35);\nvar ObjectUnsubscribedError_1 = __webpack_require__(69);\n/**\n * @class BehaviorSubject<T>\n */\nvar BehaviorSubject = (function (_super) {\n    __extends(BehaviorSubject, _super);\n    function BehaviorSubject(_value) {\n        _super.call(this);\n        this._value = _value;\n    }\n    Object.defineProperty(BehaviorSubject.prototype, \"value\", {\n        get: function () {\n            return this.getValue();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    BehaviorSubject.prototype._subscribe = function (subscriber) {\n        var subscription = _super.prototype._subscribe.call(this, subscriber);\n        if (subscription && !subscription.closed) {\n            subscriber.next(this._value);\n        }\n        return subscription;\n    };\n    BehaviorSubject.prototype.getValue = function () {\n        if (this.hasError) {\n            throw this.thrownError;\n        }\n        else if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return this._value;\n        }\n    };\n    BehaviorSubject.prototype.next = function (value) {\n        _super.prototype.next.call(this, this._value = value);\n    };\n    return BehaviorSubject;\n}(Subject_1.Subject));\nexports.BehaviorSubject = BehaviorSubject;\n//# sourceMappingURL=BehaviorSubject.js.map\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar timer_1 = __webpack_require__(48);\r\nvar of_1 = __webpack_require__(11);\r\nvar logger_1 = __webpack_require__(135);\r\nvar filter_1 = __webpack_require__(4);\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar pluck_1 = __webpack_require__(7);\r\nfunction initLogger(options) {\r\n    var log = new logger_1.Nanologger(options.logPrefix, {\r\n        colors: { magenta: \"#0F2634\" }\r\n    });\r\n    return of_1.of(log);\r\n}\r\nexports.initLogger = initLogger;\r\nvar LogNames;\r\n(function (LogNames) {\r\n    LogNames[\"Log\"] = \"@@Log\";\r\n    LogNames[\"Info\"] = \"@@Log.info\";\r\n    LogNames[\"Debug\"] = \"@@Log.debug\";\r\n})(LogNames = exports.LogNames || (exports.LogNames = {}));\r\nvar Overlay;\r\n(function (Overlay) {\r\n    Overlay[\"Info\"] = \"@@Overlay.info\";\r\n})(Overlay = exports.Overlay || (exports.Overlay = {}));\r\nfunction consoleInfo() {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return [LogNames.Log, [LogNames.Info, args]];\r\n}\r\nexports.consoleInfo = consoleInfo;\r\nfunction consoleDebug() {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return [LogNames.Log, [LogNames.Debug, args]];\r\n}\r\nexports.consoleDebug = consoleDebug;\r\nfunction overlayInfo(message, timeout) {\r\n    if (timeout === void 0) { timeout = 2000; }\r\n    return [Overlay.Info, [message, timeout]];\r\n}\r\nexports.overlayInfo = overlayInfo;\r\nexports.logHandler$ = new BehaviorSubject_1.BehaviorSubject((_a = {},\r\n    _a[LogNames.Log] = function (xs, inputs) {\r\n        return xs.pipe(\r\n        /**\r\n         * access injectNotification from the options stream\r\n         */\r\n        withLatestFrom_1.withLatestFrom(inputs.logInstance$, inputs.option$.pipe(pluck_1.pluck(\"injectNotification\"))), \r\n        /**\r\n         * only accept messages if injectNotification !== console\r\n         */\r\n        filter_1.filter(function (_a) {\r\n            var injectNotification = _a[2];\r\n            return injectNotification === \"console\";\r\n        }), tap_1.tap(function (_a) {\r\n            var event = _a[0], log = _a[1];\r\n            switch (event[0]) {\r\n                case LogNames.Info: {\r\n                    return log.info.apply(log, event[1]);\r\n                }\r\n                case LogNames.Debug: {\r\n                    return log.debug.apply(log, event[1]);\r\n                }\r\n            }\r\n        }));\r\n    },\r\n    _a[Overlay.Info] = function (xs, inputs) {\r\n        return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$, inputs.notifyElement$, inputs.document$), \r\n        /**\r\n         * Reject all notifications if notify: false\r\n         */\r\n        filter_1.filter(function (_a) {\r\n            var options = _a[1];\r\n            return Boolean(options.notify);\r\n        }), \r\n        /**\r\n         * Set the HTML of the notify element\r\n         */\r\n        tap_1.tap(function (_a) {\r\n            var event = _a[0], options = _a[1], element = _a[2], document = _a[3];\r\n            element.innerHTML = event[0];\r\n            element.style.display = \"block\";\r\n            document.body.appendChild(element);\r\n        }), \r\n        /**\r\n         * Now remove the element after the given timeout\r\n         */\r\n        switchMap_1.switchMap(function (_a) {\r\n            var event = _a[0], options = _a[1], element = _a[2], document = _a[3];\r\n            return timer_1.timer(event[1] || 2000).pipe(tap_1.tap(function () {\r\n                element.style.display = \"none\";\r\n                if (element.parentNode) {\r\n                    document.body.removeChild(element);\r\n                }\r\n            }));\r\n        }));\r\n    },\r\n    _a));\r\nvar _a;\r\n\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar subscribeToResult_1 = __webpack_require__(31);\nvar OuterSubscriber_1 = __webpack_require__(30);\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return function mergeMapOperatorFunction(source) {\n        if (typeof resultSelector === 'number') {\n            concurrent = resultSelector;\n            resultSelector = null;\n        }\n        return source.lift(new MergeMapOperator(project, resultSelector, concurrent));\n    };\n}\nexports.mergeMap = mergeMap;\nvar MergeMapOperator = (function () {\n    function MergeMapOperator(project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n    }\n    MergeMapOperator.prototype.call = function (observer, source) {\n        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent));\n    };\n    return MergeMapOperator;\n}());\nexports.MergeMapOperator = MergeMapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MergeMapSubscriber = (function (_super) {\n    __extends(MergeMapSubscriber, _super);\n    function MergeMapSubscriber(destination, project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n        this.hasCompleted = false;\n        this.buffer = [];\n        this.active = 0;\n        this.index = 0;\n    }\n    MergeMapSubscriber.prototype._next = function (value) {\n        if (this.active < this.concurrent) {\n            this._tryNext(value);\n        }\n        else {\n            this.buffer.push(value);\n        }\n    };\n    MergeMapSubscriber.prototype._tryNext = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.active++;\n        this._innerSub(result, value, index);\n    };\n    MergeMapSubscriber.prototype._innerSub = function (ish, value, index) {\n        this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index));\n    };\n    MergeMapSubscriber.prototype._complete = function () {\n        this.hasCompleted = true;\n        if (this.active === 0 && this.buffer.length === 0) {\n            this.destination.complete();\n        }\n    };\n    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    MergeMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var buffer = this.buffer;\n        this.remove(innerSub);\n        this.active--;\n        if (buffer.length > 0) {\n            this._next(buffer.shift());\n        }\n        else if (this.active === 0 && this.hasCompleted) {\n            this.destination.complete();\n        }\n    };\n    return MergeMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.MergeMapSubscriber = MergeMapSubscriber;\n//# sourceMappingURL=mergeMap.js.map\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar EmptyObservable_1 = __webpack_require__(26);\nexports.empty = EmptyObservable_1.EmptyObservable.create;\n//# sourceMappingURL=empty.js.map\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\r\n/**\r\n * Expose `Emitter`.\r\n */\r\n\r\nif (true) {\r\n  module.exports = Emitter;\r\n}\r\n\r\n/**\r\n * Initialize a new `Emitter`.\r\n *\r\n * @api public\r\n */\r\n\r\nfunction Emitter(obj) {\r\n  if (obj) return mixin(obj);\r\n};\r\n\r\n/**\r\n * Mixin the emitter properties.\r\n *\r\n * @param {Object} obj\r\n * @return {Object}\r\n * @api private\r\n */\r\n\r\nfunction mixin(obj) {\r\n  for (var key in Emitter.prototype) {\r\n    obj[key] = Emitter.prototype[key];\r\n  }\r\n  return obj;\r\n}\r\n\r\n/**\r\n * Listen on the given `event` with `fn`.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.on =\r\nEmitter.prototype.addEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n    .push(fn);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Adds an `event` listener that will be invoked a single\r\n * time then automatically removed.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.once = function(event, fn){\r\n  function on() {\r\n    this.off(event, on);\r\n    fn.apply(this, arguments);\r\n  }\r\n\r\n  on.fn = fn;\r\n  this.on(event, on);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove the given callback for `event` or all\r\n * registered callbacks.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.off =\r\nEmitter.prototype.removeListener =\r\nEmitter.prototype.removeAllListeners =\r\nEmitter.prototype.removeEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n\r\n  // all\r\n  if (0 == arguments.length) {\r\n    this._callbacks = {};\r\n    return this;\r\n  }\r\n\r\n  // specific event\r\n  var callbacks = this._callbacks['$' + event];\r\n  if (!callbacks) return this;\r\n\r\n  // remove all handlers\r\n  if (1 == arguments.length) {\r\n    delete this._callbacks['$' + event];\r\n    return this;\r\n  }\r\n\r\n  // remove specific handler\r\n  var cb;\r\n  for (var i = 0; i < callbacks.length; i++) {\r\n    cb = callbacks[i];\r\n    if (cb === fn || cb.fn === fn) {\r\n      callbacks.splice(i, 1);\r\n      break;\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Emit `event` with the given args.\r\n *\r\n * @param {String} event\r\n * @param {Mixed} ...\r\n * @return {Emitter}\r\n */\r\n\r\nEmitter.prototype.emit = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  var args = [].slice.call(arguments, 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  if (callbacks) {\r\n    callbacks = callbacks.slice(0);\r\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n      callbacks[i].apply(this, args);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return array of callbacks for `event`.\r\n *\r\n * @param {String} event\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.listeners = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  return this._callbacks['$' + event] || [];\r\n};\r\n\r\n/**\r\n * Check if this emitter has `event` handlers.\r\n *\r\n * @param {String} event\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.hasListeners = function(event){\r\n  return !! this.listeners(event).length;\r\n};\r\n\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies.\n */\n\nvar keys = __webpack_require__(115);\nvar hasBinary = __webpack_require__(59);\nvar sliceBuffer = __webpack_require__(116);\nvar after = __webpack_require__(117);\nvar utf8 = __webpack_require__(118);\n\nvar base64encoder;\nif (global && global.ArrayBuffer) {\n  base64encoder = __webpack_require__(120);\n}\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n    open:     0    // non-ws\n  , close:    1    // non-ws\n  , ping:     2\n  , pong:     3\n  , message:  4\n  , upgrade:  5\n  , noop:     6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = __webpack_require__(121);\n\n/**\n * Encodes a packet.\n *\n *     <packet type id> [ <data> ]\n *\n * Example:\n *\n *     5hello world\n *     3\n *     4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = false;\n  }\n\n  if (typeof utf8encode === 'function') {\n    callback = utf8encode;\n    utf8encode = null;\n  }\n\n  var data = (packet.data === undefined)\n    ? undefined\n    : packet.data.buffer || packet.data;\n\n  if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n    return encodeArrayBuffer(packet, supportsBinary, callback);\n  } else if (Blob && data instanceof global.Blob) {\n    return encodeBlob(packet, supportsBinary, callback);\n  }\n\n  // might be an object with { base64: true, data: dataAsBase64String }\n  if (data && data.base64) {\n    return encodeBase64Object(packet, callback);\n  }\n\n  // Sending data as a utf-8 string\n  var encoded = packets[packet.type];\n\n  // data fragment is optional\n  if (undefined !== packet.data) {\n    encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);\n  }\n\n  return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n  // packet data is an object { base64: true, data: dataAsBase64String }\n  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n  return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var data = packet.data;\n  var contentArray = new Uint8Array(data);\n  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n  resultBuffer[0] = packets[packet.type];\n  for (var i = 0; i < contentArray.length; i++) {\n    resultBuffer[i+1] = contentArray[i];\n  }\n\n  return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var fr = new FileReader();\n  fr.onload = function() {\n    packet.data = fr.result;\n    exports.encodePacket(packet, supportsBinary, true, callback);\n  };\n  return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  if (dontSendBlobs) {\n    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n  }\n\n  var length = new Uint8Array(1);\n  length[0] = packets[packet.type];\n  var blob = new Blob([length.buffer, packet.data]);\n\n  return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n  var message = 'b' + exports.packets[packet.type];\n  if (Blob && packet.data instanceof global.Blob) {\n    var fr = new FileReader();\n    fr.onload = function() {\n      var b64 = fr.result.split(',')[1];\n      callback(message + b64);\n    };\n    return fr.readAsDataURL(packet.data);\n  }\n\n  var b64data;\n  try {\n    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n  } catch (e) {\n    // iPhone Safari doesn't let you apply with typed arrays\n    var typed = new Uint8Array(packet.data);\n    var basic = new Array(typed.length);\n    for (var i = 0; i < typed.length; i++) {\n      basic[i] = typed[i];\n    }\n    b64data = String.fromCharCode.apply(null, basic);\n  }\n  message += global.btoa(b64data);\n  return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n  if (data === undefined) {\n    return err;\n  }\n  // String data\n  if (typeof data === 'string') {\n    if (data.charAt(0) === 'b') {\n      return exports.decodeBase64Packet(data.substr(1), binaryType);\n    }\n\n    if (utf8decode) {\n      data = tryDecode(data);\n      if (data === false) {\n        return err;\n      }\n    }\n    var type = data.charAt(0);\n\n    if (Number(type) != type || !packetslist[type]) {\n      return err;\n    }\n\n    if (data.length > 1) {\n      return { type: packetslist[type], data: data.substring(1) };\n    } else {\n      return { type: packetslist[type] };\n    }\n  }\n\n  var asArray = new Uint8Array(data);\n  var type = asArray[0];\n  var rest = sliceBuffer(data, 1);\n  if (Blob && binaryType === 'blob') {\n    rest = new Blob([rest]);\n  }\n  return { type: packetslist[type], data: rest };\n};\n\nfunction tryDecode(data) {\n  try {\n    data = utf8.decode(data, { strict: false });\n  } catch (e) {\n    return false;\n  }\n  return data;\n}\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n  var type = packetslist[msg.charAt(0)];\n  if (!base64encoder) {\n    return { type: type, data: { base64: true, data: msg.substr(1) } };\n  }\n\n  var data = base64encoder.decode(msg.substr(1));\n\n  if (binaryType === 'blob' && Blob) {\n    data = new Blob([data]);\n  }\n\n  return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n *     <length>:data\n *\n * Example:\n *\n *     11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = null;\n  }\n\n  var isBinary = hasBinary(packets);\n\n  if (supportsBinary && isBinary) {\n    if (Blob && !dontSendBlobs) {\n      return exports.encodePayloadAsBlob(packets, callback);\n    }\n\n    return exports.encodePayloadAsArrayBuffer(packets, callback);\n  }\n\n  if (!packets.length) {\n    return callback('0:');\n  }\n\n  function setLengthHeader(message) {\n    return message.length + ':' + message;\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, !isBinary ? false : supportsBinary, false, function(message) {\n      doneCallback(null, setLengthHeader(message));\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(results.join(''));\n  });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n  var result = new Array(ary.length);\n  var next = after(ary.length, done);\n\n  var eachWithIndex = function(i, el, cb) {\n    each(el, function(error, msg) {\n      result[i] = msg;\n      cb(error, result);\n    });\n  };\n\n  for (var i = 0; i < ary.length; i++) {\n    eachWithIndex(i, ary[i], next);\n  }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n  if (typeof data !== 'string') {\n    return exports.decodePayloadAsBinary(data, binaryType, callback);\n  }\n\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var packet;\n  if (data === '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n  var length = '', n, msg;\n\n  for (var i = 0, l = data.length; i < l; i++) {\n    var chr = data.charAt(i);\n\n    if (chr !== ':') {\n      length += chr;\n      continue;\n    }\n\n    if (length === '' || (length != (n = Number(length)))) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    msg = data.substr(i + 1, n);\n\n    if (length != msg.length) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    if (msg.length) {\n      packet = exports.decodePacket(msg, binaryType, false);\n\n      if (err.type === packet.type && err.data === packet.data) {\n        // parser error in individual packet - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      var ret = callback(packet, i + n, l);\n      if (false === ret) return;\n    }\n\n    // advance cursor\n    i += n;\n    length = '';\n  }\n\n  if (length !== '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n  if (!packets.length) {\n    return callback(new ArrayBuffer(0));\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(data) {\n      return doneCallback(null, data);\n    });\n  }\n\n  map(packets, encodeOne, function(err, encodedPackets) {\n    var totalLength = encodedPackets.reduce(function(acc, p) {\n      var len;\n      if (typeof p === 'string'){\n        len = p.length;\n      } else {\n        len = p.byteLength;\n      }\n      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n    }, 0);\n\n    var resultArray = new Uint8Array(totalLength);\n\n    var bufferIndex = 0;\n    encodedPackets.forEach(function(p) {\n      var isString = typeof p === 'string';\n      var ab = p;\n      if (isString) {\n        var view = new Uint8Array(p.length);\n        for (var i = 0; i < p.length; i++) {\n          view[i] = p.charCodeAt(i);\n        }\n        ab = view.buffer;\n      }\n\n      if (isString) { // not true binary\n        resultArray[bufferIndex++] = 0;\n      } else { // true binary\n        resultArray[bufferIndex++] = 1;\n      }\n\n      var lenStr = ab.byteLength.toString();\n      for (var i = 0; i < lenStr.length; i++) {\n        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n      }\n      resultArray[bufferIndex++] = 255;\n\n      var view = new Uint8Array(ab);\n      for (var i = 0; i < view.length; i++) {\n        resultArray[bufferIndex++] = view[i];\n      }\n    });\n\n    return callback(resultArray.buffer);\n  });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(encoded) {\n      var binaryIdentifier = new Uint8Array(1);\n      binaryIdentifier[0] = 1;\n      if (typeof encoded === 'string') {\n        var view = new Uint8Array(encoded.length);\n        for (var i = 0; i < encoded.length; i++) {\n          view[i] = encoded.charCodeAt(i);\n        }\n        encoded = view.buffer;\n        binaryIdentifier[0] = 0;\n      }\n\n      var len = (encoded instanceof ArrayBuffer)\n        ? encoded.byteLength\n        : encoded.size;\n\n      var lenStr = len.toString();\n      var lengthAry = new Uint8Array(lenStr.length + 1);\n      for (var i = 0; i < lenStr.length; i++) {\n        lengthAry[i] = parseInt(lenStr[i]);\n      }\n      lengthAry[lenStr.length] = 255;\n\n      if (Blob) {\n        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n        doneCallback(null, blob);\n      }\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(new Blob(results));\n  });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var bufferTail = data;\n  var buffers = [];\n\n  while (bufferTail.byteLength > 0) {\n    var tailArray = new Uint8Array(bufferTail);\n    var isString = tailArray[0] === 0;\n    var msgLength = '';\n\n    for (var i = 1; ; i++) {\n      if (tailArray[i] === 255) break;\n\n      // 310 = char length of Number.MAX_VALUE\n      if (msgLength.length > 310) {\n        return callback(err, 0, 1);\n      }\n\n      msgLength += tailArray[i];\n    }\n\n    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n    msgLength = parseInt(msgLength);\n\n    var msg = sliceBuffer(bufferTail, 0, msgLength);\n    if (isString) {\n      try {\n        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n      } catch (e) {\n        // iPhone Safari doesn't let you apply to typed arrays\n        var typed = new Uint8Array(msg);\n        msg = '';\n        for (var i = 0; i < typed.length; i++) {\n          msg += String.fromCharCode(typed[i]);\n        }\n      }\n    }\n\n    buffers.push(msg);\n    bufferTail = sliceBuffer(bufferTail, msgLength);\n  }\n\n  var total = buffers.length;\n  buffers.forEach(function(buffer, i) {\n    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n  });\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar prop_set_dom_effect_1 = __webpack_require__(72);\r\nvar style_set_dom_effect_1 = __webpack_require__(77);\r\nvar link_replace_dom_effect_1 = __webpack_require__(78);\r\nvar set_scroll_dom_effect_1 = __webpack_require__(79);\r\nvar set_window_name_dom_effect_1 = __webpack_require__(80);\r\nvar Events;\r\n(function (Events) {\r\n    Events[\"PropSet\"] = \"@@BSDOM.Events.PropSet\";\r\n    Events[\"StyleSet\"] = \"@@BSDOM.Events.StyleSet\";\r\n    Events[\"LinkReplace\"] = \"@@BSDOM.Events.LinkReplace\";\r\n    Events[\"SetScroll\"] = \"@@BSDOM.Events.SetScroll\";\r\n    Events[\"SetWindowName\"] = \"@@BSDOM.Events.SetWindowName\";\r\n})(Events = exports.Events || (exports.Events = {}));\r\nexports.domHandlers$ = new BehaviorSubject_1.BehaviorSubject((_a = {},\r\n    _a[Events.PropSet] = prop_set_dom_effect_1.propSetDomEffect,\r\n    _a[Events.StyleSet] = style_set_dom_effect_1.styleSetDomEffect,\r\n    _a[Events.LinkReplace] = link_replace_dom_effect_1.linkReplaceDomEffect,\r\n    _a[Events.SetScroll] = set_scroll_dom_effect_1.setScrollDomEffect,\r\n    _a[Events.SetWindowName] = set_window_name_dom_effect_1.setWindowNameDomEffect,\r\n    _a));\r\nvar _a;\r\n\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = __webpack_require__(30);\nvar subscribeToResult_1 = __webpack_require__(31);\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, emitting values only from the most recently projected Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link switch}.</span>\n *\n * <img src=\"./img/switchMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each time it observes one of these\n * inner Observables, the output Observable begins emitting the items emitted by\n * that inner Observable. When a new inner Observable is emitted, `switchMap`\n * stops emitting items from the earlier-emitted inner Observable and begins\n * emitting items from the new one. It continues to behave like this for\n * subsequent inner Observables.\n *\n * @example <caption>Rerun an interval Observable on every click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));\n * result.subscribe(x => console.log(x));\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switch}\n * @see {@link switchMapTo}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking only the values from the most recently\n * projected inner Observable.\n * @method switchMap\n * @owner Observable\n */\nfunction switchMap(project, resultSelector) {\n    return function switchMapOperatorFunction(source) {\n        return source.lift(new SwitchMapOperator(project, resultSelector));\n    };\n}\nexports.switchMap = switchMap;\nvar SwitchMapOperator = (function () {\n    function SwitchMapOperator(project, resultSelector) {\n        this.project = project;\n        this.resultSelector = resultSelector;\n    }\n    SwitchMapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new SwitchMapSubscriber(subscriber, this.project, this.resultSelector));\n    };\n    return SwitchMapOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SwitchMapSubscriber = (function (_super) {\n    __extends(SwitchMapSubscriber, _super);\n    function SwitchMapSubscriber(destination, project, resultSelector) {\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.index = 0;\n    }\n    SwitchMapSubscriber.prototype._next = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (error) {\n            this.destination.error(error);\n            return;\n        }\n        this._innerSub(result, value, index);\n    };\n    SwitchMapSubscriber.prototype._innerSub = function (result, value, index) {\n        var innerSubscription = this.innerSubscription;\n        if (innerSubscription) {\n            innerSubscription.unsubscribe();\n        }\n        this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, result, value, index));\n    };\n    SwitchMapSubscriber.prototype._complete = function () {\n        var innerSubscription = this.innerSubscription;\n        if (!innerSubscription || innerSubscription.closed) {\n            _super.prototype._complete.call(this);\n        }\n    };\n    SwitchMapSubscriber.prototype._unsubscribe = function () {\n        this.innerSubscription = null;\n    };\n    SwitchMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.remove(innerSub);\n        this.innerSubscription = null;\n        if (this.isStopped) {\n            _super.prototype._complete.call(this);\n        }\n    };\n    SwitchMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    SwitchMapSubscriber.prototype._tryNotifyNext = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return SwitchMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=switchMap.js.map\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar concat_1 = __webpack_require__(50);\r\nvar timer_1 = __webpack_require__(48);\r\nvar of_1 = __webpack_require__(11);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar startWith_1 = __webpack_require__(145);\r\nvar mapTo_1 = __webpack_require__(85);\r\nfunction each(incoming) {\r\n    return [].slice.call(incoming || []);\r\n}\r\nexports.each = each;\r\nexports.splitUrl = function (url) {\r\n    var hash, index, params;\r\n    if ((index = url.indexOf(\"#\")) >= 0) {\r\n        hash = url.slice(index);\r\n        url = url.slice(0, index);\r\n    }\r\n    else {\r\n        hash = \"\";\r\n    }\r\n    if ((index = url.indexOf(\"?\")) >= 0) {\r\n        params = url.slice(index);\r\n        url = url.slice(0, index);\r\n    }\r\n    else {\r\n        params = \"\";\r\n    }\r\n    return { url: url, params: params, hash: hash };\r\n};\r\nexports.pathFromUrl = function (url) {\r\n    var path;\r\n    (url = exports.splitUrl(url).url);\r\n    if (url.indexOf(\"file://\") === 0) {\r\n        path = url.replace(new RegExp(\"^file://(localhost)?\"), \"\");\r\n    }\r\n    else {\r\n        //                        http  :   // hostname  :8080  /\r\n        path = url.replace(new RegExp(\"^([^:]+:)?//([^:/]+)(:\\\\d*)?/\"), \"/\");\r\n    }\r\n    // decodeURI has special handling of stuff like semicolons, so use decodeURIComponent\r\n    return decodeURIComponent(path);\r\n};\r\nexports.pickBestMatch = function (path, objects, pathFunc) {\r\n    var score;\r\n    var bestMatch = { score: 0, object: null };\r\n    objects.forEach(function (object) {\r\n        score = exports.numberOfMatchingSegments(path, pathFunc(object));\r\n        if (score > bestMatch.score) {\r\n            bestMatch = { object: object, score: score };\r\n        }\r\n    });\r\n    if (bestMatch.score > 0) {\r\n        return bestMatch;\r\n    }\r\n    else {\r\n        return null;\r\n    }\r\n};\r\nexports.numberOfMatchingSegments = function (path1, path2) {\r\n    // get rid of leading slashes and normalize to lower case\r\n    path1 = path1.replace(/^\\/+/, \"\").toLowerCase();\r\n    path2 = path2.replace(/^\\/+/, \"\").toLowerCase();\r\n    if (path1 === path2) {\r\n        return 10000;\r\n    }\r\n    var comps1 = path1.split(\"/\").reverse();\r\n    var comps2 = path2.split(\"/\").reverse();\r\n    var len = Math.min(comps1.length, comps2.length);\r\n    var eqCount = 0;\r\n    while (eqCount < len && comps1[eqCount] === comps2[eqCount]) {\r\n        ++eqCount;\r\n    }\r\n    return eqCount;\r\n};\r\nexports.pathsMatch = function (path1, path2) {\r\n    return exports.numberOfMatchingSegments(path1, path2) > 0;\r\n};\r\nfunction getLocation(url) {\r\n    var location = document.createElement(\"a\");\r\n    location.href = url;\r\n    if (location.host === \"\") {\r\n        location.href = location.href;\r\n    }\r\n    return location;\r\n}\r\nexports.getLocation = getLocation;\r\n/**\r\n * @param {string} search\r\n * @param {string} key\r\n * @param {string} suffix\r\n */\r\nfunction updateSearch(search, key, suffix) {\r\n    if (search === \"\") {\r\n        return \"?\" + suffix;\r\n    }\r\n    return (\"?\" +\r\n        search\r\n            .slice(1)\r\n            .split(\"&\")\r\n            .map(function (item) {\r\n            return item.split(\"=\");\r\n        })\r\n            .filter(function (tuple) {\r\n            return tuple[0] !== key;\r\n        })\r\n            .map(function (item) {\r\n            return [item[0], item[1]].join(\"=\");\r\n        })\r\n            .concat(suffix)\r\n            .join(\"&\"));\r\n}\r\nexports.updateSearch = updateSearch;\r\nvar blacklist = [\r\n    // never allow .map files through\r\n    function (incoming) {\r\n        return incoming.ext === \"map\";\r\n    }\r\n];\r\n/**\r\n * @param incoming\r\n * @returns {boolean}\r\n */\r\nfunction isBlacklisted(incoming) {\r\n    return blacklist.some(function (fn) {\r\n        return fn(incoming);\r\n    });\r\n}\r\nexports.isBlacklisted = isBlacklisted;\r\nfunction createTimedBooleanSwitch(source$, timeout) {\r\n    if (timeout === void 0) { timeout = 1000; }\r\n    return source$.pipe(switchMap_1.switchMap(function () {\r\n        return concat_1.concat(of_1.of(false), timer_1.timer(timeout).pipe(mapTo_1.mapTo(true)));\r\n    }), startWith_1.startWith(true));\r\n}\r\nexports.createTimedBooleanSwitch = createTimedBooleanSwitch;\r\nfunction array(incoming) {\r\n    return [].slice.call(incoming);\r\n}\r\nexports.array = array;\r\n\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction getWindow() {\r\n    return window;\r\n}\r\nexports.getWindow = getWindow;\r\n/**\r\n * @returns {HTMLDocument}\r\n */\r\nfunction getDocument() {\r\n    return document;\r\n}\r\nexports.getDocument = getDocument;\r\n/**\r\n * Get the current x/y position crossbow\r\n * @returns {{x: *, y: *}}\r\n */\r\nfunction getBrowserScrollPosition(window, document) {\r\n    var scrollX;\r\n    var scrollY;\r\n    var dElement = document.documentElement;\r\n    var dBody = document.body;\r\n    if (window.pageYOffset !== undefined) {\r\n        scrollX = window.pageXOffset;\r\n        scrollY = window.pageYOffset;\r\n    }\r\n    else {\r\n        scrollX = dElement.scrollLeft || dBody.scrollLeft || 0;\r\n        scrollY = dElement.scrollTop || dBody.scrollTop || 0;\r\n    }\r\n    return {\r\n        x: scrollX,\r\n        y: scrollY\r\n    };\r\n}\r\nexports.getBrowserScrollPosition = getBrowserScrollPosition;\r\n/**\r\n * @returns {{x: number, y: number}}\r\n */\r\nfunction getDocumentScrollSpace(document) {\r\n    var dElement = document.documentElement;\r\n    var dBody = document.body;\r\n    return {\r\n        x: dBody.scrollHeight - dElement.clientWidth,\r\n        y: dBody.scrollHeight - dElement.clientHeight\r\n    };\r\n}\r\nexports.getDocumentScrollSpace = getDocumentScrollSpace;\r\n/**\r\n * Saves scroll position into cookies\r\n */\r\nfunction saveScrollPosition(window, document) {\r\n    var pos = getBrowserScrollPosition(window, document);\r\n    document.cookie = \"bs_scroll_pos=\" + [pos.x, pos.y].join(\",\");\r\n}\r\nexports.saveScrollPosition = saveScrollPosition;\r\n/**\r\n * Restores scroll position from cookies\r\n */\r\nfunction restoreScrollPosition() {\r\n    var pos = getDocument()\r\n        .cookie.replace(/(?:(?:^|.*;\\s*)bs_scroll_pos\\s*\\=\\s*([^;]*).*$)|^.*$/, \"$1\")\r\n        .split(\",\");\r\n    getWindow().scrollTo(Number(pos[0]), Number(pos[1]));\r\n}\r\nexports.restoreScrollPosition = restoreScrollPosition;\r\n/**\r\n * @param tagName\r\n * @param elem\r\n * @returns {*|number}\r\n */\r\nfunction getElementIndex(tagName, elem) {\r\n    var allElems = getDocument().getElementsByTagName(tagName);\r\n    return Array.prototype.indexOf.call(allElems, elem);\r\n}\r\nexports.getElementIndex = getElementIndex;\r\n/**\r\n * Force Change event on radio & checkboxes (IE)\r\n */\r\nfunction forceChange(elem) {\r\n    elem.blur();\r\n    elem.focus();\r\n}\r\nexports.forceChange = forceChange;\r\n/**\r\n * @param elem\r\n * @returns {{tagName: (elem.tagName|*), index: *}}\r\n */\r\nfunction getElementData(elem) {\r\n    var tagName = elem.tagName;\r\n    var index = getElementIndex(tagName, elem);\r\n    return {\r\n        tagName: tagName,\r\n        index: index\r\n    };\r\n}\r\nexports.getElementData = getElementData;\r\n/**\r\n * @param {string} tagName\r\n * @param {number} index\r\n */\r\nfunction getSingleElement(tagName, index) {\r\n    var elems = getDocument().getElementsByTagName(tagName);\r\n    return elems[index];\r\n}\r\nexports.getSingleElement = getSingleElement;\r\n/**\r\n * Get the body element\r\n */\r\nfunction getBody() {\r\n    return getDocument().getElementsByTagName(\"body\")[0];\r\n}\r\nexports.getBody = getBody;\r\n/**\r\n * @param {{x: number, y: number}} pos\r\n */\r\nfunction setScroll(pos) {\r\n    getWindow().scrollTo(pos.x, pos.y);\r\n}\r\nexports.setScroll = setScroll;\r\n/**\r\n * Hard reload\r\n */\r\nfunction reloadBrowser() {\r\n    getWindow().location.reload(true);\r\n}\r\nexports.reloadBrowser = reloadBrowser;\r\n/**\r\n * Foreach polyfill\r\n * @param coll\r\n * @param fn\r\n */\r\nfunction forEach(coll, fn) {\r\n    for (var i = 0, n = coll.length; i < n; i += 1) {\r\n        fn(coll[i], i, coll);\r\n    }\r\n}\r\nexports.forEach = forEach;\r\n/**\r\n * Are we dealing with old IE?\r\n * @returns {boolean}\r\n */\r\nfunction isOldIe() {\r\n    return typeof getWindow().attachEvent !== \"undefined\";\r\n}\r\nexports.isOldIe = isOldIe;\r\n/**\r\n * Split the URL information\r\n * @returns {object}\r\n */\r\nfunction getLocation(url) {\r\n    var location = getDocument().createElement(\"a\");\r\n    location.href = url;\r\n    if (location.host === \"\") {\r\n        location.href = location.href;\r\n    }\r\n    return location;\r\n}\r\nexports.getLocation = getLocation;\r\n/**\r\n * @param {String} val\r\n * @returns {boolean}\r\n */\r\nfunction isUndefined(val) {\r\n    return \"undefined\" === typeof val;\r\n}\r\nexports.isUndefined = isUndefined;\r\n/**\r\n * @param obj\r\n * @param path\r\n */\r\nfunction getByPath(obj, path) {\r\n    for (var i = 0, tempPath = path.split(\".\"), len = tempPath.length; i < len; i++) {\r\n        if (!obj || typeof obj !== \"object\") {\r\n            return false;\r\n        }\r\n        obj = obj[tempPath[i]];\r\n    }\r\n    if (typeof obj === \"undefined\") {\r\n        return false;\r\n    }\r\n    return obj;\r\n}\r\nexports.getByPath = getByPath;\r\nfunction getScrollPosition(window, document) {\r\n    var pos = getBrowserScrollPosition(window, document);\r\n    return {\r\n        raw: pos,\r\n        proportional: getScrollTopPercentage(pos, document) // Get % of y axis of scroll\r\n    };\r\n}\r\nexports.getScrollPosition = getScrollPosition;\r\nfunction getScrollPositionForElement(element) {\r\n    var raw = {\r\n        x: element.scrollLeft,\r\n        y: element.scrollTop\r\n    };\r\n    var scrollSpace = {\r\n        x: element.scrollWidth,\r\n        y: element.scrollHeight\r\n    };\r\n    return {\r\n        raw: raw,\r\n        proportional: getScrollPercentage(scrollSpace, raw).y // Get % of y axis of scroll\r\n    };\r\n}\r\nexports.getScrollPositionForElement = getScrollPositionForElement;\r\nfunction getScrollTopPercentage(pos, document) {\r\n    var scrollSpace = getDocumentScrollSpace(document);\r\n    var percentage = getScrollPercentage(scrollSpace, pos);\r\n    return percentage.y;\r\n}\r\nexports.getScrollTopPercentage = getScrollTopPercentage;\r\nfunction getScrollPercentage(scrollSpace, scrollPosition) {\r\n    var x = scrollPosition.x / scrollSpace.x;\r\n    var y = scrollPosition.y / scrollSpace.y;\r\n    return {\r\n        x: x || 0,\r\n        y: y\r\n    };\r\n}\r\nexports.getScrollPercentage = getScrollPercentage;\r\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\nvar ScalarObservable_1 = __webpack_require__(44);\nvar EmptyObservable_1 = __webpack_require__(26);\nvar isScheduler_1 = __webpack_require__(27);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayObservable = (function (_super) {\n    __extends(ArrayObservable, _super);\n    function ArrayObservable(array, scheduler) {\n        _super.call(this);\n        this.array = array;\n        this.scheduler = scheduler;\n        if (!scheduler && array.length === 1) {\n            this._isScalar = true;\n            this.value = array[0];\n        }\n    }\n    ArrayObservable.create = function (array, scheduler) {\n        return new ArrayObservable(array, scheduler);\n    };\n    /**\n     * Creates an Observable that emits some values you specify as arguments,\n     * immediately one after the other, and then emits a complete notification.\n     *\n     * <span class=\"informal\">Emits the arguments you provide, then completes.\n     * </span>\n     *\n     * <img src=\"./img/of.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the arguments given, and the complete notification thereafter. It can\n     * be used for composing with other Observables, such as with {@link concat}.\n     * By default, it uses a `null` IScheduler, which means the `next`\n     * notifications are sent synchronously, although with a different IScheduler\n     * it is possible to determine when those notifications will be delivered.\n     *\n     * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>\n     * var numbers = Rx.Observable.of(10, 20, 30);\n     * var letters = Rx.Observable.of('a', 'b', 'c');\n     * var interval = Rx.Observable.interval(1000);\n     * var result = numbers.concat(letters).concat(interval);\n     * result.subscribe(x => console.log(x));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link throw}\n     *\n     * @param {...T} values Arguments that represent `next` values to be emitted.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emissions of the `next` notifications.\n     * @return {Observable<T>} An Observable that emits each given input value.\n     * @static true\n     * @name of\n     * @owner Observable\n     */\n    ArrayObservable.of = function () {\n        var array = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            array[_i - 0] = arguments[_i];\n        }\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len > 1) {\n            return new ArrayObservable(array, scheduler);\n        }\n        else if (len === 1) {\n            return new ScalarObservable_1.ScalarObservable(array[0], scheduler);\n        }\n        else {\n            return new EmptyObservable_1.EmptyObservable(scheduler);\n        }\n    };\n    ArrayObservable.dispatch = function (state) {\n        var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber;\n        if (index >= count) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(array[index]);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    ArrayObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var array = this.array;\n        var count = array.length;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ArrayObservable.dispatch, 0, {\n                array: array, index: index, count: count, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < count && !subscriber.closed; i++) {\n                subscriber.next(array[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayObservable;\n}(Observable_1.Observable));\nexports.ArrayObservable = ArrayObservable;\n//# sourceMappingURL=ArrayObservable.js.map\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar EmptyObservable = (function (_super) {\n    __extends(EmptyObservable, _super);\n    function EmptyObservable(scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits a complete notification.\n     *\n     * <span class=\"informal\">Just emits 'complete', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/empty.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the complete notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then complete.</caption>\n     * var result = Rx.Observable.empty().startWith(7);\n     * result.subscribe(x => console.log(x));\n     *\n     * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()\n     * );\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following to the console:\n     * // x is equal to the count on the interval eg(0,1,2,3,...)\n     * // x will occur every 1000ms\n     * // if x % 2 is equal to 1 print abc\n     * // if x % 2 is not equal to 1 nothing will be output\n     *\n     * @see {@link create}\n     * @see {@link never}\n     * @see {@link of}\n     * @see {@link throw}\n     *\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the complete notification.\n     * @return {Observable} An \"empty\" Observable: emits only the complete\n     * notification.\n     * @static true\n     * @name empty\n     * @owner Observable\n     */\n    EmptyObservable.create = function (scheduler) {\n        return new EmptyObservable(scheduler);\n    };\n    EmptyObservable.dispatch = function (arg) {\n        var subscriber = arg.subscriber;\n        subscriber.complete();\n    };\n    EmptyObservable.prototype._subscribe = function (subscriber) {\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber });\n        }\n        else {\n            subscriber.complete();\n        }\n    };\n    return EmptyObservable;\n}(Observable_1.Observable));\nexports.EmptyObservable = EmptyObservable;\n//# sourceMappingURL=EmptyObservable.js.map\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\nexports.isScheduler = isScheduler;\n//# sourceMappingURL=isScheduler.js.map\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar OuterSubscriber = (function (_super) {\n    __extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        _super.apply(this, arguments);\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber_1.Subscriber));\nexports.OuterSubscriber = OuterSubscriber;\n//# sourceMappingURL=OuterSubscriber.js.map\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nvar isArrayLike_1 = __webpack_require__(55);\nvar isPromise_1 = __webpack_require__(56);\nvar isObject_1 = __webpack_require__(52);\nvar Observable_1 = __webpack_require__(1);\nvar iterator_1 = __webpack_require__(32);\nvar InnerSubscriber_1 = __webpack_require__(102);\nvar observable_1 = __webpack_require__(43);\nfunction subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {\n    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    if (destination.closed) {\n        return null;\n    }\n    if (result instanceof Observable_1.Observable) {\n        if (result._isScalar) {\n            destination.next(result.value);\n            destination.complete();\n            return null;\n        }\n        else {\n            destination.syncErrorThrowable = true;\n            return result.subscribe(destination);\n        }\n    }\n    else if (isArrayLike_1.isArrayLike(result)) {\n        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {\n            destination.next(result[i]);\n        }\n        if (!destination.closed) {\n            destination.complete();\n        }\n    }\n    else if (isPromise_1.isPromise(result)) {\n        result.then(function (value) {\n            if (!destination.closed) {\n                destination.next(value);\n                destination.complete();\n            }\n        }, function (err) { return destination.error(err); })\n            .then(null, function (err) {\n            // Escaping the Promise trap: globally throw unhandled errors\n            root_1.root.setTimeout(function () { throw err; });\n        });\n        return destination;\n    }\n    else if (result && typeof result[iterator_1.iterator] === 'function') {\n        var iterator = result[iterator_1.iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                destination.complete();\n                break;\n            }\n            destination.next(item.value);\n            if (destination.closed) {\n                break;\n            }\n        } while (true);\n    }\n    else if (result && typeof result[observable_1.observable] === 'function') {\n        var obs = result[observable_1.observable]();\n        if (typeof obs.subscribe !== 'function') {\n            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));\n        }\n        else {\n            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));\n        }\n    }\n    else {\n        var value = isObject_1.isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = (\"You provided \" + value + \" where a stream was expected.\")\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        destination.error(new TypeError(msg));\n    }\n    return null;\n}\nexports.subscribeToResult = subscribeToResult;\n//# sourceMappingURL=subscribeToResult.js.map\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nfunction symbolIteratorPonyfill(root) {\n    var Symbol = root.Symbol;\n    if (typeof Symbol === 'function') {\n        if (!Symbol.iterator) {\n            Symbol.iterator = Symbol('iterator polyfill');\n        }\n        return Symbol.iterator;\n    }\n    else {\n        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)\n        var Set_1 = root.Set;\n        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {\n            return '@@iterator';\n        }\n        var Map_1 = root.Map;\n        // required for compatability with es6-shim\n        if (Map_1) {\n            var keys = Object.getOwnPropertyNames(Map_1.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.\n                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {\n                    return key;\n                }\n            }\n        }\n        return '@@iterator';\n    }\n}\nexports.symbolIteratorPonyfill = symbolIteratorPonyfill;\nexports.iterator = symbolIteratorPonyfill(root_1.root);\n/**\n * @deprecated use iterator instead\n */\nexports.$$iterator = exports.iterator;\n//# sourceMappingURL=iterator.js.map\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports) {\n\n/**\r\n * Compiles a querystring\r\n * Returns string representation of the object\r\n *\r\n * @param {Object}\r\n * @api private\r\n */\r\n\r\nexports.encode = function (obj) {\r\n  var str = '';\r\n\r\n  for (var i in obj) {\r\n    if (obj.hasOwnProperty(i)) {\r\n      if (str.length) str += '&';\r\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\r\n    }\r\n  }\r\n\r\n  return str;\r\n};\r\n\r\n/**\r\n * Parses a simple querystring into an object\r\n *\r\n * @param {String} qs\r\n * @api private\r\n */\r\n\r\nexports.decode = function(qs){\r\n  var qry = {};\r\n  var pairs = qs.split('&');\r\n  for (var i = 0, l = pairs.length; i < l; i++) {\r\n    var pair = pairs[i].split('=');\r\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\r\n  }\r\n  return qry;\r\n};\r\n\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports) {\n\n\nmodule.exports = function(a, b){\n  var fn = function(){};\n  fn.prototype = b.prototype;\n  a.prototype = new fn;\n  a.prototype.constructor = a;\n};\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\nvar Subscriber_1 = __webpack_require__(3);\nvar Subscription_1 = __webpack_require__(14);\nvar ObjectUnsubscribedError_1 = __webpack_require__(69);\nvar SubjectSubscription_1 = __webpack_require__(127);\nvar rxSubscriber_1 = __webpack_require__(42);\n/**\n * @class SubjectSubscriber<T>\n */\nvar SubjectSubscriber = (function (_super) {\n    __extends(SubjectSubscriber, _super);\n    function SubjectSubscriber(destination) {\n        _super.call(this, destination);\n        this.destination = destination;\n    }\n    return SubjectSubscriber;\n}(Subscriber_1.Subscriber));\nexports.SubjectSubscriber = SubjectSubscriber;\n/**\n * @class Subject<T>\n */\nvar Subject = (function (_super) {\n    __extends(Subject, _super);\n    function Subject() {\n        _super.call(this);\n        this.observers = [];\n        this.closed = false;\n        this.isStopped = false;\n        this.hasError = false;\n        this.thrownError = null;\n    }\n    Subject.prototype[rxSubscriber_1.rxSubscriber] = function () {\n        return new SubjectSubscriber(this);\n    };\n    Subject.prototype.lift = function (operator) {\n        var subject = new AnonymousSubject(this, this);\n        subject.operator = operator;\n        return subject;\n    };\n    Subject.prototype.next = function (value) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        if (!this.isStopped) {\n            var observers = this.observers;\n            var len = observers.length;\n            var copy = observers.slice();\n            for (var i = 0; i < len; i++) {\n                copy[i].next(value);\n            }\n        }\n    };\n    Subject.prototype.error = function (err) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.hasError = true;\n        this.thrownError = err;\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].error(err);\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.complete = function () {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].complete();\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.unsubscribe = function () {\n        this.isStopped = true;\n        this.closed = true;\n        this.observers = null;\n    };\n    Subject.prototype._trySubscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return _super.prototype._trySubscribe.call(this, subscriber);\n        }\n    };\n    Subject.prototype._subscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else if (this.hasError) {\n            subscriber.error(this.thrownError);\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else if (this.isStopped) {\n            subscriber.complete();\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else {\n            this.observers.push(subscriber);\n            return new SubjectSubscription_1.SubjectSubscription(this, subscriber);\n        }\n    };\n    Subject.prototype.asObservable = function () {\n        var observable = new Observable_1.Observable();\n        observable.source = this;\n        return observable;\n    };\n    Subject.create = function (destination, source) {\n        return new AnonymousSubject(destination, source);\n    };\n    return Subject;\n}(Observable_1.Observable));\nexports.Subject = Subject;\n/**\n * @class AnonymousSubject<T>\n */\nvar AnonymousSubject = (function (_super) {\n    __extends(AnonymousSubject, _super);\n    function AnonymousSubject(destination, source) {\n        _super.call(this);\n        this.destination = destination;\n        this.source = source;\n    }\n    AnonymousSubject.prototype.next = function (value) {\n        var destination = this.destination;\n        if (destination && destination.next) {\n            destination.next(value);\n        }\n    };\n    AnonymousSubject.prototype.error = function (err) {\n        var destination = this.destination;\n        if (destination && destination.error) {\n            this.destination.error(err);\n        }\n    };\n    AnonymousSubject.prototype.complete = function () {\n        var destination = this.destination;\n        if (destination && destination.complete) {\n            this.destination.complete();\n        }\n    };\n    AnonymousSubject.prototype._subscribe = function (subscriber) {\n        var source = this.source;\n        if (source) {\n            return this.source.subscribe(subscriber);\n        }\n        else {\n            return Subscription_1.Subscription.EMPTY;\n        }\n    };\n    return AnonymousSubject;\n}(Subject));\nexports.AnonymousSubject = AnonymousSubject;\n//# sourceMappingURL=Subject.js.map\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(1);\nvar ArrayObservable_1 = __webpack_require__(25);\nvar isScheduler_1 = __webpack_require__(27);\nvar mergeAll_1 = __webpack_require__(84);\n/* tslint:enable:max-line-length */\n/**\n * Creates an output Observable which concurrently emits all values from every\n * given input Observable.\n *\n * <span class=\"informal\">Flattens multiple Observables together by blending\n * their values into one Observable.</span>\n *\n * <img src=\"./img/merge.png\" width=\"100%\">\n *\n * `merge` subscribes to each given input Observable (as arguments), and simply\n * forwards (without doing any transformation) all the values from all the input\n * Observables to the output Observable. The output Observable only completes\n * once all input Observables have completed. Any error delivered by an input\n * Observable will be immediately emitted on the output Observable.\n *\n * @example <caption>Merge together two Observables: 1s interval and clicks</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var timer = Rx.Observable.interval(1000);\n * var clicksOrTimer = Rx.Observable.merge(clicks, timer);\n * clicksOrTimer.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // timer will emit ascending values, one every second(1000ms) to console\n * // clicks logs MouseEvents to console everytime the \"document\" is clicked\n * // Since the two streams are merged you see these happening\n * // as they occur.\n *\n * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>\n * var timer1 = Rx.Observable.interval(1000).take(10);\n * var timer2 = Rx.Observable.interval(2000).take(6);\n * var timer3 = Rx.Observable.interval(500).take(10);\n * var concurrent = 2; // the argument\n * var merged = Rx.Observable.merge(timer1, timer2, timer3, concurrent);\n * merged.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // - First timer1 and timer2 will run concurrently\n * // - timer1 will emit a value every 1000ms for 10 iterations\n * // - timer2 will emit a value every 2000ms for 6 iterations\n * // - after timer1 hits it's max iteration, timer2 will\n * //   continue, and timer3 will start to run concurrently with timer2\n * // - when timer2 hits it's max iteration it terminates, and\n * //   timer3 will continue to emit a value every 500ms until it is complete\n *\n * @see {@link mergeAll}\n * @see {@link mergeMap}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n *\n * @param {...ObservableInput} observables Input Observables to merge together.\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @param {Scheduler} [scheduler=null] The IScheduler to use for managing\n * concurrency of input Observables.\n * @return {Observable} an Observable that emits items that are the result of\n * every input Observable.\n * @static true\n * @name merge\n * @owner Observable\n */\nfunction merge() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var concurrent = Number.POSITIVE_INFINITY;\n    var scheduler = null;\n    var last = observables[observables.length - 1];\n    if (isScheduler_1.isScheduler(last)) {\n        scheduler = observables.pop();\n        if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') {\n            concurrent = observables.pop();\n        }\n    }\n    else if (typeof last === 'number') {\n        concurrent = observables.pop();\n    }\n    if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable_1.Observable) {\n        return observables[0];\n    }\n    return mergeAll_1.mergeAll(concurrent)(new ArrayObservable_1.ArrayObservable(observables, scheduler));\n}\nexports.merge = merge;\n//# sourceMappingURL=merge.js.map\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/**\n * Returns an Observable that skips the first `count` items emitted by the source Observable.\n *\n * <img src=\"./img/skip.png\" width=\"100%\">\n *\n * @param {Number} count - The number of times, items emitted by source Observable should be skipped.\n * @return {Observable} An Observable that skips values emitted by the source Observable.\n *\n * @method skip\n * @owner Observable\n */\nfunction skip(count) {\n    return function (source) { return source.lift(new SkipOperator(count)); };\n}\nexports.skip = skip;\nvar SkipOperator = (function () {\n    function SkipOperator(total) {\n        this.total = total;\n    }\n    SkipOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new SkipSubscriber(subscriber, this.total));\n    };\n    return SkipOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SkipSubscriber = (function (_super) {\n    __extends(SkipSubscriber, _super);\n    function SkipSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    SkipSubscriber.prototype._next = function (x) {\n        if (++this.count > this.total) {\n            this.destination.next(x);\n        }\n    };\n    return SkipSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=skip.js.map\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nvar tryCatch_1 = __webpack_require__(41);\nvar errorObject_1 = __webpack_require__(29);\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.\n *\n * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted.\n *\n * If a comparator function is not provided, an equality check is used by default.\n *\n * @example <caption>A simple example with numbers</caption>\n * Observable.of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4)\n *   .distinctUntilChanged()\n *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4\n *\n * @example <caption>An example using a compare function</caption>\n * interface Person {\n *    age: number,\n *    name: string\n * }\n *\n * Observable.of<Person>(\n *     { age: 4, name: 'Foo'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo'})\n *     { age: 6, name: 'Foo'})\n *     .distinctUntilChanged((p: Person, q: Person) => p.name === q.name)\n *     .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Foo' }\n * // { age: 7, name: 'Bar' }\n * // { age: 5, name: 'Foo' }\n *\n * @see {@link distinct}\n * @see {@link distinctUntilKeyChanged}\n *\n * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.\n * @return {Observable} An Observable that emits items from the source Observable with distinct values.\n * @method distinctUntilChanged\n * @owner Observable\n */\nfunction distinctUntilChanged(compare, keySelector) {\n    return function (source) { return source.lift(new DistinctUntilChangedOperator(compare, keySelector)); };\n}\nexports.distinctUntilChanged = distinctUntilChanged;\nvar DistinctUntilChangedOperator = (function () {\n    function DistinctUntilChangedOperator(compare, keySelector) {\n        this.compare = compare;\n        this.keySelector = keySelector;\n    }\n    DistinctUntilChangedOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));\n    };\n    return DistinctUntilChangedOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DistinctUntilChangedSubscriber = (function (_super) {\n    __extends(DistinctUntilChangedSubscriber, _super);\n    function DistinctUntilChangedSubscriber(destination, compare, keySelector) {\n        _super.call(this, destination);\n        this.keySelector = keySelector;\n        this.hasKey = false;\n        if (typeof compare === 'function') {\n            this.compare = compare;\n        }\n    }\n    DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {\n        return x === y;\n    };\n    DistinctUntilChangedSubscriber.prototype._next = function (value) {\n        var keySelector = this.keySelector;\n        var key = value;\n        if (keySelector) {\n            key = tryCatch_1.tryCatch(this.keySelector)(value);\n            if (key === errorObject_1.errorObject) {\n                return this.destination.error(errorObject_1.errorObject.e);\n            }\n        }\n        var result = false;\n        if (this.hasKey) {\n            result = tryCatch_1.tryCatch(this.compare)(this.key, key);\n            if (result === errorObject_1.errorObject) {\n                return this.destination.error(errorObject_1.errorObject.e);\n            }\n        }\n        else {\n            this.hasKey = true;\n        }\n        if (Boolean(result) === false) {\n            this.key = key;\n            this.destination.next(value);\n        }\n    };\n    return DistinctUntilChangedSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=distinctUntilChanged.js.map\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar FromEventObservable_1 = __webpack_require__(167);\nexports.fromEvent = FromEventObservable_1.FromEventObservable.create;\n//# sourceMappingURL=fromEvent.js.map\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction isFunction(x) {\n    return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar errorObject_1 = __webpack_require__(29);\nvar tryCatchTarget;\nfunction tryCatcher() {\n    try {\n        return tryCatchTarget.apply(this, arguments);\n    }\n    catch (e) {\n        errorObject_1.errorObject.e = e;\n        return errorObject_1.errorObject;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nvar Symbol = root_1.root.Symbol;\nexports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?\n    Symbol.for('rxSubscriber') : '@@rxSubscriber';\n/**\n * @deprecated use rxSubscriber instead\n */\nexports.$$rxSubscriber = exports.rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nfunction getSymbolObservable(context) {\n    var $$observable;\n    var Symbol = context.Symbol;\n    if (typeof Symbol === 'function') {\n        if (Symbol.observable) {\n            $$observable = Symbol.observable;\n        }\n        else {\n            $$observable = Symbol('observable');\n            Symbol.observable = $$observable;\n        }\n    }\n    else {\n        $$observable = '@@observable';\n    }\n    return $$observable;\n}\nexports.getSymbolObservable = getSymbolObservable;\nexports.observable = getSymbolObservable(root_1.root);\n/**\n * @deprecated use observable instead\n */\nexports.$$observable = exports.observable;\n//# sourceMappingURL=observable.js.map\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ScalarObservable = (function (_super) {\n    __extends(ScalarObservable, _super);\n    function ScalarObservable(value, scheduler) {\n        _super.call(this);\n        this.value = value;\n        this.scheduler = scheduler;\n        this._isScalar = true;\n        if (scheduler) {\n            this._isScalar = false;\n        }\n    }\n    ScalarObservable.create = function (value, scheduler) {\n        return new ScalarObservable(value, scheduler);\n    };\n    ScalarObservable.dispatch = function (state) {\n        var done = state.done, value = state.value, subscriber = state.subscriber;\n        if (done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(value);\n        if (subscriber.closed) {\n            return;\n        }\n        state.done = true;\n        this.schedule(state);\n    };\n    ScalarObservable.prototype._subscribe = function (subscriber) {\n        var value = this.value;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ScalarObservable.dispatch, 0, {\n                done: false, value: value, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.next(value);\n            if (!subscriber.closed) {\n                subscriber.complete();\n            }\n        }\n    };\n    return ScalarObservable;\n}(Observable_1.Observable));\nexports.ScalarObservable = ScalarObservable;\n//# sourceMappingURL=ScalarObservable.js.map\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Module dependencies.\n */\n\nvar debug = __webpack_require__(10)('socket.io-parser');\nvar Emitter = __webpack_require__(19);\nvar hasBin = __webpack_require__(59);\nvar binary = __webpack_require__(109);\nvar isBuf = __webpack_require__(60);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n  'CONNECT',\n  'DISCONNECT',\n  'EVENT',\n  'ACK',\n  'ERROR',\n  'BINARY_EVENT',\n  'BINARY_ACK'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n  if ((obj.type === exports.EVENT || obj.type === exports.ACK) && hasBin(obj.data)) {\n    obj.type = obj.type === exports.EVENT ? exports.BINARY_EVENT : exports.BINARY_ACK;\n  }\n\n  debug('encoding packet %j', obj);\n\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    encodeAsBinary(obj, callback);\n  }\n  else {\n    var encoding = encodeAsString(obj);\n    callback([encoding]);\n  }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n\n  // first is type\n  var str = '' + obj.type;\n\n  // attachments if we have them\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    str += obj.attachments + '-';\n  }\n\n  // if we have a namespace other than `/`\n  // we append it followed by a comma `,`\n  if (obj.nsp && '/' !== obj.nsp) {\n    str += obj.nsp + ',';\n  }\n\n  // immediately followed by the id\n  if (null != obj.id) {\n    str += obj.id;\n  }\n\n  // json data\n  if (null != obj.data) {\n    str += JSON.stringify(obj.data);\n  }\n\n  debug('encoded %j as %s', obj, str);\n  return str;\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n  function writeEncoding(bloblessData) {\n    var deconstruction = binary.deconstructPacket(bloblessData);\n    var pack = encodeAsString(deconstruction.packet);\n    var buffers = deconstruction.buffers;\n\n    buffers.unshift(pack); // add packet info to beginning of data list\n    callback(buffers); // write all the buffers\n  }\n\n  binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n  this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an ecoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n  var packet;\n  if (typeof obj === 'string') {\n    packet = decodeString(obj);\n    if (exports.BINARY_EVENT === packet.type || exports.BINARY_ACK === packet.type) { // binary packet's json\n      this.reconstructor = new BinaryReconstructor(packet);\n\n      // no attachments, labeled binary but no binary data to follow\n      if (this.reconstructor.reconPack.attachments === 0) {\n        this.emit('decoded', packet);\n      }\n    } else { // non-binary full packet\n      this.emit('decoded', packet);\n    }\n  }\n  else if (isBuf(obj) || obj.base64) { // raw binary data\n    if (!this.reconstructor) {\n      throw new Error('got binary data when not reconstructing a packet');\n    } else {\n      packet = this.reconstructor.takeBinaryData(obj);\n      if (packet) { // received final buffer\n        this.reconstructor = null;\n        this.emit('decoded', packet);\n      }\n    }\n  }\n  else {\n    throw new Error('Unknown type: ' + obj);\n  }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n  var i = 0;\n  // look up type\n  var p = {\n    type: Number(str.charAt(0))\n  };\n\n  if (null == exports.types[p.type]) return error();\n\n  // look up attachments if type binary\n  if (exports.BINARY_EVENT === p.type || exports.BINARY_ACK === p.type) {\n    var buf = '';\n    while (str.charAt(++i) !== '-') {\n      buf += str.charAt(i);\n      if (i == str.length) break;\n    }\n    if (buf != Number(buf) || str.charAt(i) !== '-') {\n      throw new Error('Illegal attachments');\n    }\n    p.attachments = Number(buf);\n  }\n\n  // look up namespace (if any)\n  if ('/' === str.charAt(i + 1)) {\n    p.nsp = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' === c) break;\n      p.nsp += c;\n      if (i === str.length) break;\n    }\n  } else {\n    p.nsp = '/';\n  }\n\n  // look up id\n  var next = str.charAt(i + 1);\n  if ('' !== next && Number(next) == next) {\n    p.id = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      p.id += str.charAt(i);\n      if (i === str.length) break;\n    }\n    p.id = Number(p.id);\n  }\n\n  // look up json data\n  if (str.charAt(++i)) {\n    p = tryParse(p, str.substr(i));\n  }\n\n  debug('decoded %s as %j', str, p);\n  return p;\n}\n\nfunction tryParse(p, str) {\n  try {\n    p.data = JSON.parse(str);\n  } catch(e){\n    return error();\n  }\n  return p; \n}\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n  if (this.reconstructor) {\n    this.reconstructor.finishedReconstruction();\n  }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n  this.reconPack = packet;\n  this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n *   a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n  this.buffers.push(binData);\n  if (this.buffers.length === this.reconPack.attachments) { // done with buffer list\n    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n    this.finishedReconstruction();\n    return packet;\n  }\n  return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n  this.reconPack = null;\n  this.buffers = [];\n};\n\nfunction error() {\n  return {\n    type: exports.ERROR,\n    data: 'parser error'\n  };\n}\n\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {// browser shim for xmlhttprequest module\n\nvar hasCORS = __webpack_require__(113);\n\nmodule.exports = function (opts) {\n  var xdomain = opts.xdomain;\n\n  // scheme must be same when usign XDomainRequest\n  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n  var xscheme = opts.xscheme;\n\n  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n  // https://github.com/Automattic/engine.io-client/pull/217\n  var enablesXDR = opts.enablesXDR;\n\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) { }\n\n  // Use XDomainRequest for IE8 if enablesXDR is true\n  // because loading bar keeps flashing when using jsonp-polling\n  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n  try {\n    if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {\n      return new XDomainRequest();\n    }\n  } catch (e) { }\n\n  if (!xdomain) {\n    try {\n      return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');\n    } catch (e) { }\n  }\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Module dependencies.\n */\n\nvar parser = __webpack_require__(20);\nvar Emitter = __webpack_require__(19);\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n  this.path = opts.path;\n  this.hostname = opts.hostname;\n  this.port = opts.port;\n  this.secure = opts.secure;\n  this.query = opts.query;\n  this.timestampParam = opts.timestampParam;\n  this.timestampRequests = opts.timestampRequests;\n  this.readyState = '';\n  this.agent = opts.agent || false;\n  this.socket = opts.socket;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n  this.forceNode = opts.forceNode;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n  this.localAddress = opts.localAddress;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n  var err = new Error(msg);\n  err.type = 'TransportError';\n  err.description = desc;\n  this.emit('error', err);\n  return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n  if ('closed' === this.readyState || '' === this.readyState) {\n    this.readyState = 'opening';\n    this.doOpen();\n  }\n\n  return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.doClose();\n    this.onClose();\n  }\n\n  return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function (packets) {\n  if ('open' === this.readyState) {\n    this.write(packets);\n  } else {\n    throw new Error('Transport not open');\n  }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n  this.readyState = 'open';\n  this.writable = true;\n  this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function (data) {\n  var packet = parser.decodePacket(data, this.socket.binaryType);\n  this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n  this.readyState = 'closed';\n  this.emit('close');\n};\n\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar TimerObservable_1 = __webpack_require__(131);\nexports.timer = TimerObservable_1.TimerObservable.create;\n//# sourceMappingURL=timer.js.map\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar tap_1 = __webpack_require__(6);\r\nvar effects_1 = __webpack_require__(9);\r\n/**\r\n * Set the local client options\r\n * @param xs\r\n * @param inputs\r\n */\r\nfunction setOptionsEffect(xs, inputs) {\r\n    return xs.pipe(tap_1.tap(function (options) { return inputs.option$.next(options); }), \r\n    // map(() => consoleInfo('set options'))\r\n    ignoreElements_1.ignoreElements());\r\n}\r\nexports.setOptionsEffect = setOptionsEffect;\r\nfunction setOptions(options) {\r\n    return [effects_1.EffectNames.SetOptions, options];\r\n}\r\nexports.setOptions = setOptions;\r\n\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar isScheduler_1 = __webpack_require__(27);\nvar of_1 = __webpack_require__(11);\nvar from_1 = __webpack_require__(83);\nvar concatAll_1 = __webpack_require__(143);\n/* tslint:enable:max-line-length */\n/**\n * Creates an output Observable which sequentially emits all values from given\n * Observable and then moves on to the next.\n *\n * <span class=\"informal\">Concatenates multiple Observables together by\n * sequentially emitting their values, one Observable after the other.</span>\n *\n * <img src=\"./img/concat.png\" width=\"100%\">\n *\n * `concat` joins multiple Observables together, by subscribing to them one at a time and\n * merging their results into the output Observable. You can pass either an array of\n * Observables, or put them directly as arguments. Passing an empty array will result\n * in Observable that completes immediately.\n *\n * `concat` will subscribe to first input Observable and emit all its values, without\n * changing or affecting them in any way. When that Observable completes, it will\n * subscribe to then next Observable passed and, again, emit its values. This will be\n * repeated, until the operator runs out of Observables. When last input Observable completes,\n * `concat` will complete as well. At any given moment only one Observable passed to operator\n * emits values. If you would like to emit values from passed Observables concurrently, check out\n * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,\n * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.\n *\n * Note that if some input Observable never completes, `concat` will also never complete\n * and Observables following the one that did not complete will never be subscribed. On the other\n * hand, if some Observable simply completes immediately after it is subscribed, it will be\n * invisible for `concat`, which will just move on to the next Observable.\n *\n * If any Observable in chain errors, instead of passing control to the next Observable,\n * `concat` will error immediately as well. Observables that would be subscribed after\n * the one that emitted error, never will.\n *\n * If you pass to `concat` the same Observable many times, its stream of values\n * will be \"replayed\" on every subscription, which means you can repeat given Observable\n * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,\n * you can always use {@link repeat}.\n *\n * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>\n * var timer = Rx.Observable.interval(1000).take(4);\n * var sequence = Rx.Observable.range(1, 10);\n * var result = Rx.Observable.concat(timer, sequence);\n * result.subscribe(x => console.log(x));\n *\n * // results in:\n * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10\n *\n *\n * @example <caption>Concatenate an array of 3 Observables</caption>\n * var timer1 = Rx.Observable.interval(1000).take(10);\n * var timer2 = Rx.Observable.interval(2000).take(6);\n * var timer3 = Rx.Observable.interval(500).take(10);\n * var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed\n * result.subscribe(x => console.log(x));\n *\n * // results in the following:\n * // (Prints to console sequentially)\n * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9\n * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5\n * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9\n *\n *\n * @example <caption>Concatenate the same Observable to repeat it</caption>\n * const timer = Rx.Observable.interval(1000).take(2);\n *\n * Rx.Observable.concat(timer, timer) // concating the same Observable!\n * .subscribe(\n *   value => console.log(value),\n *   err => {},\n *   () => console.log('...and it is done!')\n * );\n *\n * // Logs:\n * // 0 after 1s\n * // 1 after 2s\n * // 0 after 3s\n * // 1 after 4s\n * // \"...and it is done!\" also after 4s\n *\n * @see {@link concatAll}\n * @see {@link concatMap}\n * @see {@link concatMapTo}\n *\n * @param {ObservableInput} input1 An input Observable to concatenate with others.\n * @param {ObservableInput} input2 An input Observable to concatenate with others.\n * More than one input Observables may be given as argument.\n * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each\n * Observable subscription on.\n * @return {Observable} All values of each passed Observable merged into a\n * single Observable, in order, in serial fashion.\n * @static true\n * @name concat\n * @owner Observable\n */\nfunction concat() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    if (observables.length === 1 || (observables.length === 2 && isScheduler_1.isScheduler(observables[1]))) {\n        return from_1.from(observables[0]);\n    }\n    return concatAll_1.concatAll()(of_1.of.apply(void 0, observables));\n}\nexports.concat = concat;\n//# sourceMappingURL=concat.js.map\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar filter_1 = __webpack_require__(4);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nvar concat_1 = __webpack_require__(50);\r\nvar of_1 = __webpack_require__(11);\r\nvar browser_reload_effect_1 = __webpack_require__(90);\r\nvar subscribeOn_1 = __webpack_require__(153);\r\nvar async_1 = __webpack_require__(74);\r\nfunction incomingBrowserReload(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$), filter_1.filter(function (_a) {\r\n        var event = _a[0], options = _a[1];\r\n        return options.codeSync;\r\n    }), mergeMap_1.mergeMap(reloadBrowserSafe));\r\n}\r\nexports.incomingBrowserReload = incomingBrowserReload;\r\nfunction reloadBrowserSafe() {\r\n    return concat_1.concat(\r\n    /**\r\n     * Emit a warning message allowing others to do some work\r\n     */\r\n    of_1.of(browser_reload_effect_1.preBrowserReload()), \r\n    /**\r\n     * On the next tick, perform the reload\r\n     */\r\n    of_1.of(browser_reload_effect_1.browserReload()).pipe(subscribeOn_1.subscribeOn(async_1.async)));\r\n}\r\nexports.reloadBrowserSafe = reloadBrowserSafe;\r\n\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction isObject(x) {\n    return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nexports.empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) { throw err; },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n/* tslint:disable:no-empty */\nfunction noop() { }\nexports.noop = noop;\n//# sourceMappingURL=noop.js.map\n\n/***/ }),\n/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nexports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArrayLike.js.map\n\n/***/ }),\n/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction isPromise(value) {\n    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nexports.isPromise = isPromise;\n//# sourceMappingURL=isPromise.js.map\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports) {\n\n/**\r\n * Parses an URI\r\n *\r\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\r\n * @api private\r\n */\r\n\r\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\r\n\r\nvar parts = [\r\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\r\n];\r\n\r\nmodule.exports = function parseuri(str) {\r\n    var src = str,\r\n        b = str.indexOf('['),\r\n        e = str.indexOf(']');\r\n\r\n    if (b != -1 && e != -1) {\r\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\r\n    }\r\n\r\n    var m = re.exec(str || ''),\r\n        uri = {},\r\n        i = 14;\r\n\r\n    while (i--) {\r\n        uri[parts[i]] = m[i] || '';\r\n    }\r\n\r\n    if (b != -1 && e != -1) {\r\n        uri.source = src;\r\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\r\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\r\n        uri.ipv6uri = true;\r\n    }\r\n\r\n    return uri;\r\n};\r\n\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/* global Blob File */\n\n/*\n * Module requirements.\n */\n\nvar isArray = __webpack_require__(108);\n\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof global.Blob === 'function' || toString.call(global.Blob) === '[object BlobConstructor]';\nvar withNativeFile = typeof global.File === 'function' || toString.call(global.File) === '[object FileConstructor]';\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Supports Buffer, ArrayBuffer, Blob and File.\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary (obj) {\n  if (!obj || typeof obj !== 'object') {\n    return false;\n  }\n\n  if (isArray(obj)) {\n    for (var i = 0, l = obj.length; i < l; i++) {\n      if (hasBinary(obj[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  if ((typeof global.Buffer === 'function' && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||\n     (typeof global.ArrayBuffer === 'function' && obj instanceof ArrayBuffer) ||\n     (withNativeBlob && obj instanceof Blob) ||\n     (withNativeFile && obj instanceof File)\n    ) {\n    return true;\n  }\n\n  // see: https://github.com/Automattic/has-binary/pull/4\n  if (obj.toJSON && typeof obj.toJSON === 'function' && arguments.length === 1) {\n    return hasBinary(obj.toJSON(), true);\n  }\n\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {\nmodule.exports = isBuf;\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n  return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer);\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Module dependencies.\n */\n\nvar eio = __webpack_require__(111);\nvar Socket = __webpack_require__(66);\nvar Emitter = __webpack_require__(19);\nvar parser = __webpack_require__(45);\nvar on = __webpack_require__(67);\nvar bind = __webpack_require__(68);\nvar debug = __webpack_require__(10)('socket.io-client:manager');\nvar indexOf = __webpack_require__(65);\nvar Backoff = __webpack_require__(126);\n\n/**\n * IE6+ hasOwnProperty\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager (uri, opts) {\n  if (!(this instanceof Manager)) return new Manager(uri, opts);\n  if (uri && ('object' === typeof uri)) {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n\n  opts.path = opts.path || '/socket.io';\n  this.nsps = {};\n  this.subs = [];\n  this.opts = opts;\n  this.reconnection(opts.reconnection !== false);\n  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n  this.randomizationFactor(opts.randomizationFactor || 0.5);\n  this.backoff = new Backoff({\n    min: this.reconnectionDelay(),\n    max: this.reconnectionDelayMax(),\n    jitter: this.randomizationFactor()\n  });\n  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n  this.readyState = 'closed';\n  this.uri = uri;\n  this.connecting = [];\n  this.lastPing = null;\n  this.encoding = false;\n  this.packetBuffer = [];\n  var _parser = opts.parser || parser;\n  this.encoder = new _parser.Encoder();\n  this.decoder = new _parser.Decoder();\n  this.autoConnect = opts.autoConnect !== false;\n  if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function () {\n  this.emit.apply(this, arguments);\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n    }\n  }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function () {\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].id = this.generateId(nsp);\n    }\n  }\n};\n\n/**\n * generate `socket.id` for the given `nsp`\n *\n * @param {String} nsp\n * @return {String}\n * @api private\n */\n\nManager.prototype.generateId = function (nsp) {\n  return (nsp === '/' ? '' : (nsp + '#')) + this.engine.id;\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function (v) {\n  if (!arguments.length) return this._reconnection;\n  this._reconnection = !!v;\n  return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function (v) {\n  if (!arguments.length) return this._reconnectionAttempts;\n  this._reconnectionAttempts = v;\n  return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function (v) {\n  if (!arguments.length) return this._reconnectionDelay;\n  this._reconnectionDelay = v;\n  this.backoff && this.backoff.setMin(v);\n  return this;\n};\n\nManager.prototype.randomizationFactor = function (v) {\n  if (!arguments.length) return this._randomizationFactor;\n  this._randomizationFactor = v;\n  this.backoff && this.backoff.setJitter(v);\n  return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function (v) {\n  if (!arguments.length) return this._reconnectionDelayMax;\n  this._reconnectionDelayMax = v;\n  this.backoff && this.backoff.setMax(v);\n  return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function (v) {\n  if (!arguments.length) return this._timeout;\n  this._timeout = v;\n  return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function () {\n  // Only try to reconnect if it's the first time we're connecting\n  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n    // keeps reconnection from firing twice for the same reconnection loop\n    this.reconnect();\n  }\n};\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function (fn, opts) {\n  debug('readyState %s', this.readyState);\n  if (~this.readyState.indexOf('open')) return this;\n\n  debug('opening %s', this.uri);\n  this.engine = eio(this.uri, this.opts);\n  var socket = this.engine;\n  var self = this;\n  this.readyState = 'opening';\n  this.skipReconnect = false;\n\n  // emit `open`\n  var openSub = on(socket, 'open', function () {\n    self.onopen();\n    fn && fn();\n  });\n\n  // emit `connect_error`\n  var errorSub = on(socket, 'error', function (data) {\n    debug('connect_error');\n    self.cleanup();\n    self.readyState = 'closed';\n    self.emitAll('connect_error', data);\n    if (fn) {\n      var err = new Error('Connection error');\n      err.data = data;\n      fn(err);\n    } else {\n      // Only do this if there is no fn to handle the error\n      self.maybeReconnectOnOpen();\n    }\n  });\n\n  // emit `connect_timeout`\n  if (false !== this._timeout) {\n    var timeout = this._timeout;\n    debug('connect attempt will timeout after %d', timeout);\n\n    // set timer\n    var timer = setTimeout(function () {\n      debug('connect attempt timed out after %d', timeout);\n      openSub.destroy();\n      socket.close();\n      socket.emit('error', 'timeout');\n      self.emitAll('connect_timeout', timeout);\n    }, timeout);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n\n  this.subs.push(openSub);\n  this.subs.push(errorSub);\n\n  return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function () {\n  debug('open');\n\n  // clear old subs\n  this.cleanup();\n\n  // mark as open\n  this.readyState = 'open';\n  this.emit('open');\n\n  // add new subs\n  var socket = this.engine;\n  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n};\n\n/**\n * Called upon a ping.\n *\n * @api private\n */\n\nManager.prototype.onping = function () {\n  this.lastPing = new Date();\n  this.emitAll('ping');\n};\n\n/**\n * Called upon a packet.\n *\n * @api private\n */\n\nManager.prototype.onpong = function () {\n  this.emitAll('pong', new Date() - this.lastPing);\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function (data) {\n  this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function (err) {\n  debug('error', err);\n  this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function (nsp, opts) {\n  var socket = this.nsps[nsp];\n  if (!socket) {\n    socket = new Socket(this, nsp, opts);\n    this.nsps[nsp] = socket;\n    var self = this;\n    socket.on('connecting', onConnecting);\n    socket.on('connect', function () {\n      socket.id = self.generateId(nsp);\n    });\n\n    if (this.autoConnect) {\n      // manually call here since connecting event is fired before listening\n      onConnecting();\n    }\n  }\n\n  function onConnecting () {\n    if (!~indexOf(self.connecting, socket)) {\n      self.connecting.push(socket);\n    }\n  }\n\n  return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function (socket) {\n  var index = indexOf(this.connecting, socket);\n  if (~index) this.connecting.splice(index, 1);\n  if (this.connecting.length) return;\n\n  this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function (packet) {\n  debug('writing packet %j', packet);\n  var self = this;\n  if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;\n\n  if (!self.encoding) {\n    // encode, then write to engine with result\n    self.encoding = true;\n    this.encoder.encode(packet, function (encodedPackets) {\n      for (var i = 0; i < encodedPackets.length; i++) {\n        self.engine.write(encodedPackets[i], packet.options);\n      }\n      self.encoding = false;\n      self.processPacketQueue();\n    });\n  } else { // add packet to the queue\n    self.packetBuffer.push(packet);\n  }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function () {\n  if (this.packetBuffer.length > 0 && !this.encoding) {\n    var pack = this.packetBuffer.shift();\n    this.packet(pack);\n  }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function () {\n  debug('cleanup');\n\n  var subsLength = this.subs.length;\n  for (var i = 0; i < subsLength; i++) {\n    var sub = this.subs.shift();\n    sub.destroy();\n  }\n\n  this.packetBuffer = [];\n  this.encoding = false;\n  this.lastPing = null;\n\n  this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function () {\n  debug('disconnect');\n  this.skipReconnect = true;\n  this.reconnecting = false;\n  if ('opening' === this.readyState) {\n    // `onclose` will not fire because\n    // an open event never happened\n    this.cleanup();\n  }\n  this.backoff.reset();\n  this.readyState = 'closed';\n  if (this.engine) this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function (reason) {\n  debug('onclose');\n\n  this.cleanup();\n  this.backoff.reset();\n  this.readyState = 'closed';\n  this.emit('close', reason);\n\n  if (this._reconnection && !this.skipReconnect) {\n    this.reconnect();\n  }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function () {\n  if (this.reconnecting || this.skipReconnect) return this;\n\n  var self = this;\n\n  if (this.backoff.attempts >= this._reconnectionAttempts) {\n    debug('reconnect failed');\n    this.backoff.reset();\n    this.emitAll('reconnect_failed');\n    this.reconnecting = false;\n  } else {\n    var delay = this.backoff.duration();\n    debug('will wait %dms before reconnect attempt', delay);\n\n    this.reconnecting = true;\n    var timer = setTimeout(function () {\n      if (self.skipReconnect) return;\n\n      debug('attempting reconnect');\n      self.emitAll('reconnect_attempt', self.backoff.attempts);\n      self.emitAll('reconnecting', self.backoff.attempts);\n\n      // check again for the case socket closed in above events\n      if (self.skipReconnect) return;\n\n      self.open(function (err) {\n        if (err) {\n          debug('reconnect attempt error');\n          self.reconnecting = false;\n          self.reconnect();\n          self.emitAll('reconnect_error', err.data);\n        } else {\n          debug('reconnect success');\n          self.onreconnect();\n        }\n      });\n    }, delay);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function () {\n  var attempt = this.backoff.attempts;\n  this.reconnecting = false;\n  this.backoff.reset();\n  this.updateSocketIds();\n  this.emitAll('reconnect', attempt);\n};\n\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = __webpack_require__(46);\nvar XHR = __webpack_require__(114);\nvar JSONP = __webpack_require__(122);\nvar websocket = __webpack_require__(123);\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling (opts) {\n  var xhr;\n  var xd = false;\n  var xs = false;\n  var jsonp = false !== opts.jsonp;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    xd = opts.hostname !== location.hostname || port !== opts.port;\n    xs = opts.secure !== isSSL;\n  }\n\n  opts.xdomain = xd;\n  opts.xscheme = xs;\n  xhr = new XMLHttpRequest(opts);\n\n  if ('open' in xhr && !opts.forceJSONP) {\n    return new XHR(opts);\n  } else {\n    if (!jsonp) throw new Error('JSONP disabled');\n    return new JSONP(opts);\n  }\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Module dependencies.\n */\n\nvar Transport = __webpack_require__(47);\nvar parseqs = __webpack_require__(33);\nvar parser = __webpack_require__(20);\nvar inherit = __webpack_require__(34);\nvar yeast = __webpack_require__(64);\nvar debug = __webpack_require__(10)('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function () {\n  var XMLHttpRequest = __webpack_require__(46);\n  var xhr = new XMLHttpRequest({ xdomain: false });\n  return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (!hasXHR2 || forceBase64) {\n    this.supportsBinary = false;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function () {\n  this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function (onPause) {\n  var self = this;\n\n  this.readyState = 'pausing';\n\n  function pause () {\n    debug('paused');\n    self.readyState = 'paused';\n    onPause();\n  }\n\n  if (this.polling || !this.writable) {\n    var total = 0;\n\n    if (this.polling) {\n      debug('we are currently polling - waiting to pause');\n      total++;\n      this.once('pollComplete', function () {\n        debug('pre-pause polling complete');\n        --total || pause();\n      });\n    }\n\n    if (!this.writable) {\n      debug('we are currently writing - waiting to pause');\n      total++;\n      this.once('drain', function () {\n        debug('pre-pause writing complete');\n        --total || pause();\n      });\n    }\n  } else {\n    pause();\n  }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function () {\n  debug('polling');\n  this.polling = true;\n  this.doPoll();\n  this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function (data) {\n  var self = this;\n  debug('polling got data %s', data);\n  var callback = function (packet, index, total) {\n    // if its the first message we consider the transport open\n    if ('opening' === self.readyState) {\n      self.onOpen();\n    }\n\n    // if its a close packet, we close the ongoing requests\n    if ('close' === packet.type) {\n      self.onClose();\n      return false;\n    }\n\n    // otherwise bypass onData and handle the message\n    self.onPacket(packet);\n  };\n\n  // decode payload\n  parser.decodePayload(data, this.socket.binaryType, callback);\n\n  // if an event did not trigger closing\n  if ('closed' !== this.readyState) {\n    // if we got data we're not polling\n    this.polling = false;\n    this.emit('pollComplete');\n\n    if ('open' === this.readyState) {\n      this.poll();\n    } else {\n      debug('ignoring poll - transport state \"%s\"', this.readyState);\n    }\n  }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function () {\n  var self = this;\n\n  function close () {\n    debug('writing close packet');\n    self.write([{ type: 'close' }]);\n  }\n\n  if ('open' === this.readyState) {\n    debug('transport open - closing');\n    close();\n  } else {\n    // in case we're trying to close while\n    // handshaking is in progress (GH-164)\n    debug('transport not open - deferring close');\n    this.once('open', close);\n  }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n  var callbackfn = function () {\n    self.writable = true;\n    self.emit('drain');\n  };\n\n  parser.encodePayload(packets, this.supportsBinary, function (data) {\n    self.doWrite(data, callbackfn);\n  });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'https' : 'http';\n  var port = '';\n\n  // cache busting is forced\n  if (false !== this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  if (!this.supportsBinary && !query.sid) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // avoid port if default for schema\n  if (this.port && (('https' === schema && Number(this.port) !== 443) ||\n     ('http' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports) {\n\n\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Module dependencies.\n */\n\nvar parser = __webpack_require__(45);\nvar Emitter = __webpack_require__(19);\nvar toArray = __webpack_require__(125);\nvar on = __webpack_require__(67);\nvar bind = __webpack_require__(68);\nvar debug = __webpack_require__(10)('socket.io-client:socket');\nvar parseqs = __webpack_require__(33);\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n  connect: 1,\n  connect_error: 1,\n  connect_timeout: 1,\n  connecting: 1,\n  disconnect: 1,\n  error: 1,\n  reconnect: 1,\n  reconnect_attempt: 1,\n  reconnect_failed: 1,\n  reconnect_error: 1,\n  reconnecting: 1,\n  ping: 1,\n  pong: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket (io, nsp, opts) {\n  this.io = io;\n  this.nsp = nsp;\n  this.json = this; // compat\n  this.ids = 0;\n  this.acks = {};\n  this.receiveBuffer = [];\n  this.sendBuffer = [];\n  this.connected = false;\n  this.disconnected = true;\n  if (opts && opts.query) {\n    this.query = opts.query;\n  }\n  if (this.io.autoConnect) this.open();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function () {\n  if (this.subs) return;\n\n  var io = this.io;\n  this.subs = [\n    on(io, 'open', bind(this, 'onopen')),\n    on(io, 'packet', bind(this, 'onpacket')),\n    on(io, 'close', bind(this, 'onclose'))\n  ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function () {\n  if (this.connected) return this;\n\n  this.subEvents();\n  this.io.open(); // ensure open\n  if ('open' === this.io.readyState) this.onopen();\n  this.emit('connecting');\n  return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function () {\n  var args = toArray(arguments);\n  args.unshift('message');\n  this.emit.apply(this, args);\n  return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function (ev) {\n  if (events.hasOwnProperty(ev)) {\n    emit.apply(this, arguments);\n    return this;\n  }\n\n  var args = toArray(arguments);\n  var packet = { type: parser.EVENT, data: args };\n\n  packet.options = {};\n  packet.options.compress = !this.flags || false !== this.flags.compress;\n\n  // event ack callback\n  if ('function' === typeof args[args.length - 1]) {\n    debug('emitting packet with ack id %d', this.ids);\n    this.acks[this.ids] = args.pop();\n    packet.id = this.ids++;\n  }\n\n  if (this.connected) {\n    this.packet(packet);\n  } else {\n    this.sendBuffer.push(packet);\n  }\n\n  delete this.flags;\n\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function (packet) {\n  packet.nsp = this.nsp;\n  this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function () {\n  debug('transport is open - connecting');\n\n  // write connect packet if necessary\n  if ('/' !== this.nsp) {\n    if (this.query) {\n      var query = typeof this.query === 'object' ? parseqs.encode(this.query) : this.query;\n      debug('sending connect packet with query %s', query);\n      this.packet({type: parser.CONNECT, query: query});\n    } else {\n      this.packet({type: parser.CONNECT});\n    }\n  }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function (reason) {\n  debug('close (%s)', reason);\n  this.connected = false;\n  this.disconnected = true;\n  delete this.id;\n  this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function (packet) {\n  if (packet.nsp !== this.nsp) return;\n\n  switch (packet.type) {\n    case parser.CONNECT:\n      this.onconnect();\n      break;\n\n    case parser.EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.BINARY_EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.ACK:\n      this.onack(packet);\n      break;\n\n    case parser.BINARY_ACK:\n      this.onack(packet);\n      break;\n\n    case parser.DISCONNECT:\n      this.ondisconnect();\n      break;\n\n    case parser.ERROR:\n      this.emit('error', packet.data);\n      break;\n  }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function (packet) {\n  var args = packet.data || [];\n  debug('emitting event %j', args);\n\n  if (null != packet.id) {\n    debug('attaching ack callback to event');\n    args.push(this.ack(packet.id));\n  }\n\n  if (this.connected) {\n    emit.apply(this, args);\n  } else {\n    this.receiveBuffer.push(args);\n  }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function (id) {\n  var self = this;\n  var sent = false;\n  return function () {\n    // prevent double callbacks\n    if (sent) return;\n    sent = true;\n    var args = toArray(arguments);\n    debug('sending ack %j', args);\n\n    self.packet({\n      type: parser.ACK,\n      id: id,\n      data: args\n    });\n  };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function (packet) {\n  var ack = this.acks[packet.id];\n  if ('function' === typeof ack) {\n    debug('calling ack %s with %j', packet.id, packet.data);\n    ack.apply(this, packet.data);\n    delete this.acks[packet.id];\n  } else {\n    debug('bad ack %s', packet.id);\n  }\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function () {\n  this.connected = true;\n  this.disconnected = false;\n  this.emit('connect');\n  this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function () {\n  var i;\n  for (i = 0; i < this.receiveBuffer.length; i++) {\n    emit.apply(this, this.receiveBuffer[i]);\n  }\n  this.receiveBuffer = [];\n\n  for (i = 0; i < this.sendBuffer.length; i++) {\n    this.packet(this.sendBuffer[i]);\n  }\n  this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function () {\n  debug('server disconnect (%s)', this.nsp);\n  this.destroy();\n  this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function () {\n  if (this.subs) {\n    // clean subscriptions to avoid reconnections\n    for (var i = 0; i < this.subs.length; i++) {\n      this.subs[i].destroy();\n    }\n    this.subs = null;\n  }\n\n  this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function () {\n  if (this.connected) {\n    debug('performing disconnect (%s)', this.nsp);\n    this.packet({ type: parser.DISCONNECT });\n  }\n\n  // remove socket from pool\n  this.destroy();\n\n  if (this.connected) {\n    // fire events\n    this.onclose('io client disconnect');\n  }\n  return this;\n};\n\n/**\n * Sets the compress flag.\n *\n * @param {Boolean} if `true`, compresses the sending data\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.compress = function (compress) {\n  this.flags = this.flags || {};\n  this.flags.compress = compress;\n  return this;\n};\n\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports) {\n\n\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on (obj, ev, fn) {\n  obj.on(ev, fn);\n  return {\n    destroy: function () {\n      obj.removeListener(ev, fn);\n    }\n  };\n}\n\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports) {\n\n/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n  if ('string' == typeof fn) fn = obj[fn];\n  if ('function' != typeof fn) throw new Error('bind() requires a function');\n  var args = slice.call(arguments, 2);\n  return function(){\n    return fn.apply(obj, args.concat(slice.call(arguments)));\n  }\n};\n\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an action is invalid because the object has been\n * unsubscribed.\n *\n * @see {@link Subject}\n * @see {@link BehaviorSubject}\n *\n * @class ObjectUnsubscribedError\n */\nvar ObjectUnsubscribedError = (function (_super) {\n    __extends(ObjectUnsubscribedError, _super);\n    function ObjectUnsubscribedError() {\n        var err = _super.call(this, 'object unsubscribed');\n        this.name = err.name = 'ObjectUnsubscribedError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ObjectUnsubscribedError;\n}(Error));\nexports.ObjectUnsubscribedError = ObjectUnsubscribedError;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar multicast_1 = __webpack_require__(128);\nvar refCount_1 = __webpack_require__(71);\nvar Subject_1 = __webpack_require__(35);\nfunction shareSubjectFactory() {\n    return new Subject_1.Subject();\n}\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n * This is an alias for .multicast(() => new Subject()).refCount().\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return function (source) { return refCount_1.refCount()(multicast_1.multicast(shareSubjectFactory)(source)); };\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nfunction refCount() {\n    return function refCountOperatorFunction(source) {\n        return source.lift(new RefCountOperator(source));\n    };\n}\nexports.refCount = refCount;\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=refCount.js.map\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar map_1 = __webpack_require__(2);\r\nvar tap_1 = __webpack_require__(6);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nvar Log = __webpack_require__(16);\r\nfunction propSetDomEffect(xs) {\r\n    return xs.pipe(tap_1.tap(function (event) {\r\n        var target = event.target, prop = event.prop, value = event.value;\r\n        target[prop] = value;\r\n    }), map_1.map(function (e) {\r\n        return Log.consoleInfo(\"[PropSet]\", e.target, e.prop + \" = \" + e.pathname);\r\n    }));\r\n}\r\nexports.propSetDomEffect = propSetDomEffect;\r\nfunction propSet(incoming) {\r\n    return [dom_effects_1.Events.PropSet, incoming];\r\n}\r\nexports.propSet = propSet;\r\n\n\n/***/ }),\n/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar isArray_1 = __webpack_require__(28);\nfunction isNumeric(val) {\n    // parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    // adding 1 corrects loss of precision from parseFloat (#15100)\n    return !isArray_1.isArray(val) && (val - parseFloat(val) + 1) >= 0;\n}\nexports.isNumeric = isNumeric;\n;\n//# sourceMappingURL=isNumeric.js.map\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar AsyncAction_1 = __webpack_require__(75);\nvar AsyncScheduler_1 = __webpack_require__(76);\n/**\n *\n * Async Scheduler\n *\n * <span class=\"informal\">Schedule task as if you used setTimeout(task, duration)</span>\n *\n * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript\n * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating\n * in intervals.\n *\n * If you just want to \"defer\" task, that is to perform it right after currently\n * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),\n * better choice will be the {@link asap} scheduler.\n *\n * @example <caption>Use async scheduler to delay task</caption>\n * const task = () => console.log('it works!');\n *\n * Rx.Scheduler.async.schedule(task, 2000);\n *\n * // After 2 seconds logs:\n * // \"it works!\"\n *\n *\n * @example <caption>Use async scheduler to repeat task in intervals</caption>\n * function task(state) {\n *   console.log(state);\n *   this.schedule(state + 1, 1000); // `this` references currently executing Action,\n *                                   // which we reschedule with new state and delay\n * }\n *\n * Rx.Scheduler.async.schedule(task, 3000, 0);\n *\n * // Logs:\n * // 0 after 3s\n * // 1 after 4s\n * // 2 after 5s\n * // 3 after 6s\n *\n * @static true\n * @name async\n * @owner Scheduler\n */\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = __webpack_require__(8);\nvar Action_1 = __webpack_require__(132);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsyncAction = (function (_super) {\n    __extends(AsyncAction, _super);\n    function AsyncAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.work = work;\n        this.pending = false;\n    }\n    AsyncAction.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        if (this.closed) {\n            return this;\n        }\n        // Always replace the current state with the new state.\n        this.state = state;\n        // Set the pending flag indicating that this action has been scheduled, or\n        // has recursively rescheduled itself.\n        this.pending = true;\n        var id = this.id;\n        var scheduler = this.scheduler;\n        //\n        // Important implementation note:\n        //\n        // Actions only execute once by default, unless rescheduled from within the\n        // scheduled callback. This allows us to implement single and repeat\n        // actions via the same code path, without adding API surface area, as well\n        // as mimic traditional recursion but across asynchronous boundaries.\n        //\n        // However, JS runtimes and timers distinguish between intervals achieved by\n        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of\n        // serial `setTimeout` calls can be individually delayed, which delays\n        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to\n        // guarantee the interval callback will be invoked more precisely to the\n        // interval period, regardless of load.\n        //\n        // Therefore, we use `setInterval` to schedule single and repeat actions.\n        // If the action reschedules itself with the same delay, the interval is not\n        // canceled. If the action doesn't reschedule, or reschedules with a\n        // different delay, the interval will be canceled after scheduled callback\n        // execution.\n        //\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, delay);\n        }\n        this.delay = delay;\n        // If this action has already an async Id, don't request a new one.\n        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);\n        return this;\n    };\n    AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        return root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);\n    };\n    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If this action is rescheduled with the same delay time, don't clear the interval id.\n        if (delay !== null && this.delay === delay && this.pending === false) {\n            return id;\n        }\n        // Otherwise, if the action's delay time is different from the current delay,\n        // or the action has been rescheduled before it's executed, clear the interval id\n        return root_1.root.clearInterval(id) && undefined || undefined;\n    };\n    /**\n     * Immediately executes this action and the `work` it contains.\n     * @return {any}\n     */\n    AsyncAction.prototype.execute = function (state, delay) {\n        if (this.closed) {\n            return new Error('executing a cancelled action');\n        }\n        this.pending = false;\n        var error = this._execute(state, delay);\n        if (error) {\n            return error;\n        }\n        else if (this.pending === false && this.id != null) {\n            // Dequeue if the action didn't reschedule itself. Don't call\n            // unsubscribe(), because the action could reschedule later.\n            // For example:\n            // ```\n            // scheduler.schedule(function doWork(counter) {\n            //   /* ... I'm a busy worker bee ... */\n            //   var originalAction = this;\n            //   /* wait 100ms before rescheduling the action */\n            //   setTimeout(function () {\n            //     originalAction.schedule(counter + 1);\n            //   }, 100);\n            // }, 1000);\n            // ```\n            this.id = this.recycleAsyncId(this.scheduler, this.id, null);\n        }\n    };\n    AsyncAction.prototype._execute = function (state, delay) {\n        var errored = false;\n        var errorValue = undefined;\n        try {\n            this.work(state);\n        }\n        catch (e) {\n            errored = true;\n            errorValue = !!e && e || new Error(e);\n        }\n        if (errored) {\n            this.unsubscribe();\n            return errorValue;\n        }\n    };\n    AsyncAction.prototype._unsubscribe = function () {\n        var id = this.id;\n        var scheduler = this.scheduler;\n        var actions = scheduler.actions;\n        var index = actions.indexOf(this);\n        this.work = null;\n        this.state = null;\n        this.pending = false;\n        this.scheduler = null;\n        if (index !== -1) {\n            actions.splice(index, 1);\n        }\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, null);\n        }\n        this.delay = null;\n    };\n    return AsyncAction;\n}(Action_1.Action));\nexports.AsyncAction = AsyncAction;\n//# sourceMappingURL=AsyncAction.js.map\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Scheduler_1 = __webpack_require__(133);\nvar AsyncScheduler = (function (_super) {\n    __extends(AsyncScheduler, _super);\n    function AsyncScheduler() {\n        _super.apply(this, arguments);\n        this.actions = [];\n        /**\n         * A flag to indicate whether the Scheduler is currently executing a batch of\n         * queued actions.\n         * @type {boolean}\n         */\n        this.active = false;\n        /**\n         * An internal ID used to track the latest asynchronous task such as those\n         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and\n         * others.\n         * @type {any}\n         */\n        this.scheduled = undefined;\n    }\n    AsyncScheduler.prototype.flush = function (action) {\n        var actions = this.actions;\n        if (this.active) {\n            actions.push(action);\n            return;\n        }\n        var error;\n        this.active = true;\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (action = actions.shift()); // exhaust the scheduler queue\n        this.active = false;\n        if (error) {\n            while (action = actions.shift()) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsyncScheduler;\n}(Scheduler_1.Scheduler));\nexports.AsyncScheduler = AsyncScheduler;\n//# sourceMappingURL=AsyncScheduler.js.map\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar map_1 = __webpack_require__(2);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nvar tap_1 = __webpack_require__(6);\r\nvar Log = __webpack_require__(16);\r\nfunction styleSetDomEffect(xs) {\r\n    return xs.pipe(tap_1.tap(function (event) {\r\n        var style = event.style, styleName = event.styleName, newValue = event.newValue;\r\n        style[styleName] = newValue;\r\n    }), map_1.map(function (e) { return Log.consoleInfo(\"[StyleSet] \" + e.styleName + \" = \" + e.pathName); }));\r\n}\r\nexports.styleSetDomEffect = styleSetDomEffect;\r\nfunction styleSet(incoming) {\r\n    return [dom_effects_1.Events.StyleSet, incoming];\r\n}\r\nexports.styleSet = styleSet;\r\n\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar map_1 = __webpack_require__(2);\r\nvar filter_1 = __webpack_require__(4);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar Log = __webpack_require__(16);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nfunction linkReplaceDomEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"injectNotification\"))), filter_1.filter(function (_a) {\r\n        var inject = _a[1];\r\n        return inject;\r\n    }), map_1.map(function (_a) {\r\n        var incoming = _a[0], inject = _a[1];\r\n        var message = \"[LinkReplace] \" + incoming.basename;\r\n        if (inject === \"overlay\") {\r\n            return Log.overlayInfo(message);\r\n        }\r\n        return Log.consoleInfo(message);\r\n    }));\r\n}\r\nexports.linkReplaceDomEffect = linkReplaceDomEffect;\r\nfunction linkReplace(incoming) {\r\n    return [dom_effects_1.Events.LinkReplace, incoming];\r\n}\r\nexports.linkReplace = linkReplace;\r\n\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar tap_1 = __webpack_require__(6);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nfunction setScroll(x, y) {\r\n    return [dom_effects_1.Events.SetScroll, { x: x, y: y }];\r\n}\r\nexports.setScroll = setScroll;\r\nfunction setScrollDomEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$), tap_1.tap(function (_a) {\r\n        var event = _a[0], window = _a[1];\r\n        return window.scrollTo(event.x, event.y);\r\n    }), ignoreElements_1.ignoreElements());\r\n}\r\nexports.setScrollDomEffect = setScrollDomEffect;\r\n\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar tap_1 = __webpack_require__(6);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nfunction setWindowNameDomEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$), tap_1.tap(function (_a) {\r\n        var value = _a[0], window = _a[1];\r\n        return (window.name = value);\r\n    }), ignoreElements_1.ignoreElements());\r\n}\r\nexports.setWindowNameDomEffect = setWindowNameDomEffect;\r\nfunction setWindowName(incoming) {\r\n    return [dom_effects_1.Events.SetWindowName, incoming];\r\n}\r\nexports.setWindowName = setWindowName;\r\n\n\n/***/ }),\n/* 81 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar effects_1 = __webpack_require__(9);\r\nfunction outgoing(data, tagName, index, mappingIndex) {\r\n    if (mappingIndex === void 0) { mappingIndex = -1; }\r\n    return [\r\n        socket_messages_1.OutgoingSocketEvents.Scroll,\r\n        { position: data, tagName: tagName, index: index, mappingIndex: mappingIndex }\r\n    ];\r\n}\r\nexports.outgoing = outgoing;\r\nfunction incomingScrollHandler(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"ghostMode\", \"scroll\")), inputs.window$.pipe(pluck_1.pluck(\"location\", \"pathname\"))), filter_1.filter(function (_a) {\r\n        var event = _a[0], canScroll = _a[1], pathname = _a[2];\r\n        return canScroll && event.pathname === pathname;\r\n    }), map_1.map(function (_a) {\r\n        var event = _a[0];\r\n        return [effects_1.EffectNames.BrowserSetScroll, event];\r\n    }));\r\n}\r\nexports.incomingScrollHandler = incomingScrollHandler;\r\n\n\n/***/ }),\n/* 82 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar effects_1 = __webpack_require__(9);\r\nvar Reloader_1 = __webpack_require__(136);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nfunction fileReload(event) {\r\n    return [effects_1.EffectNames.FileReload, event];\r\n}\r\nexports.fileReload = fileReload;\r\n/**\r\n * Attempt to reload files in place\r\n * @param xs\r\n * @param inputs\r\n */\r\nfunction fileReloadEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$, inputs.document$, inputs.navigator$), mergeMap_1.mergeMap(function (_a) {\r\n        var event = _a[0], options = _a[1], document = _a[2], navigator = _a[3];\r\n        return Reloader_1.reload(document, navigator)(event, {\r\n            tagNames: options.tagNames,\r\n            liveCSS: true,\r\n            liveImg: true\r\n        });\r\n    }));\r\n}\r\nexports.fileReloadEffect = fileReloadEffect;\r\n\n\n/***/ }),\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar FromObservable_1 = __webpack_require__(137);\nexports.from = FromObservable_1.FromObservable.create;\n//# sourceMappingURL=from.js.map\n\n/***/ }),\n/* 84 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar mergeMap_1 = __webpack_require__(17);\nvar identity_1 = __webpack_require__(144);\n/**\n * Converts a higher-order Observable into a first-order Observable which\n * concurrently delivers all values that are emitted on the inner Observables.\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables.</span>\n *\n * <img src=\"./img/mergeAll.png\" width=\"100%\">\n *\n * `mergeAll` subscribes to an Observable that emits Observables, also known as\n * a higher-order Observable. Each time it observes one of these emitted inner\n * Observables, it subscribes to that and delivers all the values from the\n * inner Observable on the output Observable. The output Observable only\n * completes once all inner Observables have completed. Any error delivered by\n * a inner Observable will be immediately emitted on the output Observable.\n *\n * @example <caption>Spawn a new interval Observable for each click event, and blend their outputs as one Observable</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000));\n * var firstOrder = higherOrder.mergeAll();\n * firstOrder.subscribe(x => console.log(x));\n *\n * @example <caption>Count from 0 to 9 every second for each click, but only allow 2 concurrent timers</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(10));\n * var firstOrder = higherOrder.mergeAll(2);\n * firstOrder.subscribe(x => console.log(x));\n *\n * @see {@link combineAll}\n * @see {@link concatAll}\n * @see {@link exhaust}\n * @see {@link merge}\n * @see {@link mergeMap}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switch}\n * @see {@link zipAll}\n *\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of inner\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits values coming from all the\n * inner Observables emitted by the source Observable.\n * @method mergeAll\n * @owner Observable\n */\nfunction mergeAll(concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return mergeMap_1.mergeMap(identity_1.identity, null, concurrent);\n}\nexports.mergeAll = mergeAll;\n//# sourceMappingURL=mergeAll.js.map\n\n/***/ }),\n/* 85 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/**\n * Emits the given constant value on the output Observable every time the source\n * Observable emits a value.\n *\n * <span class=\"informal\">Like {@link map}, but it maps every source value to\n * the same output value every time.</span>\n *\n * <img src=\"./img/mapTo.png\" width=\"100%\">\n *\n * Takes a constant `value` as argument, and emits that whenever the source\n * Observable emits a value. In other words, ignores the actual source value,\n * and simply uses the emission moment to know when to emit the given `value`.\n *\n * @example <caption>Map every click to the string 'Hi'</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var greetings = clicks.mapTo('Hi');\n * greetings.subscribe(x => console.log(x));\n *\n * @see {@link map}\n *\n * @param {any} value The value to map each source value to.\n * @return {Observable} An Observable that emits the given `value` every time\n * the source Observable emits something.\n * @method mapTo\n * @owner Observable\n */\nfunction mapTo(value) {\n    return function (source) { return source.lift(new MapToOperator(value)); };\n}\nexports.mapTo = mapTo;\nvar MapToOperator = (function () {\n    function MapToOperator(value) {\n        this.value = value;\n    }\n    MapToOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapToSubscriber(subscriber, this.value));\n    };\n    return MapToOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapToSubscriber = (function (_super) {\n    __extends(MapToSubscriber, _super);\n    function MapToSubscriber(destination, value) {\n        _super.call(this, destination);\n        this.value = value;\n    }\n    MapToSubscriber.prototype._next = function (x) {\n        this.destination.next(this.value);\n    };\n    return MapToSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=mapTo.js.map\n\n/***/ }),\n/* 86 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar effects_1 = __webpack_require__(9);\r\nfunction browserSetLocationEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$), tap_1.tap(function (_a) {\r\n        var event = _a[0], window = _a[1];\r\n        if (event.path) {\r\n            return (window.location =\r\n                window.location.protocol +\r\n                    \"//\" +\r\n                    window.location.host +\r\n                    event.path);\r\n        }\r\n        if (event.url) {\r\n            return (window.location = event.url);\r\n        }\r\n    }), ignoreElements_1.ignoreElements());\r\n}\r\nexports.browserSetLocationEffect = browserSetLocationEffect;\r\nfunction browserSetLocation(input) {\r\n    return [effects_1.EffectNames.BrowserSetLocation, input];\r\n}\r\nexports.browserSetLocation = browserSetLocation;\r\n\n\n/***/ }),\n/* 87 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar effects_1 = __webpack_require__(9);\r\nfunction simulateClickEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$, inputs.document$), tap_1.tap(function (_a) {\r\n        var event = _a[0], window = _a[1], document = _a[2];\r\n        var elems = document.getElementsByTagName(event.tagName);\r\n        var match = elems[event.index];\r\n        if (match) {\r\n            if (document.createEvent) {\r\n                window.setTimeout(function () {\r\n                    var evObj = document.createEvent(\"MouseEvents\");\r\n                    evObj.initEvent(\"click\", true, true);\r\n                    match.dispatchEvent(evObj);\r\n                }, 0);\r\n            }\r\n            else {\r\n                window.setTimeout(function () {\r\n                    if (document.createEventObject) {\r\n                        var evObj = document.createEventObject();\r\n                        evObj.cancelBubble = true;\r\n                        match.fireEvent(\"on\" + \"click\", evObj);\r\n                    }\r\n                }, 0);\r\n            }\r\n        }\r\n    }), ignoreElements_1.ignoreElements());\r\n}\r\nexports.simulateClickEffect = simulateClickEffect;\r\nfunction simulateClick(event) {\r\n    return [effects_1.EffectNames.SimulateClick, event];\r\n}\r\nexports.simulateClick = simulateClick;\r\n\n\n/***/ }),\n/* 88 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar effects_1 = __webpack_require__(9);\r\nfunction setElementValueEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.document$), tap_1.tap(function (_a) {\r\n        var event = _a[0], document = _a[1];\r\n        var elems = document.getElementsByTagName(event.tagName);\r\n        var match = elems[event.index];\r\n        if (match) {\r\n            match.value = event.value;\r\n        }\r\n    }));\r\n}\r\nexports.setElementValueEffect = setElementValueEffect;\r\nfunction setElementValue(event) {\r\n    return [effects_1.EffectNames.SetElementValue, event];\r\n}\r\nexports.setElementValue = setElementValue;\r\n\n\n/***/ }),\n/* 89 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar effects_1 = __webpack_require__(9);\r\nfunction setElementToggleValueEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.document$), tap_1.tap(function (_a) {\r\n        var event = _a[0], document = _a[1];\r\n        var elems = document.getElementsByTagName(event.tagName);\r\n        var match = elems[event.index];\r\n        if (match) {\r\n            if (event.type === \"radio\") {\r\n                match.checked = true;\r\n            }\r\n            if (event.type === \"checkbox\") {\r\n                match.checked = event.checked;\r\n            }\r\n            if (event.tagName === \"SELECT\") {\r\n                match.value = event.value;\r\n            }\r\n        }\r\n    }));\r\n}\r\nexports.setElementToggleValueEffect = setElementToggleValueEffect;\r\nfunction setElementToggleValue(event) {\r\n    return [effects_1.EffectNames.SetElementToggleValue, event];\r\n}\r\nexports.setElementToggleValue = setElementToggleValue;\r\n\n\n/***/ }),\n/* 90 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar effects_1 = __webpack_require__(9);\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nfunction browserReload() {\r\n    return [effects_1.EffectNames.BrowserReload];\r\n}\r\nexports.browserReload = browserReload;\r\nfunction preBrowserReload() {\r\n    return [effects_1.EffectNames.PreBrowserReload];\r\n}\r\nexports.preBrowserReload = preBrowserReload;\r\nfunction browserReloadEffect(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$), tap_1.tap(function (_a) {\r\n        var window = _a[1];\r\n        return window.location.reload(true);\r\n    }));\r\n}\r\nexports.browserReloadEffect = browserReloadEffect;\r\n\n\n/***/ }),\n/* 91 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar simulate_click_effect_1 = __webpack_require__(87);\r\nfunction outgoing(data) {\r\n    return [socket_messages_1.OutgoingSocketEvents.Click, data];\r\n}\r\nexports.outgoing = outgoing;\r\nfunction incomingHandler$(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"ghostMode\", \"clicks\")), inputs.window$.pipe(pluck_1.pluck(\"location\", \"pathname\"))), filter_1.filter(function (_a) {\r\n        var event = _a[0], canClick = _a[1], pathname = _a[2];\r\n        return canClick && event.pathname === pathname;\r\n    }), map_1.map(function (_a) {\r\n        var event = _a[0];\r\n        return simulate_click_effect_1.simulateClick(event);\r\n    }));\r\n}\r\nexports.incomingHandler$ = incomingHandler$;\r\n\n\n/***/ }),\n/* 92 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n            t[p] = s[p];\r\n    }\r\n    return t;\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar set_element_value_effect_1 = __webpack_require__(88);\r\nfunction outgoing(element, value) {\r\n    return [\r\n        socket_messages_1.OutgoingSocketEvents.Keyup,\r\n        __assign({}, element, { value: value })\r\n    ];\r\n}\r\nexports.outgoing = outgoing;\r\nfunction incomingKeyupHandler(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"ghostMode\", \"forms\", \"inputs\")), inputs.window$.pipe(pluck_1.pluck(\"location\", \"pathname\"))), filter_1.filter(function (_a) {\r\n        var event = _a[0], canKeyup = _a[1], pathname = _a[2];\r\n        return canKeyup && event.pathname === pathname;\r\n    }), map_1.map(function (_a) {\r\n        var event = _a[0];\r\n        return set_element_value_effect_1.setElementValue(event);\r\n    }));\r\n}\r\nexports.incomingKeyupHandler = incomingKeyupHandler;\r\n\n\n/***/ }),\n/* 93 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(158);\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n\n/***/ }),\n/* 94 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n            t[p] = s[p];\r\n    }\r\n    return t;\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar set_element_toggle_value_effect_1 = __webpack_require__(89);\r\nfunction outgoing(element, props) {\r\n    return [\r\n        socket_messages_1.OutgoingSocketEvents.InputToggle,\r\n        __assign({}, element, props)\r\n    ];\r\n}\r\nexports.outgoing = outgoing;\r\nfunction incomingInputsToggles(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"ghostMode\", \"forms\", \"toggles\")), inputs.window$.pipe(pluck_1.pluck(\"location\", \"pathname\"))), filter_1.filter(function (_a) {\r\n        var toggles = _a[1];\r\n        return toggles === true;\r\n    }), map_1.map(function (_a) {\r\n        var event = _a[0];\r\n        return set_element_toggle_value_effect_1.setElementToggleValue(event);\r\n    }));\r\n}\r\nexports.incomingInputsToggles = incomingInputsToggles;\r\n\n\n/***/ }),\n/* 95 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(96);\n\n\n/***/ }),\n/* 96 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n            t[p] = s[p];\r\n    }\r\n    return t;\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar zip_1 = __webpack_require__(97);\r\nvar socket_1 = __webpack_require__(103);\r\nvar notify_1 = __webpack_require__(130);\r\nvar dom_effects_1 = __webpack_require__(21);\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar merge_1 = __webpack_require__(36);\r\nvar log_1 = __webpack_require__(16);\r\nvar effects_1 = __webpack_require__(9);\r\nvar scroll_restore_1 = __webpack_require__(164);\r\nvar listeners_1 = __webpack_require__(165);\r\nvar groupBy_1 = __webpack_require__(171);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nvar share_1 = __webpack_require__(70);\r\nvar filter_1 = __webpack_require__(4);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar of_1 = __webpack_require__(11);\r\nvar window$ = socket_1.initWindow();\r\nvar document$ = socket_1.initDocument();\r\nvar _a = socket_1.initSocket(), socket$ = _a.socket$, io$ = _a.io$;\r\nvar option$ = socket_1.initOptions();\r\nvar navigator$ = of_1.of(navigator);\r\nvar notifyElement$ = notify_1.initNotify(option$.getValue());\r\nvar logInstance$ = log_1.initLogger(option$.getValue());\r\nvar outgoing$ = listeners_1.initListeners(window, document, socket$, option$);\r\nvar inputs = {\r\n    window$: window$,\r\n    document$: document$,\r\n    socket$: socket$,\r\n    option$: option$,\r\n    navigator$: navigator$,\r\n    notifyElement$: notifyElement$,\r\n    logInstance$: logInstance$,\r\n    io$: io$,\r\n    outgoing$: outgoing$\r\n};\r\nfunction getStream(name, inputs) {\r\n    return function (handlers$, inputStream$) {\r\n        return inputStream$.pipe(groupBy_1.groupBy(function (_a) {\r\n            var keyName = _a[0];\r\n            return keyName;\r\n        }), withLatestFrom_1.withLatestFrom(handlers$), filter_1.filter(function (_a) {\r\n            var x = _a[0], handlers = _a[1];\r\n            return typeof handlers[x.key] === \"function\";\r\n        }), mergeMap_1.mergeMap(function (_a) {\r\n            var x = _a[0], handlers = _a[1];\r\n            return handlers[x.key](x.pipe(pluck_1.pluck(String(1))), inputs);\r\n        }), share_1.share());\r\n    };\r\n}\r\nvar combinedEffectHandler$ = zip_1.zip(effects_1.effectOutputHandlers$, scroll_restore_1.scrollRestoreHandlers$, function () {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return args.reduce(function (acc, item) { return (__assign({}, acc, item)); }, {});\r\n});\r\nvar output$ = getStream(\"[socket]\", inputs)(socket_messages_1.socketHandlers$, merge_1.merge(inputs.socket$, outgoing$));\r\nvar effect$ = getStream(\"[effect]\", inputs)(combinedEffectHandler$, output$);\r\nvar dom$ = getStream(\"[dom-effect]\", inputs)(dom_effects_1.domHandlers$, effect$);\r\nvar merged$ = merge_1.merge(output$, effect$, dom$);\r\nvar log$ = getStream(\"[log]\", inputs)(log_1.logHandler$, merged$);\r\nlog$.subscribe();\r\n// resume$.next(true);\r\n// var socket = require(\"./socket\");\r\n// var shims = require(\"./client-shims\");\r\n// var notify = require(\"./notify\");\r\n// // var codeSync = require(\"./code-sync\");\r\n// const { BrowserSync } = require(\"./browser-sync\");\r\n// var ghostMode = require(\"./ghostmode\");\r\n// var events = require(\"./events\");\r\n// var utils = require(\"./browser.utils\");\r\n//\r\n// const mitt = require(\"mitt\").default;\r\n//\r\n// var shouldReload = false;\r\n// var initialised = false;\r\n//\r\n// /**\r\n//  * @param options\r\n//  */\r\n// function init(options: bs.InitOptions) {\r\n//     if (shouldReload && options.reloadOnRestart) {\r\n//         utils.reloadBrowser();\r\n//     }\r\n//\r\n//     var BS = window.___browserSync___ || {};\r\n//     var emitter = mitt();\r\n//\r\n//     if (!BS.client) {\r\n//         BS.client = true;\r\n//\r\n//         var browserSync = new BrowserSync({ options, emitter, socket });\r\n//\r\n//         // codeSync.init(browserSync);\r\n//\r\n//         // // Always init on page load\r\n//         // ghostMode.init(browserSync);\r\n//         //\r\n//         // notify.init(browserSync);\r\n//         //\r\n//         // if (options.notify) {\r\n//         //     notify.flash(\"Connected to BrowserSync\");\r\n//         // }\r\n//     }\r\n//\r\n//     // if (!initialised) {\r\n//     //     socket.on(\"disconnect\", function() {\r\n//     //         if (options.notify) {\r\n//     //             notify.flash(\"Disconnected from BrowserSync\");\r\n//     //         }\r\n//     //         shouldReload = true;\r\n//     //     });\r\n//     //     initialised = true;\r\n//     // }\r\n// }\r\n//\r\n// /**\r\n//  * Handle individual socket connections\r\n//  */\r\n// socket.on(\"connection\", init);\r\n\n\n/***/ }),\n/* 97 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar zip_1 = __webpack_require__(98);\nexports.zip = zip_1.zipStatic;\n//# sourceMappingURL=zip.js.map\n\n/***/ }),\n/* 98 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar ArrayObservable_1 = __webpack_require__(25);\nvar isArray_1 = __webpack_require__(28);\nvar Subscriber_1 = __webpack_require__(3);\nvar OuterSubscriber_1 = __webpack_require__(30);\nvar subscribeToResult_1 = __webpack_require__(31);\nvar iterator_1 = __webpack_require__(32);\n/* tslint:enable:max-line-length */\n/**\n * @param observables\n * @return {Observable<R>}\n * @method zip\n * @owner Observable\n */\nfunction zip() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    return function zipOperatorFunction(source) {\n        return source.lift.call(zipStatic.apply(void 0, [source].concat(observables)));\n    };\n}\nexports.zip = zip;\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are calculated from the values, in order, of each\n * of its input Observables.\n *\n * If the latest parameter is a function, this function is used to compute the created value from the input values.\n * Otherwise, an array of the input values is returned.\n *\n * @example <caption>Combine age and name from different sources</caption>\n *\n * let age$ = Observable.of<number>(27, 25, 29);\n * let name$ = Observable.of<string>('Foo', 'Bar', 'Beer');\n * let isDev$ = Observable.of<boolean>(true, true, false);\n *\n * Observable\n *     .zip(age$,\n *          name$,\n *          isDev$,\n *          (age: number, name: string, isDev: boolean) => ({ age, name, isDev }))\n *     .subscribe(x => console.log(x));\n *\n * // outputs\n * // { age: 27, name: 'Foo', isDev: true }\n * // { age: 25, name: 'Bar', isDev: true }\n * // { age: 29, name: 'Beer', isDev: false }\n *\n * @param observables\n * @return {Observable<R>}\n * @static true\n * @name zip\n * @owner Observable\n */\nfunction zipStatic() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var project = observables[observables.length - 1];\n    if (typeof project === 'function') {\n        observables.pop();\n    }\n    return new ArrayObservable_1.ArrayObservable(observables).lift(new ZipOperator(project));\n}\nexports.zipStatic = zipStatic;\nvar ZipOperator = (function () {\n    function ZipOperator(project) {\n        this.project = project;\n    }\n    ZipOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ZipSubscriber(subscriber, this.project));\n    };\n    return ZipOperator;\n}());\nexports.ZipOperator = ZipOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ZipSubscriber = (function (_super) {\n    __extends(ZipSubscriber, _super);\n    function ZipSubscriber(destination, project, values) {\n        if (values === void 0) { values = Object.create(null); }\n        _super.call(this, destination);\n        this.iterators = [];\n        this.active = 0;\n        this.project = (typeof project === 'function') ? project : null;\n        this.values = values;\n    }\n    ZipSubscriber.prototype._next = function (value) {\n        var iterators = this.iterators;\n        if (isArray_1.isArray(value)) {\n            iterators.push(new StaticArrayIterator(value));\n        }\n        else if (typeof value[iterator_1.iterator] === 'function') {\n            iterators.push(new StaticIterator(value[iterator_1.iterator]()));\n        }\n        else {\n            iterators.push(new ZipBufferIterator(this.destination, this, value));\n        }\n    };\n    ZipSubscriber.prototype._complete = function () {\n        var iterators = this.iterators;\n        var len = iterators.length;\n        if (len === 0) {\n            this.destination.complete();\n            return;\n        }\n        this.active = len;\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            if (iterator.stillUnsubscribed) {\n                this.add(iterator.subscribe(iterator, i));\n            }\n            else {\n                this.active--; // not an observable\n            }\n        }\n    };\n    ZipSubscriber.prototype.notifyInactive = function () {\n        this.active--;\n        if (this.active === 0) {\n            this.destination.complete();\n        }\n    };\n    ZipSubscriber.prototype.checkIterators = function () {\n        var iterators = this.iterators;\n        var len = iterators.length;\n        var destination = this.destination;\n        // abort if not all of them have values\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) {\n                return;\n            }\n        }\n        var shouldComplete = false;\n        var args = [];\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            var result = iterator.next();\n            // check to see if it's completed now that you've gotten\n            // the next value.\n            if (iterator.hasCompleted()) {\n                shouldComplete = true;\n            }\n            if (result.done) {\n                destination.complete();\n                return;\n            }\n            args.push(result.value);\n        }\n        if (this.project) {\n            this._tryProject(args);\n        }\n        else {\n            destination.next(args);\n        }\n        if (shouldComplete) {\n            destination.complete();\n        }\n    };\n    ZipSubscriber.prototype._tryProject = function (args) {\n        var result;\n        try {\n            result = this.project.apply(this, args);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return ZipSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ZipSubscriber = ZipSubscriber;\nvar StaticIterator = (function () {\n    function StaticIterator(iterator) {\n        this.iterator = iterator;\n        this.nextResult = iterator.next();\n    }\n    StaticIterator.prototype.hasValue = function () {\n        return true;\n    };\n    StaticIterator.prototype.next = function () {\n        var result = this.nextResult;\n        this.nextResult = this.iterator.next();\n        return result;\n    };\n    StaticIterator.prototype.hasCompleted = function () {\n        var nextResult = this.nextResult;\n        return nextResult && nextResult.done;\n    };\n    return StaticIterator;\n}());\nvar StaticArrayIterator = (function () {\n    function StaticArrayIterator(array) {\n        this.array = array;\n        this.index = 0;\n        this.length = 0;\n        this.length = array.length;\n    }\n    StaticArrayIterator.prototype[iterator_1.iterator] = function () {\n        return this;\n    };\n    StaticArrayIterator.prototype.next = function (value) {\n        var i = this.index++;\n        var array = this.array;\n        return i < this.length ? { value: array[i], done: false } : { value: null, done: true };\n    };\n    StaticArrayIterator.prototype.hasValue = function () {\n        return this.array.length > this.index;\n    };\n    StaticArrayIterator.prototype.hasCompleted = function () {\n        return this.array.length === this.index;\n    };\n    return StaticArrayIterator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ZipBufferIterator = (function (_super) {\n    __extends(ZipBufferIterator, _super);\n    function ZipBufferIterator(destination, parent, observable) {\n        _super.call(this, destination);\n        this.parent = parent;\n        this.observable = observable;\n        this.stillUnsubscribed = true;\n        this.buffer = [];\n        this.isComplete = false;\n    }\n    ZipBufferIterator.prototype[iterator_1.iterator] = function () {\n        return this;\n    };\n    // NOTE: there is actually a name collision here with Subscriber.next and Iterator.next\n    //    this is legit because `next()` will never be called by a subscription in this case.\n    ZipBufferIterator.prototype.next = function () {\n        var buffer = this.buffer;\n        if (buffer.length === 0 && this.isComplete) {\n            return { value: null, done: true };\n        }\n        else {\n            return { value: buffer.shift(), done: false };\n        }\n    };\n    ZipBufferIterator.prototype.hasValue = function () {\n        return this.buffer.length > 0;\n    };\n    ZipBufferIterator.prototype.hasCompleted = function () {\n        return this.buffer.length === 0 && this.isComplete;\n    };\n    ZipBufferIterator.prototype.notifyComplete = function () {\n        if (this.buffer.length > 0) {\n            this.isComplete = true;\n            this.parent.notifyInactive();\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    ZipBufferIterator.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.buffer.push(innerValue);\n        this.parent.checkIterators();\n    };\n    ZipBufferIterator.prototype.subscribe = function (value, index) {\n        return subscribeToResult_1.subscribeToResult(this, this.observable, this, index);\n    };\n    return ZipBufferIterator;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=zip.js.map\n\n/***/ }),\n/* 99 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Subscriber_1 = __webpack_require__(3);\nvar rxSubscriber_1 = __webpack_require__(42);\nvar Observer_1 = __webpack_require__(53);\nfunction toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {\n            return nextOrObserver[rxSubscriber_1.rxSubscriber]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber_1.Subscriber(Observer_1.empty);\n    }\n    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map\n\n/***/ }),\n/* 100 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n    __extends(UnsubscriptionError, _super);\n    function UnsubscriptionError(errors) {\n        _super.call(this);\n        this.errors = errors;\n        var err = Error.call(this, errors ?\n            errors.length + \" errors occurred during unsubscription:\\n  \" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n  ') : '');\n        this.name = err.name = 'UnsubscriptionError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map\n\n/***/ }),\n/* 101 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar noop_1 = __webpack_require__(54);\n/* tslint:enable:max-line-length */\nfunction pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i - 0] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexports.pipe = pipe;\n/* @internal */\nfunction pipeFromArray(fns) {\n    if (!fns) {\n        return noop_1.noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\nexports.pipeFromArray = pipeFromArray;\n//# sourceMappingURL=pipe.js.map\n\n/***/ }),\n/* 102 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerSubscriber = (function (_super) {\n    __extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        _super.call(this);\n        this.parent = parent;\n        this.outerValue = outerValue;\n        this.outerIndex = outerIndex;\n        this.index = 0;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber_1.Subscriber));\nexports.InnerSubscriber = InnerSubscriber;\n//# sourceMappingURL=InnerSubscriber.js.map\n\n/***/ }),\n/* 103 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket = __webpack_require__(104);\r\nvar Observable_1 = __webpack_require__(1);\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar of_1 = __webpack_require__(11);\r\nvar share_1 = __webpack_require__(70);\r\n/**\r\n * Alias for socket.emit\r\n * @param name\r\n * @param data\r\n */\r\n// export function emit(name, data) {\r\n//     if (io && io.emit) {\r\n//         // send relative path of where the event is sent\r\n//         data.url = window.location.pathname;\r\n//         io.emit(name, data);\r\n//     }\r\n// }\r\n//\r\n// /**\r\n//  * Alias for socket.on\r\n//  * @param name\r\n//  * @param func\r\n//  */\r\n// export function on(name, func) {\r\n//     io.on(name, func);\r\n// }\r\nfunction initWindow() {\r\n    return of_1.of(window);\r\n}\r\nexports.initWindow = initWindow;\r\nfunction initDocument() {\r\n    return of_1.of(document);\r\n}\r\nexports.initDocument = initDocument;\r\nfunction initNavigator() {\r\n    return of_1.of(navigator);\r\n}\r\nexports.initNavigator = initNavigator;\r\nfunction initOptions() {\r\n    return new BehaviorSubject_1.BehaviorSubject(window.___browserSync___.options);\r\n}\r\nexports.initOptions = initOptions;\r\nfunction initSocket() {\r\n    /**\r\n     * @type {{emit: emit, on: on}}\r\n     */\r\n    var socketConfig = window.___browserSync___.socketConfig;\r\n    var socketUrl = window.___browserSync___.socketUrl;\r\n    var io = socket(socketUrl, socketConfig);\r\n    var onevent = io.onevent;\r\n    var socket$ = Observable_1.Observable.create(function (obs) {\r\n        io.onevent = function (packet) {\r\n            onevent.call(this, packet);\r\n            obs.next(packet.data);\r\n        };\r\n    }).pipe(share_1.share());\r\n    var io$ = new BehaviorSubject_1.BehaviorSubject(io);\r\n    /**\r\n     * *****BACK-COMPAT*******\r\n     * Scripts that come after Browsersync may rely on the previous window.___browserSync___.socket\r\n     */\r\n    window.___browserSync___.socket = io;\r\n    return { socket$: socket$, io$: io$ };\r\n}\r\nexports.initSocket = initSocket;\r\n\n\n/***/ }),\n/* 104 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Module dependencies.\n */\n\nvar url = __webpack_require__(105);\nvar parser = __webpack_require__(45);\nvar Manager = __webpack_require__(61);\nvar debug = __webpack_require__(10)('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n *   `io('http://localhost/a');`\n *   `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup (uri, opts) {\n  if (typeof uri === 'object') {\n    opts = uri;\n    uri = undefined;\n  }\n\n  opts = opts || {};\n\n  var parsed = url(uri);\n  var source = parsed.source;\n  var id = parsed.id;\n  var path = parsed.path;\n  var sameNamespace = cache[id] && path in cache[id].nsps;\n  var newConnection = opts.forceNew || opts['force new connection'] ||\n                      false === opts.multiplex || sameNamespace;\n\n  var io;\n\n  if (newConnection) {\n    debug('ignoring socket cache for %s', source);\n    io = Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      debug('new io instance for %s', source);\n      cache[id] = Manager(source, opts);\n    }\n    io = cache[id];\n  }\n  if (parsed.query && !opts.query) {\n    opts.query = parsed.query;\n  }\n  return io.socket(parsed.path, opts);\n}\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = __webpack_require__(61);\nexports.Socket = __webpack_require__(66);\n\n\n/***/ }),\n/* 105 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {\n/**\n * Module dependencies.\n */\n\nvar parseuri = __webpack_require__(57);\nvar debug = __webpack_require__(10)('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n *                 Defaults to window.location.\n * @api public\n */\n\nfunction url (uri, loc) {\n  var obj = uri;\n\n  // default to window.location\n  loc = loc || global.location;\n  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n  // relative path support\n  if ('string' === typeof uri) {\n    if ('/' === uri.charAt(0)) {\n      if ('/' === uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      debug('protocol-less url %s', uri);\n      if ('undefined' !== typeof loc) {\n        uri = loc.protocol + '//' + uri;\n      } else {\n        uri = 'https://' + uri;\n      }\n    }\n\n    // parse\n    debug('parse %s', uri);\n    obj = parseuri(uri);\n  }\n\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = '80';\n    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = '443';\n    }\n  }\n\n  obj.path = obj.path || '/';\n\n  var ipv6 = obj.host.indexOf(':') !== -1;\n  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\n  // define unique id\n  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n  // define href\n  obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));\n\n  return obj;\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 106 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug['default'] = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = __webpack_require__(107);\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  exports.names = [];\n  exports.skips = [];\n\n  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n\n\n/***/ }),\n/* 107 */\n/***/ (function(module, exports) {\n\n/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return;\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name;\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n\n\n/***/ }),\n/* 108 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n/***/ }),\n/* 109 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = __webpack_require__(110);\nvar isBuf = __webpack_require__(60);\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof global.Blob === 'function' || toString.call(global.Blob) === '[object BlobConstructor]';\nvar withNativeFile = typeof global.File === 'function' || toString.call(global.File) === '[object FileConstructor]';\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet) {\n  var buffers = [];\n  var packetData = packet.data;\n  var pack = packet;\n  pack.data = _deconstructPacket(packetData, buffers);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {packet: pack, buffers: buffers};\n};\n\nfunction _deconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (isBuf(data)) {\n    var placeholder = { _placeholder: true, num: buffers.length };\n    buffers.push(data);\n    return placeholder;\n  } else if (isArray(data)) {\n    var newData = new Array(data.length);\n    for (var i = 0; i < data.length; i++) {\n      newData[i] = _deconstructPacket(data[i], buffers);\n    }\n    return newData;\n  } else if (typeof data === 'object' && !(data instanceof Date)) {\n    var newData = {};\n    for (var key in data) {\n      newData[key] = _deconstructPacket(data[key], buffers);\n    }\n    return newData;\n  }\n  return data;\n}\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n  packet.data = _reconstructPacket(packet.data, buffers);\n  packet.attachments = undefined; // no longer useful\n  return packet;\n};\n\nfunction _reconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (data && data._placeholder) {\n    return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n  } else if (isArray(data)) {\n    for (var i = 0; i < data.length; i++) {\n      data[i] = _reconstructPacket(data[i], buffers);\n    }\n  } else if (typeof data === 'object') {\n    for (var key in data) {\n      data[key] = _reconstructPacket(data[key], buffers);\n    }\n  }\n\n  return data;\n}\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n  function _removeBlobs(obj, curKey, containingObject) {\n    if (!obj) return obj;\n\n    // convert any blob\n    if ((withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File)) {\n      pendingBlobs++;\n\n      // async filereader\n      var fileReader = new FileReader();\n      fileReader.onload = function() { // this.result == arraybuffer\n        if (containingObject) {\n          containingObject[curKey] = this.result;\n        }\n        else {\n          bloblessData = this.result;\n        }\n\n        // if nothing pending its callback time\n        if(! --pendingBlobs) {\n          callback(bloblessData);\n        }\n      };\n\n      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n    } else if (isArray(obj)) { // handle array\n      for (var i = 0; i < obj.length; i++) {\n        _removeBlobs(obj[i], i, obj);\n      }\n    } else if (typeof obj === 'object' && !isBuf(obj)) { // and object\n      for (var key in obj) {\n        _removeBlobs(obj[key], key, obj);\n      }\n    }\n  }\n\n  var pendingBlobs = 0;\n  var bloblessData = data;\n  _removeBlobs(bloblessData);\n  if (!pendingBlobs) {\n    callback(bloblessData);\n  }\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 110 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n/***/ }),\n/* 111 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\nmodule.exports = __webpack_require__(112);\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = __webpack_require__(20);\n\n\n/***/ }),\n/* 112 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies.\n */\n\nvar transports = __webpack_require__(62);\nvar Emitter = __webpack_require__(19);\nvar debug = __webpack_require__(10)('engine.io-client:socket');\nvar index = __webpack_require__(65);\nvar parser = __webpack_require__(20);\nvar parseuri = __webpack_require__(57);\nvar parseqs = __webpack_require__(33);\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket (uri, opts) {\n  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n  opts = opts || {};\n\n  if (uri && 'object' === typeof uri) {\n    opts = uri;\n    uri = null;\n  }\n\n  if (uri) {\n    uri = parseuri(uri);\n    opts.hostname = uri.host;\n    opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';\n    opts.port = uri.port;\n    if (uri.query) opts.query = uri.query;\n  } else if (opts.host) {\n    opts.hostname = parseuri(opts.host).host;\n  }\n\n  this.secure = null != opts.secure ? opts.secure\n    : (global.location && 'https:' === location.protocol);\n\n  if (opts.hostname && !opts.port) {\n    // if no port is specified manually, use the protocol default\n    opts.port = this.secure ? '443' : '80';\n  }\n\n  this.agent = opts.agent || false;\n  this.hostname = opts.hostname ||\n    (global.location ? location.hostname : 'localhost');\n  this.port = opts.port || (global.location && location.port\n      ? location.port\n      : (this.secure ? 443 : 80));\n  this.query = opts.query || {};\n  if ('string' === typeof this.query) this.query = parseqs.decode(this.query);\n  this.upgrade = false !== opts.upgrade;\n  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n  this.forceJSONP = !!opts.forceJSONP;\n  this.jsonp = false !== opts.jsonp;\n  this.forceBase64 = !!opts.forceBase64;\n  this.enablesXDR = !!opts.enablesXDR;\n  this.timestampParam = opts.timestampParam || 't';\n  this.timestampRequests = opts.timestampRequests;\n  this.transports = opts.transports || ['polling', 'websocket'];\n  this.transportOptions = opts.transportOptions || {};\n  this.readyState = '';\n  this.writeBuffer = [];\n  this.prevBufferLen = 0;\n  this.policyPort = opts.policyPort || 843;\n  this.rememberUpgrade = opts.rememberUpgrade || false;\n  this.binaryType = null;\n  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\n  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n    this.perMessageDeflate.threshold = 1024;\n  }\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx || null;\n  this.key = opts.key || null;\n  this.passphrase = opts.passphrase || null;\n  this.cert = opts.cert || null;\n  this.ca = opts.ca || null;\n  this.ciphers = opts.ciphers || null;\n  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? true : opts.rejectUnauthorized;\n  this.forceNode = !!opts.forceNode;\n\n  // other options for Node.js client\n  var freeGlobal = typeof global === 'object' && global;\n  if (freeGlobal.global === freeGlobal) {\n    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n      this.extraHeaders = opts.extraHeaders;\n    }\n\n    if (opts.localAddress) {\n      this.localAddress = opts.localAddress;\n    }\n  }\n\n  // set on handshake\n  this.id = null;\n  this.upgrades = null;\n  this.pingInterval = null;\n  this.pingTimeout = null;\n\n  // set on heartbeat\n  this.pingIntervalTimer = null;\n  this.pingTimeoutTimer = null;\n\n  this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = __webpack_require__(47);\nSocket.transports = __webpack_require__(62);\nSocket.parser = __webpack_require__(20);\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n  debug('creating transport \"%s\"', name);\n  var query = clone(this.query);\n\n  // append engine.io protocol identifier\n  query.EIO = parser.protocol;\n\n  // transport name\n  query.transport = name;\n\n  // per-transport options\n  var options = this.transportOptions[name] || {};\n\n  // session id if we already have one\n  if (this.id) query.sid = this.id;\n\n  var transport = new transports[name]({\n    query: query,\n    socket: this,\n    agent: options.agent || this.agent,\n    hostname: options.hostname || this.hostname,\n    port: options.port || this.port,\n    secure: options.secure || this.secure,\n    path: options.path || this.path,\n    forceJSONP: options.forceJSONP || this.forceJSONP,\n    jsonp: options.jsonp || this.jsonp,\n    forceBase64: options.forceBase64 || this.forceBase64,\n    enablesXDR: options.enablesXDR || this.enablesXDR,\n    timestampRequests: options.timestampRequests || this.timestampRequests,\n    timestampParam: options.timestampParam || this.timestampParam,\n    policyPort: options.policyPort || this.policyPort,\n    pfx: options.pfx || this.pfx,\n    key: options.key || this.key,\n    passphrase: options.passphrase || this.passphrase,\n    cert: options.cert || this.cert,\n    ca: options.ca || this.ca,\n    ciphers: options.ciphers || this.ciphers,\n    rejectUnauthorized: options.rejectUnauthorized || this.rejectUnauthorized,\n    perMessageDeflate: options.perMessageDeflate || this.perMessageDeflate,\n    extraHeaders: options.extraHeaders || this.extraHeaders,\n    forceNode: options.forceNode || this.forceNode,\n    localAddress: options.localAddress || this.localAddress,\n    requestTimeout: options.requestTimeout || this.requestTimeout,\n    protocols: options.protocols || void (0)\n  });\n\n  return transport;\n};\n\nfunction clone (obj) {\n  var o = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      o[i] = obj[i];\n    }\n  }\n  return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n  var transport;\n  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {\n    transport = 'websocket';\n  } else if (0 === this.transports.length) {\n    // Emit error on next tick so it can be listened to\n    var self = this;\n    setTimeout(function () {\n      self.emit('error', 'No transports available');\n    }, 0);\n    return;\n  } else {\n    transport = this.transports[0];\n  }\n  this.readyState = 'opening';\n\n  // Retry with the next transport if the transport is disabled (jsonp: false)\n  try {\n    transport = this.createTransport(transport);\n  } catch (e) {\n    this.transports.shift();\n    this.open();\n    return;\n  }\n\n  transport.open();\n  this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function (transport) {\n  debug('setting transport %s', transport.name);\n  var self = this;\n\n  if (this.transport) {\n    debug('clearing existing transport %s', this.transport.name);\n    this.transport.removeAllListeners();\n  }\n\n  // set up transport\n  this.transport = transport;\n\n  // set up transport listeners\n  transport\n  .on('drain', function () {\n    self.onDrain();\n  })\n  .on('packet', function (packet) {\n    self.onPacket(packet);\n  })\n  .on('error', function (e) {\n    self.onError(e);\n  })\n  .on('close', function () {\n    self.onClose('transport close');\n  });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n  debug('probing transport \"%s\"', name);\n  var transport = this.createTransport(name, { probe: 1 });\n  var failed = false;\n  var self = this;\n\n  Socket.priorWebsocketSuccess = false;\n\n  function onTransportOpen () {\n    if (self.onlyBinaryUpgrades) {\n      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n      failed = failed || upgradeLosesBinary;\n    }\n    if (failed) return;\n\n    debug('probe transport \"%s\" opened', name);\n    transport.send([{ type: 'ping', data: 'probe' }]);\n    transport.once('packet', function (msg) {\n      if (failed) return;\n      if ('pong' === msg.type && 'probe' === msg.data) {\n        debug('probe transport \"%s\" pong', name);\n        self.upgrading = true;\n        self.emit('upgrading', transport);\n        if (!transport) return;\n        Socket.priorWebsocketSuccess = 'websocket' === transport.name;\n\n        debug('pausing current transport \"%s\"', self.transport.name);\n        self.transport.pause(function () {\n          if (failed) return;\n          if ('closed' === self.readyState) return;\n          debug('changing transport and sending upgrade packet');\n\n          cleanup();\n\n          self.setTransport(transport);\n          transport.send([{ type: 'upgrade' }]);\n          self.emit('upgrade', transport);\n          transport = null;\n          self.upgrading = false;\n          self.flush();\n        });\n      } else {\n        debug('probe transport \"%s\" failed', name);\n        var err = new Error('probe error');\n        err.transport = transport.name;\n        self.emit('upgradeError', err);\n      }\n    });\n  }\n\n  function freezeTransport () {\n    if (failed) return;\n\n    // Any callback called by transport should be ignored since now\n    failed = true;\n\n    cleanup();\n\n    transport.close();\n    transport = null;\n  }\n\n  // Handle any error that happens while probing\n  function onerror (err) {\n    var error = new Error('probe error: ' + err);\n    error.transport = transport.name;\n\n    freezeTransport();\n\n    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n    self.emit('upgradeError', error);\n  }\n\n  function onTransportClose () {\n    onerror('transport closed');\n  }\n\n  // When the socket is closed while we're probing\n  function onclose () {\n    onerror('socket closed');\n  }\n\n  // When the socket is upgraded while we're probing\n  function onupgrade (to) {\n    if (transport && to.name !== transport.name) {\n      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n      freezeTransport();\n    }\n  }\n\n  // Remove all listeners on the transport and on self\n  function cleanup () {\n    transport.removeListener('open', onTransportOpen);\n    transport.removeListener('error', onerror);\n    transport.removeListener('close', onTransportClose);\n    self.removeListener('close', onclose);\n    self.removeListener('upgrading', onupgrade);\n  }\n\n  transport.once('open', onTransportOpen);\n  transport.once('error', onerror);\n  transport.once('close', onTransportClose);\n\n  this.once('close', onclose);\n  this.once('upgrading', onupgrade);\n\n  transport.open();\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n  debug('socket open');\n  this.readyState = 'open';\n  Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;\n  this.emit('open');\n  this.flush();\n\n  // we check for `readyState` in case an `open`\n  // listener already closed the socket\n  if ('open' === this.readyState && this.upgrade && this.transport.pause) {\n    debug('starting upgrade probes');\n    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n      this.probe(this.upgrades[i]);\n    }\n  }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n  if ('opening' === this.readyState || 'open' === this.readyState ||\n      'closing' === this.readyState) {\n    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n    this.emit('packet', packet);\n\n    // Socket is live - any packet counts\n    this.emit('heartbeat');\n\n    switch (packet.type) {\n      case 'open':\n        this.onHandshake(JSON.parse(packet.data));\n        break;\n\n      case 'pong':\n        this.setPing();\n        this.emit('pong');\n        break;\n\n      case 'error':\n        var err = new Error('server error');\n        err.code = packet.data;\n        this.onError(err);\n        break;\n\n      case 'message':\n        this.emit('data', packet.data);\n        this.emit('message', packet.data);\n        break;\n    }\n  } else {\n    debug('packet received with socket readyState \"%s\"', this.readyState);\n  }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n  this.emit('handshake', data);\n  this.id = data.sid;\n  this.transport.query.sid = data.sid;\n  this.upgrades = this.filterUpgrades(data.upgrades);\n  this.pingInterval = data.pingInterval;\n  this.pingTimeout = data.pingTimeout;\n  this.onOpen();\n  // In case open handler closes socket\n  if ('closed' === this.readyState) return;\n  this.setPing();\n\n  // Prolong liveness of socket on heartbeat\n  this.removeListener('heartbeat', this.onHeartbeat);\n  this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n  clearTimeout(this.pingTimeoutTimer);\n  var self = this;\n  self.pingTimeoutTimer = setTimeout(function () {\n    if ('closed' === self.readyState) return;\n    self.onClose('ping timeout');\n  }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n  var self = this;\n  clearTimeout(self.pingIntervalTimer);\n  self.pingIntervalTimer = setTimeout(function () {\n    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n    self.ping();\n    self.onHeartbeat(self.pingTimeout);\n  }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api private\n*/\n\nSocket.prototype.ping = function () {\n  var self = this;\n  this.sendPacket('ping', function () {\n    self.emit('ping');\n  });\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function () {\n  this.writeBuffer.splice(0, this.prevBufferLen);\n\n  // setting prevBufferLen = 0 is very important\n  // for example, when upgrading, upgrade packet is sent over,\n  // and a nonzero prevBufferLen could cause problems on `drain`\n  this.prevBufferLen = 0;\n\n  if (0 === this.writeBuffer.length) {\n    this.emit('drain');\n  } else {\n    this.flush();\n  }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n  if ('closed' !== this.readyState && this.transport.writable &&\n    !this.upgrading && this.writeBuffer.length) {\n    debug('flushing %d packets in socket', this.writeBuffer.length);\n    this.transport.send(this.writeBuffer);\n    // keep track of current length of writeBuffer\n    // splice writeBuffer and callbackBuffer on `drain`\n    this.prevBufferLen = this.writeBuffer.length;\n    this.emit('flush');\n  }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @param {Object} options.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, options, fn) {\n  this.sendPacket('message', msg, options, fn);\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Object} options.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, options, fn) {\n  if ('function' === typeof data) {\n    fn = data;\n    data = undefined;\n  }\n\n  if ('function' === typeof options) {\n    fn = options;\n    options = null;\n  }\n\n  if ('closing' === this.readyState || 'closed' === this.readyState) {\n    return;\n  }\n\n  options = options || {};\n  options.compress = false !== options.compress;\n\n  var packet = {\n    type: type,\n    data: data,\n    options: options\n  };\n  this.emit('packetCreate', packet);\n  this.writeBuffer.push(packet);\n  if (fn) this.once('flush', fn);\n  this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.readyState = 'closing';\n\n    var self = this;\n\n    if (this.writeBuffer.length) {\n      this.once('drain', function () {\n        if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      });\n    } else if (this.upgrading) {\n      waitForUpgrade();\n    } else {\n      close();\n    }\n  }\n\n  function close () {\n    self.onClose('forced close');\n    debug('socket closing - telling transport to close');\n    self.transport.close();\n  }\n\n  function cleanupAndClose () {\n    self.removeListener('upgrade', cleanupAndClose);\n    self.removeListener('upgradeError', cleanupAndClose);\n    close();\n  }\n\n  function waitForUpgrade () {\n    // wait for upgrade to finish since we can't send packets while pausing a transport\n    self.once('upgrade', cleanupAndClose);\n    self.once('upgradeError', cleanupAndClose);\n  }\n\n  return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n  debug('socket error %j', err);\n  Socket.priorWebsocketSuccess = false;\n  this.emit('error', err);\n  this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n  if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {\n    debug('socket close with reason: \"%s\"', reason);\n    var self = this;\n\n    // clear timers\n    clearTimeout(this.pingIntervalTimer);\n    clearTimeout(this.pingTimeoutTimer);\n\n    // stop event from firing again for transport\n    this.transport.removeAllListeners('close');\n\n    // ensure transport won't stay open\n    this.transport.close();\n\n    // ignore further transport communication\n    this.transport.removeAllListeners();\n\n    // set ready state\n    this.readyState = 'closed';\n\n    // clear session id\n    this.id = null;\n\n    // emit close event\n    this.emit('close', reason, desc);\n\n    // clean buffers after, so users can still\n    // grab the buffers on `close` event\n    self.writeBuffer = [];\n    self.prevBufferLen = 0;\n  }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n  var filteredUpgrades = [];\n  for (var i = 0, j = upgrades.length; i < j; i++) {\n    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n  }\n  return filteredUpgrades;\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 113 */\n/***/ (function(module, exports) {\n\n\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n\n\n/***/ }),\n/* 114 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = __webpack_require__(46);\nvar Polling = __webpack_require__(63);\nvar Emitter = __webpack_require__(19);\nvar inherit = __webpack_require__(34);\nvar debug = __webpack_require__(10)('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty () {}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR (opts) {\n  Polling.call(this, opts);\n  this.requestTimeout = opts.requestTimeout;\n  this.extraHeaders = opts.extraHeaders;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    this.xd = opts.hostname !== global.location.hostname ||\n      port !== opts.port;\n    this.xs = opts.secure !== isSSL;\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function (opts) {\n  opts = opts || {};\n  opts.uri = this.uri();\n  opts.xd = this.xd;\n  opts.xs = this.xs;\n  opts.agent = this.agent || false;\n  opts.supportsBinary = this.supportsBinary;\n  opts.enablesXDR = this.enablesXDR;\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  opts.requestTimeout = this.requestTimeout;\n\n  // other options for Node.js client\n  opts.extraHeaders = this.extraHeaders;\n\n  return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function (data, fn) {\n  var isBinary = typeof data !== 'string' && data !== undefined;\n  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n  var self = this;\n  req.on('success', fn);\n  req.on('error', function (err) {\n    self.onError('xhr post error', err);\n  });\n  this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function () {\n  debug('xhr poll');\n  var req = this.request();\n  var self = this;\n  req.on('data', function (data) {\n    self.onData(data);\n  });\n  req.on('error', function (err) {\n    self.onError('xhr poll error', err);\n  });\n  this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request (opts) {\n  this.method = opts.method || 'GET';\n  this.uri = opts.uri;\n  this.xd = !!opts.xd;\n  this.xs = !!opts.xs;\n  this.async = false !== opts.async;\n  this.data = undefined !== opts.data ? opts.data : null;\n  this.agent = opts.agent;\n  this.isBinary = opts.isBinary;\n  this.supportsBinary = opts.supportsBinary;\n  this.enablesXDR = opts.enablesXDR;\n  this.requestTimeout = opts.requestTimeout;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n\n  this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function () {\n  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  var xhr = this.xhr = new XMLHttpRequest(opts);\n  var self = this;\n\n  try {\n    debug('xhr open %s: %s', this.method, this.uri);\n    xhr.open(this.method, this.uri, this.async);\n    try {\n      if (this.extraHeaders) {\n        xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n        for (var i in this.extraHeaders) {\n          if (this.extraHeaders.hasOwnProperty(i)) {\n            xhr.setRequestHeader(i, this.extraHeaders[i]);\n          }\n        }\n      }\n    } catch (e) {}\n\n    if ('POST' === this.method) {\n      try {\n        if (this.isBinary) {\n          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n        } else {\n          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n        }\n      } catch (e) {}\n    }\n\n    try {\n      xhr.setRequestHeader('Accept', '*/*');\n    } catch (e) {}\n\n    // ie6 check\n    if ('withCredentials' in xhr) {\n      xhr.withCredentials = true;\n    }\n\n    if (this.requestTimeout) {\n      xhr.timeout = this.requestTimeout;\n    }\n\n    if (this.hasXDR()) {\n      xhr.onload = function () {\n        self.onLoad();\n      };\n      xhr.onerror = function () {\n        self.onError(xhr.responseText);\n      };\n    } else {\n      xhr.onreadystatechange = function () {\n        if (xhr.readyState === 2) {\n          var contentType;\n          try {\n            contentType = xhr.getResponseHeader('Content-Type');\n          } catch (e) {}\n          if (contentType === 'application/octet-stream') {\n            xhr.responseType = 'arraybuffer';\n          }\n        }\n        if (4 !== xhr.readyState) return;\n        if (200 === xhr.status || 1223 === xhr.status) {\n          self.onLoad();\n        } else {\n          // make sure the `error` event handler that's user-set\n          // does not throw in the same tick and gets caught here\n          setTimeout(function () {\n            self.onError(xhr.status);\n          }, 0);\n        }\n      };\n    }\n\n    debug('xhr data %s', this.data);\n    xhr.send(this.data);\n  } catch (e) {\n    // Need to defer since .create() is called directly fhrom the constructor\n    // and thus the 'error' event can only be only bound *after* this exception\n    // occurs.  Therefore, also, we cannot throw here at all.\n    setTimeout(function () {\n      self.onError(e);\n    }, 0);\n    return;\n  }\n\n  if (global.document) {\n    this.index = Request.requestsCount++;\n    Request.requests[this.index] = this;\n  }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function () {\n  this.emit('success');\n  this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function (data) {\n  this.emit('data', data);\n  this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function (err) {\n  this.emit('error', err);\n  this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function (fromError) {\n  if ('undefined' === typeof this.xhr || null === this.xhr) {\n    return;\n  }\n  // xmlhttprequest\n  if (this.hasXDR()) {\n    this.xhr.onload = this.xhr.onerror = empty;\n  } else {\n    this.xhr.onreadystatechange = empty;\n  }\n\n  if (fromError) {\n    try {\n      this.xhr.abort();\n    } catch (e) {}\n  }\n\n  if (global.document) {\n    delete Request.requests[this.index];\n  }\n\n  this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function () {\n  var data;\n  try {\n    var contentType;\n    try {\n      contentType = this.xhr.getResponseHeader('Content-Type');\n    } catch (e) {}\n    if (contentType === 'application/octet-stream') {\n      data = this.xhr.response || this.xhr.responseText;\n    } else {\n      data = this.xhr.responseText;\n    }\n  } catch (e) {\n    this.onError(e);\n  }\n  if (null != data) {\n    this.onData(data);\n  }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function () {\n  return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function () {\n  this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nRequest.requestsCount = 0;\nRequest.requests = {};\n\nif (global.document) {\n  if (global.attachEvent) {\n    global.attachEvent('onunload', unloadHandler);\n  } else if (global.addEventListener) {\n    global.addEventListener('beforeunload', unloadHandler, false);\n  }\n}\n\nfunction unloadHandler () {\n  for (var i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 115 */\n/***/ (function(module, exports) {\n\n\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n  var arr = [];\n  var has = Object.prototype.hasOwnProperty;\n\n  for (var i in obj) {\n    if (has.call(obj, i)) {\n      arr.push(i);\n    }\n  }\n  return arr;\n};\n\n\n/***/ }),\n/* 116 */\n/***/ (function(module, exports) {\n\n/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n  var bytes = arraybuffer.byteLength;\n  start = start || 0;\n  end = end || bytes;\n\n  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n  if (start < 0) { start += bytes; }\n  if (end < 0) { end += bytes; }\n  if (end > bytes) { end = bytes; }\n\n  if (start >= bytes || start >= end || bytes === 0) {\n    return new ArrayBuffer(0);\n  }\n\n  var abv = new Uint8Array(arraybuffer);\n  var result = new Uint8Array(end - start);\n  for (var i = start, ii = 0; i < end; i++, ii++) {\n    result[ii] = abv[i];\n  }\n  return result.buffer;\n};\n\n\n/***/ }),\n/* 117 */\n/***/ (function(module, exports) {\n\nmodule.exports = after\n\nfunction after(count, callback, err_cb) {\n    var bail = false\n    err_cb = err_cb || noop\n    proxy.count = count\n\n    return (count === 0) ? callback() : proxy\n\n    function proxy(err, result) {\n        if (proxy.count <= 0) {\n            throw new Error('after called too many times')\n        }\n        --proxy.count\n\n        // after first error, rest are passed to err_cb\n        if (err) {\n            bail = true\n            callback(err)\n            // future error callbacks will go to error handler\n            callback = err_cb\n        } else if (proxy.count === 0 && !bail) {\n            callback(null, result)\n        }\n    }\n}\n\nfunction noop() {}\n\n\n/***/ }),\n/* 118 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint, strict) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tif (strict) {\n\t\t\t\tthrow Error(\n\t\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t\t' is not a scalar value'\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint, strict) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tif (!checkScalarValue(codePoint, strict)) {\n\t\t\t\tcodePoint = 0xFFFD;\n\t\t\t}\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string, opts) {\n\t\topts = opts || {};\n\t\tvar strict = false !== opts.strict;\n\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint, strict);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol(strict) {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\treturn checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString, opts) {\n\t\topts = opts || {};\n\t\tvar strict = false !== opts.strict;\n\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol(strict)) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttrue\n\t) {\n\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {\n\t\t\treturn utf8;\n\t\t}).call(exports, __webpack_require__, exports, module),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(119)(module), __webpack_require__(5)))\n\n/***/ }),\n/* 119 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n/***/ }),\n/* 120 */\n/***/ (function(module, exports) {\n\n/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\n\n\n/***/ }),\n/* 121 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Create a blob builder even when vendor prefixes exist\n */\n\nvar BlobBuilder = global.BlobBuilder\n  || global.WebKitBlobBuilder\n  || global.MSBlobBuilder\n  || global.MozBlobBuilder;\n\n/**\n * Check if Blob constructor is supported\n */\n\nvar blobSupported = (function() {\n  try {\n    var a = new Blob(['hi']);\n    return a.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if Blob constructor supports ArrayBufferViews\n * Fails in Safari 6, so we need to map to ArrayBuffers there.\n */\n\nvar blobSupportsArrayBufferView = blobSupported && (function() {\n  try {\n    var b = new Blob([new Uint8Array([1,2])]);\n    return b.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if BlobBuilder is supported\n */\n\nvar blobBuilderSupported = BlobBuilder\n  && BlobBuilder.prototype.append\n  && BlobBuilder.prototype.getBlob;\n\n/**\n * Helper function that maps ArrayBufferViews to ArrayBuffers\n * Used by BlobBuilder constructor and old browsers that didn't\n * support it in the Blob constructor.\n */\n\nfunction mapArrayBufferViews(ary) {\n  for (var i = 0; i < ary.length; i++) {\n    var chunk = ary[i];\n    if (chunk.buffer instanceof ArrayBuffer) {\n      var buf = chunk.buffer;\n\n      // if this is a subarray, make a copy so we only\n      // include the subarray region from the underlying buffer\n      if (chunk.byteLength !== buf.byteLength) {\n        var copy = new Uint8Array(chunk.byteLength);\n        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\n        buf = copy.buffer;\n      }\n\n      ary[i] = buf;\n    }\n  }\n}\n\nfunction BlobBuilderConstructor(ary, options) {\n  options = options || {};\n\n  var bb = new BlobBuilder();\n  mapArrayBufferViews(ary);\n\n  for (var i = 0; i < ary.length; i++) {\n    bb.append(ary[i]);\n  }\n\n  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n};\n\nfunction BlobConstructor(ary, options) {\n  mapArrayBufferViews(ary);\n  return new Blob(ary, options || {});\n};\n\nmodule.exports = (function() {\n  if (blobSupported) {\n    return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;\n  } else if (blobBuilderSupported) {\n    return BlobBuilderConstructor;\n  } else {\n    return undefined;\n  }\n})();\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 122 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {\n/**\n * Module requirements.\n */\n\nvar Polling = __webpack_require__(63);\nvar inherit = __webpack_require__(34);\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n  Polling.call(this, opts);\n\n  this.query = this.query || {};\n\n  // define global callbacks array if not present\n  // we do this here (lazily) to avoid unneeded global pollution\n  if (!callbacks) {\n    // we need to consider multiple engines in the same page\n    if (!global.___eio) global.___eio = [];\n    callbacks = global.___eio;\n  }\n\n  // callback identifier\n  this.index = callbacks.length;\n\n  // add callback to jsonp global\n  var self = this;\n  callbacks.push(function (msg) {\n    self.onData(msg);\n  });\n\n  // append to query string\n  this.query.j = this.index;\n\n  // prevent spurious errors from being emitted when the window is unloaded\n  if (global.document && global.addEventListener) {\n    global.addEventListener('beforeunload', function () {\n      if (self.script) self.script.onerror = empty;\n    }, false);\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  if (this.form) {\n    this.form.parentNode.removeChild(this.form);\n    this.form = null;\n    this.iframe = null;\n  }\n\n  Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n  var self = this;\n  var script = document.createElement('script');\n\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  script.async = true;\n  script.src = this.uri();\n  script.onerror = function (e) {\n    self.onError('jsonp poll error', e);\n  };\n\n  var insertAt = document.getElementsByTagName('script')[0];\n  if (insertAt) {\n    insertAt.parentNode.insertBefore(script, insertAt);\n  } else {\n    (document.head || document.body).appendChild(script);\n  }\n  this.script = script;\n\n  var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);\n\n  if (isUAgecko) {\n    setTimeout(function () {\n      var iframe = document.createElement('iframe');\n      document.body.appendChild(iframe);\n      document.body.removeChild(iframe);\n    }, 100);\n  }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n  var self = this;\n\n  if (!this.form) {\n    var form = document.createElement('form');\n    var area = document.createElement('textarea');\n    var id = this.iframeId = 'eio_iframe_' + this.index;\n    var iframe;\n\n    form.className = 'socketio';\n    form.style.position = 'absolute';\n    form.style.top = '-1000px';\n    form.style.left = '-1000px';\n    form.target = id;\n    form.method = 'POST';\n    form.setAttribute('accept-charset', 'utf-8');\n    area.name = 'd';\n    form.appendChild(area);\n    document.body.appendChild(form);\n\n    this.form = form;\n    this.area = area;\n  }\n\n  this.form.action = this.uri();\n\n  function complete () {\n    initIframe();\n    fn();\n  }\n\n  function initIframe () {\n    if (self.iframe) {\n      try {\n        self.form.removeChild(self.iframe);\n      } catch (e) {\n        self.onError('jsonp polling iframe removal error', e);\n      }\n    }\n\n    try {\n      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n      var html = '<iframe src=\"javascript:0\" name=\"' + self.iframeId + '\">';\n      iframe = document.createElement(html);\n    } catch (e) {\n      iframe = document.createElement('iframe');\n      iframe.name = self.iframeId;\n      iframe.src = 'javascript:0';\n    }\n\n    iframe.id = self.iframeId;\n\n    self.form.appendChild(iframe);\n    self.iframe = iframe;\n  }\n\n  initIframe();\n\n  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n  data = data.replace(rEscapedNewline, '\\\\\\n');\n  this.area.value = data.replace(rNewline, '\\\\n');\n\n  try {\n    this.form.submit();\n  } catch (e) {}\n\n  if (this.iframe.attachEvent) {\n    this.iframe.onreadystatechange = function () {\n      if (self.iframe.readyState === 'complete') {\n        complete();\n      }\n    };\n  } else {\n    this.iframe.onload = complete;\n  }\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 123 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies.\n */\n\nvar Transport = __webpack_require__(47);\nvar parser = __webpack_require__(20);\nvar parseqs = __webpack_require__(33);\nvar inherit = __webpack_require__(34);\nvar yeast = __webpack_require__(64);\nvar debug = __webpack_require__(10)('engine.io-client:websocket');\nvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\nvar NodeWebSocket;\nif (typeof window === 'undefined') {\n  try {\n    NodeWebSocket = __webpack_require__(124);\n  } catch (e) { }\n}\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocket = BrowserWebSocket;\nif (!WebSocket && typeof window === 'undefined') {\n  WebSocket = NodeWebSocket;\n}\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (forceBase64) {\n    this.supportsBinary = false;\n  }\n  this.perMessageDeflate = opts.perMessageDeflate;\n  this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;\n  this.protocols = opts.protocols;\n  if (!this.usingBrowserWebSocket) {\n    WebSocket = NodeWebSocket;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function () {\n  if (!this.check()) {\n    // let probe timeout\n    return;\n  }\n\n  var uri = this.uri();\n  var protocols = this.protocols;\n  var opts = {\n    agent: this.agent,\n    perMessageDeflate: this.perMessageDeflate\n  };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  if (this.extraHeaders) {\n    opts.headers = this.extraHeaders;\n  }\n  if (this.localAddress) {\n    opts.localAddress = this.localAddress;\n  }\n\n  try {\n    this.ws = this.usingBrowserWebSocket ? (protocols ? new WebSocket(uri, protocols) : new WebSocket(uri)) : new WebSocket(uri, protocols, opts);\n  } catch (err) {\n    return this.emit('error', err);\n  }\n\n  if (this.ws.binaryType === undefined) {\n    this.supportsBinary = false;\n  }\n\n  if (this.ws.supports && this.ws.supports.binary) {\n    this.supportsBinary = true;\n    this.ws.binaryType = 'nodebuffer';\n  } else {\n    this.ws.binaryType = 'arraybuffer';\n  }\n\n  this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function () {\n  var self = this;\n\n  this.ws.onopen = function () {\n    self.onOpen();\n  };\n  this.ws.onclose = function () {\n    self.onClose();\n  };\n  this.ws.onmessage = function (ev) {\n    self.onData(ev.data);\n  };\n  this.ws.onerror = function (e) {\n    self.onError('websocket error', e);\n  };\n};\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n\n  // encodePacket efficient as it uses WS framing\n  // no need for encodePayload\n  var total = packets.length;\n  for (var i = 0, l = total; i < l; i++) {\n    (function (packet) {\n      parser.encodePacket(packet, self.supportsBinary, function (data) {\n        if (!self.usingBrowserWebSocket) {\n          // always create a new object (GH-437)\n          var opts = {};\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n\n          if (self.perMessageDeflate) {\n            var len = 'string' === typeof data ? global.Buffer.byteLength(data) : data.length;\n            if (len < self.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n\n        // Sometimes the websocket has already been closed but the browser didn't\n        // have a chance of informing us about it yet, in that case send will\n        // throw an error\n        try {\n          if (self.usingBrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            self.ws.send(data);\n          } else {\n            self.ws.send(data, opts);\n          }\n        } catch (e) {\n          debug('websocket closed before onclose event');\n        }\n\n        --total || done();\n      });\n    })(packets[i]);\n  }\n\n  function done () {\n    self.emit('flush');\n\n    // fake drain\n    // defer to next tick to allow Socket to clear writeBuffer\n    setTimeout(function () {\n      self.writable = true;\n      self.emit('drain');\n    }, 0);\n  }\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function () {\n  Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function () {\n  if (typeof this.ws !== 'undefined') {\n    this.ws.close();\n  }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'wss' : 'ws';\n  var port = '';\n\n  // avoid port if default for schema\n  if (this.port && (('wss' === schema && Number(this.port) !== 443) ||\n    ('ws' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // append timestamp to URI\n  if (this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  // communicate binary support capabilities\n  if (!this.supportsBinary) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function () {\n  return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 124 */\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n/* 125 */\n/***/ (function(module, exports) {\n\nmodule.exports = toArray\n\nfunction toArray(list, index) {\n    var array = []\n\n    index = index || 0\n\n    for (var i = index || 0; i < list.length; i++) {\n        array[i - index] = list[i]\n    }\n\n    return array\n}\n\n\n/***/ }),\n/* 126 */\n/***/ (function(module, exports) {\n\n\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n\n\n/***/ }),\n/* 127 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = __webpack_require__(14);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SubjectSubscription = (function (_super) {\n    __extends(SubjectSubscription, _super);\n    function SubjectSubscription(subject, subscriber) {\n        _super.call(this);\n        this.subject = subject;\n        this.subscriber = subscriber;\n        this.closed = false;\n    }\n    SubjectSubscription.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.closed = true;\n        var subject = this.subject;\n        var observers = subject.observers;\n        this.subject = null;\n        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n            return;\n        }\n        var subscriberIndex = observers.indexOf(this.subscriber);\n        if (subscriberIndex !== -1) {\n            observers.splice(subscriberIndex, 1);\n        }\n    };\n    return SubjectSubscription;\n}(Subscription_1.Subscription));\nexports.SubjectSubscription = SubjectSubscription;\n//# sourceMappingURL=SubjectSubscription.js.map\n\n/***/ }),\n/* 128 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ConnectableObservable_1 = __webpack_require__(129);\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the results of invoking a specified selector on items\n * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.\n *\n * <img src=\"./img/multicast.png\" width=\"100%\">\n *\n * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through\n * which the source sequence's elements will be multicast to the selector function\n * or Subject to push source elements into.\n * @param {Function} [selector] - Optional selector function that can use the multicasted source stream\n * as many times as needed, without causing multiple subscriptions to the source stream.\n * Subscribers to the given source will receive all notifications of the source from the\n * time of the subscription forward.\n * @return {Observable} An Observable that emits the results of invoking the selector\n * on the items emitted by a `ConnectableObservable` that shares a single subscription to\n * the underlying stream.\n * @method multicast\n * @owner Observable\n */\nfunction multicast(subjectOrSubjectFactory, selector) {\n    return function multicastOperatorFunction(source) {\n        var subjectFactory;\n        if (typeof subjectOrSubjectFactory === 'function') {\n            subjectFactory = subjectOrSubjectFactory;\n        }\n        else {\n            subjectFactory = function subjectFactory() {\n                return subjectOrSubjectFactory;\n            };\n        }\n        if (typeof selector === 'function') {\n            return source.lift(new MulticastOperator(subjectFactory, selector));\n        }\n        var connectable = Object.create(source, ConnectableObservable_1.connectableObservableDescriptor);\n        connectable.source = source;\n        connectable.subjectFactory = subjectFactory;\n        return connectable;\n    };\n}\nexports.multicast = multicast;\nvar MulticastOperator = (function () {\n    function MulticastOperator(subjectFactory, selector) {\n        this.subjectFactory = subjectFactory;\n        this.selector = selector;\n    }\n    MulticastOperator.prototype.call = function (subscriber, source) {\n        var selector = this.selector;\n        var subject = this.subjectFactory();\n        var subscription = selector(subject).subscribe(subscriber);\n        subscription.add(source.subscribe(subject));\n        return subscription;\n    };\n    return MulticastOperator;\n}());\nexports.MulticastOperator = MulticastOperator;\n//# sourceMappingURL=multicast.js.map\n\n/***/ }),\n/* 129 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = __webpack_require__(35);\nvar Observable_1 = __webpack_require__(1);\nvar Subscriber_1 = __webpack_require__(3);\nvar Subscription_1 = __webpack_require__(14);\nvar refCount_1 = __webpack_require__(71);\n/**\n * @class ConnectableObservable<T>\n */\nvar ConnectableObservable = (function (_super) {\n    __extends(ConnectableObservable, _super);\n    function ConnectableObservable(source, subjectFactory) {\n        _super.call(this);\n        this.source = source;\n        this.subjectFactory = subjectFactory;\n        this._refCount = 0;\n        this._isComplete = false;\n    }\n    ConnectableObservable.prototype._subscribe = function (subscriber) {\n        return this.getSubject().subscribe(subscriber);\n    };\n    ConnectableObservable.prototype.getSubject = function () {\n        var subject = this._subject;\n        if (!subject || subject.isStopped) {\n            this._subject = this.subjectFactory();\n        }\n        return this._subject;\n    };\n    ConnectableObservable.prototype.connect = function () {\n        var connection = this._connection;\n        if (!connection) {\n            this._isComplete = false;\n            connection = this._connection = new Subscription_1.Subscription();\n            connection.add(this.source\n                .subscribe(new ConnectableSubscriber(this.getSubject(), this)));\n            if (connection.closed) {\n                this._connection = null;\n                connection = Subscription_1.Subscription.EMPTY;\n            }\n            else {\n                this._connection = connection;\n            }\n        }\n        return connection;\n    };\n    ConnectableObservable.prototype.refCount = function () {\n        return refCount_1.refCount()(this);\n    };\n    return ConnectableObservable;\n}(Observable_1.Observable));\nexports.ConnectableObservable = ConnectableObservable;\nvar connectableProto = ConnectableObservable.prototype;\nexports.connectableObservableDescriptor = {\n    operator: { value: null },\n    _refCount: { value: 0, writable: true },\n    _subject: { value: null, writable: true },\n    _connection: { value: null, writable: true },\n    _subscribe: { value: connectableProto._subscribe },\n    _isComplete: { value: connectableProto._isComplete, writable: true },\n    getSubject: { value: connectableProto.getSubject },\n    connect: { value: connectableProto.connect },\n    refCount: { value: connectableProto.refCount }\n};\nvar ConnectableSubscriber = (function (_super) {\n    __extends(ConnectableSubscriber, _super);\n    function ConnectableSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    ConnectableSubscriber.prototype._error = function (err) {\n        this._unsubscribe();\n        _super.prototype._error.call(this, err);\n    };\n    ConnectableSubscriber.prototype._complete = function () {\n        this.connectable._isComplete = true;\n        this._unsubscribe();\n        _super.prototype._complete.call(this);\n    };\n    ConnectableSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (connectable) {\n            this.connectable = null;\n            var connection = connectable._connection;\n            connectable._refCount = 0;\n            connectable._subject = null;\n            connectable._connection = null;\n            if (connection) {\n                connection.unsubscribe();\n            }\n        }\n    };\n    return ConnectableSubscriber;\n}(Subject_1.SubjectSubscriber));\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ConnectableObservable.js.map\n\n/***/ }),\n/* 130 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar styles = {\r\n    display: \"none\",\r\n    padding: \"15px\",\r\n    fontFamily: \"sans-serif\",\r\n    position: \"fixed\",\r\n    fontSize: \"0.9em\",\r\n    zIndex: 9999,\r\n    right: 0,\r\n    top: 0,\r\n    borderBottomLeftRadius: \"5px\",\r\n    backgroundColor: \"#1B2032\",\r\n    margin: 0,\r\n    color: \"white\",\r\n    textAlign: \"center\",\r\n    pointerEvents: \"none\"\r\n};\r\n/**\r\n * @param {IBrowserSyncOptions} options\r\n * @returns {BehaviorSubject<any>}\r\n */\r\nfunction initNotify(options) {\r\n    var cssStyles = styles;\r\n    var elem;\r\n    if (options.notify.styles) {\r\n        if (Object.prototype.toString.call(options.notify.styles) ===\r\n            \"[object Array]\") {\r\n            // handle original array behavior, replace all styles with a joined copy\r\n            cssStyles = options.notify.styles.join(\";\");\r\n        }\r\n        else {\r\n            for (var key in options.notify.styles) {\r\n                if (options.notify.styles.hasOwnProperty(key)) {\r\n                    cssStyles[key] = options.notify.styles[key];\r\n                }\r\n            }\r\n        }\r\n    }\r\n    elem = document.createElement(\"DIV\");\r\n    elem.id = \"__bs_notify__\";\r\n    if (typeof cssStyles === \"string\") {\r\n        elem.style.cssText = cssStyles;\r\n    }\r\n    else {\r\n        for (var rule in cssStyles) {\r\n            elem.style[rule] = cssStyles[rule];\r\n        }\r\n    }\r\n    return new BehaviorSubject_1.BehaviorSubject(elem);\r\n}\r\nexports.initNotify = initNotify;\r\n\n\n/***/ }),\n/* 131 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isNumeric_1 = __webpack_require__(73);\nvar Observable_1 = __webpack_require__(1);\nvar async_1 = __webpack_require__(74);\nvar isScheduler_1 = __webpack_require__(27);\nvar isDate_1 = __webpack_require__(134);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar TimerObservable = (function (_super) {\n    __extends(TimerObservable, _super);\n    function TimerObservable(dueTime, period, scheduler) {\n        if (dueTime === void 0) { dueTime = 0; }\n        _super.call(this);\n        this.period = -1;\n        this.dueTime = 0;\n        if (isNumeric_1.isNumeric(period)) {\n            this.period = Number(period) < 1 && 1 || Number(period);\n        }\n        else if (isScheduler_1.isScheduler(period)) {\n            scheduler = period;\n        }\n        if (!isScheduler_1.isScheduler(scheduler)) {\n            scheduler = async_1.async;\n        }\n        this.scheduler = scheduler;\n        this.dueTime = isDate_1.isDate(dueTime) ?\n            (+dueTime - this.scheduler.now()) :\n            dueTime;\n    }\n    /**\n     * Creates an Observable that starts emitting after an `initialDelay` and\n     * emits ever increasing numbers after each `period` of time thereafter.\n     *\n     * <span class=\"informal\">Its like {@link interval}, but you can specify when\n     * should the emissions start.</span>\n     *\n     * <img src=\"./img/timer.png\" width=\"100%\">\n     *\n     * `timer` returns an Observable that emits an infinite sequence of ascending\n     * integers, with a constant interval of time, `period` of your choosing\n     * between those emissions. The first emission happens after the specified\n     * `initialDelay`. The initial delay may be a {@link Date}. By default, this\n     * operator uses the `async` IScheduler to provide a notion of time, but you\n     * may pass any IScheduler to it. If `period` is not specified, the output\n     * Observable emits only one value, `0`. Otherwise, it emits an infinite\n     * sequence.\n     *\n     * @example <caption>Emits ascending numbers, one every second (1000ms), starting after 3 seconds</caption>\n     * var numbers = Rx.Observable.timer(3000, 1000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @example <caption>Emits one number after five seconds</caption>\n     * var numbers = Rx.Observable.timer(5000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @see {@link interval}\n     * @see {@link delay}\n     *\n     * @param {number|Date} initialDelay The initial delay time to wait before\n     * emitting the first value of `0`.\n     * @param {number} [period] The period of time between emissions of the\n     * subsequent numbers.\n     * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling\n     * the emission of values, and providing a notion of \"time\".\n     * @return {Observable} An Observable that emits a `0` after the\n     * `initialDelay` and ever increasing numbers after each `period` of time\n     * thereafter.\n     * @static true\n     * @name timer\n     * @owner Observable\n     */\n    TimerObservable.create = function (initialDelay, period, scheduler) {\n        if (initialDelay === void 0) { initialDelay = 0; }\n        return new TimerObservable(initialDelay, period, scheduler);\n    };\n    TimerObservable.dispatch = function (state) {\n        var index = state.index, period = state.period, subscriber = state.subscriber;\n        var action = this;\n        subscriber.next(index);\n        if (subscriber.closed) {\n            return;\n        }\n        else if (period === -1) {\n            return subscriber.complete();\n        }\n        state.index = index + 1;\n        action.schedule(state, period);\n    };\n    TimerObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, period = _a.period, dueTime = _a.dueTime, scheduler = _a.scheduler;\n        return scheduler.schedule(TimerObservable.dispatch, dueTime, {\n            index: index, period: period, subscriber: subscriber\n        });\n    };\n    return TimerObservable;\n}(Observable_1.Observable));\nexports.TimerObservable = TimerObservable;\n//# sourceMappingURL=TimerObservable.js.map\n\n/***/ }),\n/* 132 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = __webpack_require__(14);\n/**\n * A unit of work to be executed in a {@link Scheduler}. An action is typically\n * created from within a Scheduler and an RxJS user does not need to concern\n * themselves about creating and manipulating an Action.\n *\n * ```ts\n * class Action<T> extends Subscription {\n *   new (scheduler: Scheduler, work: (state?: T) => void);\n *   schedule(state?: T, delay: number = 0): Subscription;\n * }\n * ```\n *\n * @class Action<T>\n */\nvar Action = (function (_super) {\n    __extends(Action, _super);\n    function Action(scheduler, work) {\n        _super.call(this);\n    }\n    /**\n     * Schedules this action on its parent Scheduler for execution. May be passed\n     * some context object, `state`. May happen at some point in the future,\n     * according to the `delay` parameter, if specified.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler.\n     * @return {void}\n     */\n    Action.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        return this;\n    };\n    return Action;\n}(Subscription_1.Subscription));\nexports.Action = Action;\n//# sourceMappingURL=Action.js.map\n\n/***/ }),\n/* 133 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n/**\n * An execution context and a data structure to order tasks and schedule their\n * execution. Provides a notion of (potentially virtual) time, through the\n * `now()` getter method.\n *\n * Each unit of work in a Scheduler is called an {@link Action}.\n *\n * ```ts\n * class Scheduler {\n *   now(): number;\n *   schedule(work, delay?, state?): Subscription;\n * }\n * ```\n *\n * @class Scheduler\n */\nvar Scheduler = (function () {\n    function Scheduler(SchedulerAction, now) {\n        if (now === void 0) { now = Scheduler.now; }\n        this.SchedulerAction = SchedulerAction;\n        this.now = now;\n    }\n    /**\n     * Schedules a function, `work`, for execution. May happen at some point in\n     * the future, according to the `delay` parameter, if specified. May be passed\n     * some context object, `state`, which will be passed to the `work` function.\n     *\n     * The given arguments will be processed an stored as an Action object in a\n     * queue of actions.\n     *\n     * @param {function(state: ?T): ?Subscription} work A function representing a\n     * task, or some unit of work to be executed by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler itself.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @return {Subscription} A subscription in order to be able to unsubscribe\n     * the scheduled work.\n     */\n    Scheduler.prototype.schedule = function (work, delay, state) {\n        if (delay === void 0) { delay = 0; }\n        return new this.SchedulerAction(this, work).schedule(state, delay);\n    };\n    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };\n    return Scheduler;\n}());\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=Scheduler.js.map\n\n/***/ }),\n/* 134 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction isDate(value) {\n    return value instanceof Date && !isNaN(+value);\n}\nexports.isDate = isDate;\n//# sourceMappingURL=isDate.js.map\n\n/***/ }),\n/* 135 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n            t[p] = s[p];\r\n    }\r\n    return t;\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar emojis = {\r\n    trace: '🔍',\r\n    debug: '🐛',\r\n    info: '✨',\r\n    warn: '⚠️',\r\n    error: '🚨',\r\n    fatal: '💀'\r\n};\r\nvar levels = {\r\n    trace: 10,\r\n    debug: 20,\r\n    info: 30,\r\n    warn: 40,\r\n    error: 50,\r\n    fatal: 60\r\n};\r\nvar defaultColors = {\r\n    foreground: '#d3c0c8',\r\n    background: '#2d2d2d',\r\n    black: '#2d2d2d',\r\n    red: '#f2777a',\r\n    green: '#99cc99',\r\n    yellow: '#ffcc66',\r\n    blue: '#6699cc',\r\n    magenta: '#cc99cc',\r\n    cyan: '#66cccc',\r\n    white: '#d3d0c8',\r\n    brightBlack: '#747369'\r\n};\r\nvar Nanologger = /** @class */ (function () {\r\n    function Nanologger(name, opts) {\r\n        this.name = name;\r\n        this.opts = opts;\r\n        this._name = name || '';\r\n        this._colors = __assign({}, defaultColors, (opts.colors || {}));\r\n        try {\r\n            this.logLevel = window.localStorage.getItem('logLevel') || 'info';\r\n        }\r\n        catch (e) {\r\n            this.logLevel = 'info';\r\n        }\r\n        this._logLevel = levels[this.logLevel];\r\n    }\r\n    Nanologger.prototype.trace = function () {\r\n        var args = ['trace'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype.debug = function () {\r\n        var args = ['debug'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype.info = function () {\r\n        var args = ['info'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype.warn = function () {\r\n        var args = ['warn'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype.error = function () {\r\n        var args = ['error'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype.fatal = function () {\r\n        var args = ['fatal'];\r\n        for (var i = 0, len = arguments.length; i < len; i++)\r\n            args.push(arguments[i]);\r\n        this._print.apply(this, args);\r\n    };\r\n    Nanologger.prototype._print = function (level) {\r\n        if (levels[level] < this._logLevel)\r\n            return;\r\n        // var time = getTimeStamp()\r\n        var emoji = emojis[level];\r\n        var name = this._name || 'unknown';\r\n        var msgColor = (level === 'error' || level.fatal)\r\n            ? this._colors.red\r\n            : level === 'warn'\r\n                ? this._colors.yellow\r\n                : this._colors.green;\r\n        var objs = [];\r\n        var args = [null];\r\n        var msg = emoji + ' %c%s';\r\n        // args.push(color(this._colors.brightBlack), time)\r\n        args.push(color(this._colors.magenta), name);\r\n        for (var i = 1, len = arguments.length; i < len; i++) {\r\n            var arg = arguments[i];\r\n            if (typeof arg === 'string') {\r\n                if (i === 1) {\r\n                    // first string argument is in color\r\n                    msg += ' %c%s';\r\n                    args.push(color(msgColor));\r\n                    args.push(arg);\r\n                }\r\n                else if (/ms$/.test(arg)) {\r\n                    // arguments finishing with 'ms', grey out\r\n                    msg += ' %c%s';\r\n                    args.push(color(this._colors.brightBlack));\r\n                    args.push(arg);\r\n                }\r\n                else {\r\n                    // normal colors\r\n                    msg += ' %c%s';\r\n                    args.push(color(this._colors.white));\r\n                    args.push(arg);\r\n                }\r\n            }\r\n            else if (typeof arg === 'number') {\r\n                msg += ' %c%d';\r\n                args.push(color(this._colors.magenta));\r\n                args.push(arg);\r\n            }\r\n            else {\r\n                objs.push(arg);\r\n            }\r\n        }\r\n        args[0] = msg;\r\n        objs.forEach(function (obj) {\r\n            args.push(obj);\r\n        });\r\n        // In IE/Edge console functions don't inherit from Function.prototype\r\n        // so this is necessary to get all the args applied.\r\n        Function.prototype.apply.apply(console.log, [console, args]);\r\n    };\r\n    return Nanologger;\r\n}());\r\nexports.Nanologger = Nanologger;\r\nfunction color(color) {\r\n    return 'color: ' + color + ';';\r\n}\r\nfunction getTimeStamp() {\r\n    var date = new Date();\r\n    var hours = pad(date.getHours().toString());\r\n    var minutes = pad(date.getMinutes().toString());\r\n    var seconds = pad(date.getSeconds().toString());\r\n    return hours + ':' + minutes + ':' + seconds;\r\n}\r\nfunction pad(str) {\r\n    return str.length !== 2 ? 0 + str : str;\r\n}\r\n\n\n/***/ }),\n/* 136 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n/**\r\n *\r\n * With thanks to https://github.com/livereload/livereload-js\r\n * :) :) :)\r\n *\r\n */\r\nvar utils_1 = __webpack_require__(23);\r\nvar empty_1 = __webpack_require__(18);\r\nvar Observable_1 = __webpack_require__(1);\r\nvar merge_1 = __webpack_require__(36);\r\nvar timer_1 = __webpack_require__(48);\r\nvar from_1 = __webpack_require__(83);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nvar take_1 = __webpack_require__(146);\r\nvar tap_1 = __webpack_require__(6);\r\nvar mapTo_1 = __webpack_require__(85);\r\nvar prop_set_dom_effect_1 = __webpack_require__(72);\r\nvar style_set_dom_effect_1 = __webpack_require__(77);\r\nvar link_replace_dom_effect_1 = __webpack_require__(78);\r\nvar hiddenElem;\r\nvar IMAGE_STYLES = [\r\n    { selector: 'background', styleNames: ['backgroundImage'] },\r\n    { selector: 'border', styleNames: ['borderImage', 'webkitBorderImage', 'MozBorderImage'] }\r\n];\r\nvar attrs = {\r\n    link: \"href\",\r\n    img: \"src\",\r\n    script: \"src\"\r\n};\r\nfunction reload(document, navigator) {\r\n    return function (data, options) {\r\n        var path = data.path;\r\n        if (options.liveCSS) {\r\n            if (path.match(/\\.css$/i)) {\r\n                return reloadStylesheet(path, document, navigator);\r\n            }\r\n        }\r\n        if (options.liveImg) {\r\n            if (path.match(/\\.(jpe?g|png|gif)$/i)) {\r\n                return reloadImages(path, document);\r\n            }\r\n        }\r\n        /**\r\n         * LEGACY\r\n         */\r\n        var domData = getElems(data.ext, options, document);\r\n        var elems = getMatches(domData.elems, data.basename, domData.attr);\r\n        for (var i = 0, n = elems.length; i < n; i += 1) {\r\n            swapFile(elems[i], domData, options, document, navigator);\r\n        }\r\n        return empty_1.empty();\r\n    };\r\n    function getMatches(elems, url, attr) {\r\n        if (url[0] === \"*\") {\r\n            return elems;\r\n        }\r\n        var matches = [];\r\n        var urlMatcher = new RegExp(\"(^|/)\" + url);\r\n        for (var i = 0, len = elems.length; i < len; i += 1) {\r\n            if (urlMatcher.test(elems[i][attr])) {\r\n                matches.push(elems[i]);\r\n            }\r\n        }\r\n        return matches;\r\n    }\r\n    function getElems(fileExtension, options, document) {\r\n        var tagName = options.tagNames[fileExtension];\r\n        var attr = attrs[tagName];\r\n        return {\r\n            attr: attr,\r\n            tagName: tagName,\r\n            elems: document.getElementsByTagName(tagName)\r\n        };\r\n    }\r\n    function reloadImages(path, document) {\r\n        var expando = generateUniqueString(Date.now());\r\n        return merge_1.merge(from_1.from([].slice.call(document.images))\r\n            .pipe(filter_1.filter(function (img) { return utils_1.pathsMatch(path, utils_1.pathFromUrl(img.src)); }), map_1.map(function (img) {\r\n            var payload = {\r\n                target: img,\r\n                prop: 'src',\r\n                value: generateCacheBustUrl(img.src, expando),\r\n                pathname: utils_1.getLocation(img.src).pathname\r\n            };\r\n            return prop_set_dom_effect_1.propSet(payload);\r\n        })), from_1.from(IMAGE_STYLES)\r\n            .pipe(mergeMap_1.mergeMap(function (_a) {\r\n            var selector = _a.selector, styleNames = _a.styleNames;\r\n            return from_1.from(document.querySelectorAll(\"[style*=\" + selector + \"]\")).pipe(mergeMap_1.mergeMap(function (img) {\r\n                return reloadStyleImages(img.style, styleNames, path, expando);\r\n            }));\r\n        })));\r\n        // if (document.styleSheets) {\r\n        //     return [].slice.call(document.styleSheets)\r\n        //         .map((styleSheet) => {\r\n        //             return reloadStylesheetImages(styleSheet, path, expando);\r\n        //         });\r\n        // }\r\n    }\r\n    function reloadStylesheetImages(styleSheet, path, expando) {\r\n        var rules;\r\n        try {\r\n            rules = styleSheet != null ? styleSheet.cssRules : undefined;\r\n        }\r\n        catch (e) { }\r\n        //\r\n        if (!rules) {\r\n            return;\r\n        }\r\n        [].slice.call(rules).forEach(function (rule) {\r\n            switch (rule.type) {\r\n                case CSSRule.IMPORT_RULE:\r\n                    reloadStylesheetImages(rule.styleSheet, path, expando);\r\n                    break;\r\n                case CSSRule.STYLE_RULE:\r\n                    [].slice.call(IMAGE_STYLES).forEach(function (_a) {\r\n                        var styleNames = _a.styleNames;\r\n                        reloadStyleImages(rule.style, styleNames, path, expando);\r\n                    });\r\n                    break;\r\n                case CSSRule.MEDIA_RULE:\r\n                    reloadStylesheetImages(rule, path, expando);\r\n                    break;\r\n            }\r\n        });\r\n    }\r\n    function reloadStyleImages(style, styleNames, path, expando) {\r\n        return from_1.from(styleNames).pipe(filter_1.filter(function (styleName) { return typeof style[styleName] === 'string'; }), map_1.map(function (styleName) {\r\n            var pathName;\r\n            var value = style[styleName];\r\n            var newValue = value.replace(new RegExp(\"\\\\burl\\\\s*\\\\(([^)]*)\\\\)\"), function (match, src) {\r\n                var _src = src;\r\n                if (src[0] === '\"' && src[src.length - 1] === '\"') {\r\n                    _src = src.slice(1, -1);\r\n                }\r\n                pathName = utils_1.getLocation(_src).pathname;\r\n                if (utils_1.pathsMatch(path, utils_1.pathFromUrl(_src))) {\r\n                    return \"url(\" + generateCacheBustUrl(_src, expando) + \")\";\r\n                }\r\n                else {\r\n                    return match;\r\n                }\r\n            });\r\n            return [\r\n                style,\r\n                styleName,\r\n                value,\r\n                newValue,\r\n                pathName\r\n            ];\r\n        }), filter_1.filter(function (_a) {\r\n            var style = _a[0], styleName = _a[1], value = _a[2], newValue = _a[3];\r\n            return newValue !== value;\r\n        }), map_1.map(function (_a) {\r\n            var style = _a[0], styleName = _a[1], value = _a[2], newValue = _a[3], pathName = _a[4];\r\n            return style_set_dom_effect_1.styleSet({ style: style, styleName: styleName, value: value, newValue: newValue, pathName: pathName });\r\n        }));\r\n    }\r\n    function swapFile(elem, domData, options, document, navigator) {\r\n        var attr = domData.attr;\r\n        var currentValue = elem[attr];\r\n        var timeStamp = new Date().getTime();\r\n        var key = \"browsersync-legacy\";\r\n        var suffix = key + \"=\" + timeStamp;\r\n        var anchor = utils_1.getLocation(currentValue);\r\n        var search = utils_1.updateSearch(anchor.search, key, suffix);\r\n        switch (domData.tagName) {\r\n            case 'link': {\r\n                // this.logger.trace(`replacing LINK ${attr}`);\r\n                reloadStylesheet(currentValue, document, navigator);\r\n                break;\r\n            }\r\n            case 'img': {\r\n                reloadImages(currentValue, document);\r\n                break;\r\n            }\r\n            default: {\r\n                if (options.timestamps === false) {\r\n                    elem[attr] = anchor.href;\r\n                }\r\n                else {\r\n                    elem[attr] = anchor.href.split(\"?\")[0] + search;\r\n                }\r\n                // this.logger.info(`reloading ${elem[attr]}`);\r\n                setTimeout(function () {\r\n                    if (!hiddenElem) {\r\n                        hiddenElem = document.createElement(\"DIV\");\r\n                        document.body.appendChild(hiddenElem);\r\n                    }\r\n                    else {\r\n                        hiddenElem.style.display = \"none\";\r\n                        hiddenElem.style.display = \"block\";\r\n                    }\r\n                }, 200);\r\n            }\r\n        }\r\n        return {\r\n            elem: elem,\r\n            timeStamp: timeStamp\r\n        };\r\n    }\r\n    function reattachStylesheetLink(link, document, navigator) {\r\n        // ignore LINKs that will be removed by LR soon\r\n        var clone;\r\n        if (link.__LiveReload_pendingRemoval) {\r\n            return empty_1.empty();\r\n        }\r\n        link.__LiveReload_pendingRemoval = true;\r\n        if (link.tagName === 'STYLE') {\r\n            // prefixfree\r\n            clone = document.createElement('link');\r\n            clone.rel = 'stylesheet';\r\n            clone.media = link.media;\r\n            clone.disabled = link.disabled;\r\n        }\r\n        else {\r\n            clone = link.cloneNode(false);\r\n        }\r\n        var prevHref = link.href;\r\n        var nextHref = generateCacheBustUrl(linkHref(link));\r\n        clone.href = nextHref;\r\n        var pathname = utils_1.getLocation(nextHref).pathname;\r\n        var basename = pathname.split('/').slice(-1)[0];\r\n        // insert the new LINK before the old one\r\n        var parent = link.parentNode;\r\n        if (parent.lastChild === link) {\r\n            parent.appendChild(clone);\r\n        }\r\n        else {\r\n            parent.insertBefore(clone, link.nextSibling);\r\n        }\r\n        var additionalWaitingTime;\r\n        if (/AppleWebKit/.test(navigator.userAgent)) {\r\n            additionalWaitingTime = 5;\r\n        }\r\n        else {\r\n            additionalWaitingTime = 200;\r\n        }\r\n        return Observable_1.Observable.create(function (obs) { return clone.onload = function () { return obs.next(true); }; })\r\n            .pipe(take_1.take(1), mergeMap_1.mergeMap(function () {\r\n            return timer_1.timer(additionalWaitingTime)\r\n                .pipe(tap_1.tap(function () {\r\n                if (link && !link.parentNode) {\r\n                    return;\r\n                }\r\n                link.parentNode.removeChild(link);\r\n                clone.onreadystatechange = null;\r\n            }), mapTo_1.mapTo(link_replace_dom_effect_1.linkReplace({ target: clone, nextHref: nextHref, prevHref: prevHref, pathname: pathname, basename: basename })));\r\n        }));\r\n    }\r\n    function reattachImportedRule(_a, document) {\r\n        var rule = _a.rule, index = _a.index, link = _a.link;\r\n        var parent = rule.parentStyleSheet;\r\n        var href = generateCacheBustUrl(rule.href);\r\n        var media = rule.media.length ? [].join.call(rule.media, ', ') : '';\r\n        var newRule = \"@import url(\\\"\" + href + \"\\\") \" + media + \";\";\r\n        // used to detect if reattachImportedRule has been called again on the same rule\r\n        rule.__LiveReload_newHref = href;\r\n        // WORKAROUND FOR WEBKIT BUG: WebKit resets all styles if we add @import'ed\r\n        // stylesheet that hasn't been cached yet. Workaround is to pre-cache the\r\n        // stylesheet by temporarily adding it as a LINK tag.\r\n        var tempLink = document.createElement(\"link\");\r\n        tempLink.rel = 'stylesheet';\r\n        tempLink.href = href;\r\n        tempLink.__LiveReload_pendingRemoval = true; // exclude from path matching\r\n        if (link.parentNode) {\r\n            link.parentNode.insertBefore(tempLink, link);\r\n        }\r\n        return timer_1.timer(200)\r\n            .pipe(tap_1.tap(function () {\r\n            if (tempLink.parentNode) {\r\n                tempLink.parentNode.removeChild(tempLink);\r\n            }\r\n            // if another reattachImportedRule call is in progress, abandon this one\r\n            if (rule.__LiveReload_newHref !== href) {\r\n                return;\r\n            }\r\n            parent.insertRule(newRule, index);\r\n            parent.deleteRule(index + 1);\r\n            // save the new rule, so that we can detect another reattachImportedRule call\r\n            rule = parent.cssRules[index];\r\n            rule.__LiveReload_newHref = href;\r\n        }), mergeMap_1.mergeMap(function () {\r\n            return timer_1.timer(200).pipe(tap_1.tap(function () {\r\n                // if another reattachImportedRule call is in progress, abandon this one\r\n                if (rule.__LiveReload_newHref !== href) {\r\n                    return;\r\n                }\r\n                parent.insertRule(newRule, index);\r\n                return parent.deleteRule(index + 1);\r\n            }));\r\n        }));\r\n    }\r\n    function generateCacheBustUrl(url, expando) {\r\n        if (expando === void 0) { expando = generateUniqueString(Date.now()); }\r\n        var hash, oldParams;\r\n        (_a = utils_1.splitUrl(url), url = _a.url, hash = _a.hash, oldParams = _a.params);\r\n        // if (this.options.overrideURL) {\r\n        //     if (url.indexOf(this.options.serverURL) < 0) {\r\n        //         const originalUrl = url;\r\n        //         url = this.options.serverURL + this.options.overrideURL + \"?url=\" + encodeURIComponent(url);\r\n        //         this.logger.debug(`overriding source URL ${originalUrl} with ${url}`);\r\n        //     }\r\n        // }\r\n        var params = oldParams.replace(/(\\?|&)browsersync=(\\d+)/, function (match, sep) { return \"\" + sep + expando; });\r\n        if (params === oldParams) {\r\n            if (oldParams.length === 0) {\r\n                params = \"?\" + expando;\r\n            }\r\n            else {\r\n                params = oldParams + \"&\" + expando;\r\n            }\r\n        }\r\n        return url + params + hash;\r\n        var _a;\r\n    }\r\n    function reloadStylesheet(path, document, navigator) {\r\n        // has to be a real array, because DOMNodeList will be modified\r\n        var links = utils_1.array(document.getElementsByTagName('link'))\r\n            .filter(function (link) {\r\n            return link.rel.match(/^stylesheet$/i)\r\n                && !link.__LiveReload_pendingRemoval;\r\n        });\r\n        /**\r\n         * Find imported style sheets in <style> tags\r\n         * @type {any[]}\r\n         */\r\n        var styleImported = utils_1.array(document.getElementsByTagName('style'))\r\n            .filter(function (style) { return Boolean(style.sheet); })\r\n            .reduce(function (acc, style) {\r\n            return acc.concat(collectImportedStylesheets(style, style.sheet));\r\n        }, []);\r\n        /**\r\n         * Find imported style sheets in <link> tags\r\n         * @type {any[]}\r\n         */\r\n        var linksImported = links\r\n            .reduce(function (acc, link) {\r\n            return acc.concat(collectImportedStylesheets(link, link.sheet));\r\n        }, []);\r\n        /**\r\n         * Combine all links + sheets\r\n         */\r\n        var allRules = links.concat(styleImported, linksImported);\r\n        /**\r\n         * Which href best matches the incoming href?\r\n         */\r\n        var match = utils_1.pickBestMatch(path, allRules, function (l) { return utils_1.pathFromUrl(linkHref(l)); });\r\n        if (match) {\r\n            if (match.object && match.object.rule) {\r\n                return reattachImportedRule(match.object, document);\r\n            }\r\n            return reattachStylesheetLink(match.object, document, navigator);\r\n        }\r\n        return empty_1.empty();\r\n    }\r\n    function collectImportedStylesheets(link, styleSheet) {\r\n        // in WebKit, styleSheet.cssRules is null for inaccessible stylesheets;\r\n        // Firefox/Opera may throw exceptions\r\n        var output = [];\r\n        collect(link, makeRules(styleSheet));\r\n        return output;\r\n        function makeRules(styleSheet) {\r\n            var rules;\r\n            try {\r\n                rules = styleSheet != null ? styleSheet.cssRules : undefined;\r\n            }\r\n            catch (e) { }\r\n            return rules;\r\n        }\r\n        function collect(link, rules) {\r\n            if (rules && rules.length) {\r\n                for (var index = 0; index < rules.length; index++) {\r\n                    var rule = rules[index];\r\n                    switch (rule.type) {\r\n                        case CSSRule.CHARSET_RULE:\r\n                            break;\r\n                        case CSSRule.IMPORT_RULE:\r\n                            output.push({ link: link, rule: rule, index: index, href: rule.href });\r\n                            collect(link, makeRules(rule.styleSheet));\r\n                            break;\r\n                        default:\r\n                            break; // import rules can only be preceded by charset rules\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    function linkHref(link) {\r\n        // prefixfree uses data-href when it turns LINK into STYLE\r\n        return link.href || link.getAttribute('data-href');\r\n    }\r\n    function generateUniqueString(value) {\r\n        return \"browsersync=\" + value;\r\n    }\r\n}\r\nexports.reload = reload;\r\n\n\n/***/ }),\n/* 137 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isArray_1 = __webpack_require__(28);\nvar isArrayLike_1 = __webpack_require__(55);\nvar isPromise_1 = __webpack_require__(56);\nvar PromiseObservable_1 = __webpack_require__(138);\nvar IteratorObservable_1 = __webpack_require__(139);\nvar ArrayObservable_1 = __webpack_require__(25);\nvar ArrayLikeObservable_1 = __webpack_require__(140);\nvar iterator_1 = __webpack_require__(32);\nvar Observable_1 = __webpack_require__(1);\nvar observeOn_1 = __webpack_require__(141);\nvar observable_1 = __webpack_require__(43);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromObservable = (function (_super) {\n    __extends(FromObservable, _super);\n    function FromObservable(ish, scheduler) {\n        _super.call(this, null);\n        this.ish = ish;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable from an Array, an array-like object, a Promise, an\n     * iterable object, or an Observable-like object.\n     *\n     * <span class=\"informal\">Converts almost anything to an Observable.</span>\n     *\n     * <img src=\"./img/from.png\" width=\"100%\">\n     *\n     * Convert various other objects and data types into Observables. `from`\n     * converts a Promise or an array-like or an\n     * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)\n     * object into an Observable that emits the items in that promise or array or\n     * iterable. A String, in this context, is treated as an array of characters.\n     * Observable-like objects (contains a function named with the ES2015 Symbol\n     * for Observable) can also be converted through this operator.\n     *\n     * @example <caption>Converts an array to an Observable</caption>\n     * var array = [10, 20, 30];\n     * var result = Rx.Observable.from(array);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 10 20 30\n     *\n     * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>\n     * function* generateDoubles(seed) {\n     *   var i = seed;\n     *   while (true) {\n     *     yield i;\n     *     i = 2 * i; // double it\n     *   }\n     * }\n     *\n     * var iterator = generateDoubles(3);\n     * var result = Rx.Observable.from(iterator).take(10);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 3 6 12 24 48 96 192 384 768 1536\n     *\n     * @see {@link create}\n     * @see {@link fromEvent}\n     * @see {@link fromEventPattern}\n     * @see {@link fromPromise}\n     *\n     * @param {ObservableInput<T>} ish A subscribable object, a Promise, an\n     * Observable-like, an Array, an iterable or an array-like object to be\n     * converted.\n     * @param {Scheduler} [scheduler] The scheduler on which to schedule the\n     * emissions of values.\n     * @return {Observable<T>} The Observable whose values are originally from the\n     * input object that was converted.\n     * @static true\n     * @name from\n     * @owner Observable\n     */\n    FromObservable.create = function (ish, scheduler) {\n        if (ish != null) {\n            if (typeof ish[observable_1.observable] === 'function') {\n                if (ish instanceof Observable_1.Observable && !scheduler) {\n                    return ish;\n                }\n                return new FromObservable(ish, scheduler);\n            }\n            else if (isArray_1.isArray(ish)) {\n                return new ArrayObservable_1.ArrayObservable(ish, scheduler);\n            }\n            else if (isPromise_1.isPromise(ish)) {\n                return new PromiseObservable_1.PromiseObservable(ish, scheduler);\n            }\n            else if (typeof ish[iterator_1.iterator] === 'function' || typeof ish === 'string') {\n                return new IteratorObservable_1.IteratorObservable(ish, scheduler);\n            }\n            else if (isArrayLike_1.isArrayLike(ish)) {\n                return new ArrayLikeObservable_1.ArrayLikeObservable(ish, scheduler);\n            }\n        }\n        throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable');\n    };\n    FromObservable.prototype._subscribe = function (subscriber) {\n        var ish = this.ish;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            return ish[observable_1.observable]().subscribe(subscriber);\n        }\n        else {\n            return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0));\n        }\n    };\n    return FromObservable;\n}(Observable_1.Observable));\nexports.FromObservable = FromObservable;\n//# sourceMappingURL=FromObservable.js.map\n\n/***/ }),\n/* 138 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = __webpack_require__(8);\nvar Observable_1 = __webpack_require__(1);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar PromiseObservable = (function (_super) {\n    __extends(PromiseObservable, _super);\n    function PromiseObservable(promise, scheduler) {\n        _super.call(this);\n        this.promise = promise;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Converts a Promise to an Observable.\n     *\n     * <span class=\"informal\">Returns an Observable that just emits the Promise's\n     * resolved value, then completes.</span>\n     *\n     * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an\n     * Observable. If the Promise resolves with a value, the output Observable\n     * emits that resolved value as a `next`, and then completes. If the Promise\n     * is rejected, then the output Observable emits the corresponding Error.\n     *\n     * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>\n     * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link bindCallback}\n     * @see {@link from}\n     *\n     * @param {PromiseLike<T>} promise The promise to be converted.\n     * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling\n     * the delivery of the resolved value (or the rejection).\n     * @return {Observable<T>} An Observable which wraps the Promise.\n     * @static true\n     * @name fromPromise\n     * @owner Observable\n     */\n    PromiseObservable.create = function (promise, scheduler) {\n        return new PromiseObservable(promise, scheduler);\n    };\n    PromiseObservable.prototype._subscribe = function (subscriber) {\n        var _this = this;\n        var promise = this.promise;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    subscriber.next(this.value);\n                    subscriber.complete();\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.next(value);\n                        subscriber.complete();\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.error(err);\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n        else {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n    };\n    return PromiseObservable;\n}(Observable_1.Observable));\nexports.PromiseObservable = PromiseObservable;\nfunction dispatchNext(arg) {\n    var value = arg.value, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.next(value);\n        subscriber.complete();\n    }\n}\nfunction dispatchError(arg) {\n    var err = arg.err, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.error(err);\n    }\n}\n//# sourceMappingURL=PromiseObservable.js.map\n\n/***/ }),\n/* 139 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = __webpack_require__(8);\nvar Observable_1 = __webpack_require__(1);\nvar iterator_1 = __webpack_require__(32);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IteratorObservable = (function (_super) {\n    __extends(IteratorObservable, _super);\n    function IteratorObservable(iterator, scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n        if (iterator == null) {\n            throw new Error('iterator cannot be null.');\n        }\n        this.iterator = getIterator(iterator);\n    }\n    IteratorObservable.create = function (iterator, scheduler) {\n        return new IteratorObservable(iterator, scheduler);\n    };\n    IteratorObservable.dispatch = function (state) {\n        var index = state.index, hasError = state.hasError, iterator = state.iterator, subscriber = state.subscriber;\n        if (hasError) {\n            subscriber.error(state.error);\n            return;\n        }\n        var result = iterator.next();\n        if (result.done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(result.value);\n        state.index = index + 1;\n        if (subscriber.closed) {\n            if (typeof iterator.return === 'function') {\n                iterator.return();\n            }\n            return;\n        }\n        this.schedule(state);\n    };\n    IteratorObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, iterator = _a.iterator, scheduler = _a.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(IteratorObservable.dispatch, 0, {\n                index: index, iterator: iterator, subscriber: subscriber\n            });\n        }\n        else {\n            do {\n                var result = iterator.next();\n                if (result.done) {\n                    subscriber.complete();\n                    break;\n                }\n                else {\n                    subscriber.next(result.value);\n                }\n                if (subscriber.closed) {\n                    if (typeof iterator.return === 'function') {\n                        iterator.return();\n                    }\n                    break;\n                }\n            } while (true);\n        }\n    };\n    return IteratorObservable;\n}(Observable_1.Observable));\nexports.IteratorObservable = IteratorObservable;\nvar StringIterator = (function () {\n    function StringIterator(str, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = str.length; }\n        this.str = str;\n        this.idx = idx;\n        this.len = len;\n    }\n    StringIterator.prototype[iterator_1.iterator] = function () { return (this); };\n    StringIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.str.charAt(this.idx++)\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return StringIterator;\n}());\nvar ArrayIterator = (function () {\n    function ArrayIterator(arr, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = toLength(arr); }\n        this.arr = arr;\n        this.idx = idx;\n        this.len = len;\n    }\n    ArrayIterator.prototype[iterator_1.iterator] = function () { return this; };\n    ArrayIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.arr[this.idx++]\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return ArrayIterator;\n}());\nfunction getIterator(obj) {\n    var i = obj[iterator_1.iterator];\n    if (!i && typeof obj === 'string') {\n        return new StringIterator(obj);\n    }\n    if (!i && obj.length !== undefined) {\n        return new ArrayIterator(obj);\n    }\n    if (!i) {\n        throw new TypeError('object is not iterable');\n    }\n    return obj[iterator_1.iterator]();\n}\nvar maxSafeInteger = Math.pow(2, 53) - 1;\nfunction toLength(o) {\n    var len = +o.length;\n    if (isNaN(len)) {\n        return 0;\n    }\n    if (len === 0 || !numberIsFinite(len)) {\n        return len;\n    }\n    len = sign(len) * Math.floor(Math.abs(len));\n    if (len <= 0) {\n        return 0;\n    }\n    if (len > maxSafeInteger) {\n        return maxSafeInteger;\n    }\n    return len;\n}\nfunction numberIsFinite(value) {\n    return typeof value === 'number' && root_1.root.isFinite(value);\n}\nfunction sign(value) {\n    var valueAsNumber = +value;\n    if (valueAsNumber === 0) {\n        return valueAsNumber;\n    }\n    if (isNaN(valueAsNumber)) {\n        return valueAsNumber;\n    }\n    return valueAsNumber < 0 ? -1 : 1;\n}\n//# sourceMappingURL=IteratorObservable.js.map\n\n/***/ }),\n/* 140 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\nvar ScalarObservable_1 = __webpack_require__(44);\nvar EmptyObservable_1 = __webpack_require__(26);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayLikeObservable = (function (_super) {\n    __extends(ArrayLikeObservable, _super);\n    function ArrayLikeObservable(arrayLike, scheduler) {\n        _super.call(this);\n        this.arrayLike = arrayLike;\n        this.scheduler = scheduler;\n        if (!scheduler && arrayLike.length === 1) {\n            this._isScalar = true;\n            this.value = arrayLike[0];\n        }\n    }\n    ArrayLikeObservable.create = function (arrayLike, scheduler) {\n        var length = arrayLike.length;\n        if (length === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else if (length === 1) {\n            return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler);\n        }\n        else {\n            return new ArrayLikeObservable(arrayLike, scheduler);\n        }\n    };\n    ArrayLikeObservable.dispatch = function (state) {\n        var arrayLike = state.arrayLike, index = state.index, length = state.length, subscriber = state.subscriber;\n        if (subscriber.closed) {\n            return;\n        }\n        if (index >= length) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(arrayLike[index]);\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    ArrayLikeObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, arrayLike = _a.arrayLike, scheduler = _a.scheduler;\n        var length = arrayLike.length;\n        if (scheduler) {\n            return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {\n                arrayLike: arrayLike, index: index, length: length, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < length && !subscriber.closed; i++) {\n                subscriber.next(arrayLike[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayLikeObservable;\n}(Observable_1.Observable));\nexports.ArrayLikeObservable = ArrayLikeObservable;\n//# sourceMappingURL=ArrayLikeObservable.js.map\n\n/***/ }),\n/* 141 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nvar Notification_1 = __webpack_require__(142);\n/**\n *\n * Re-emits all notifications from source Observable with specified scheduler.\n *\n * <span class=\"informal\">Ensure a specific scheduler is used, from outside of an Observable.</span>\n *\n * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule\n * notifications emitted by the source Observable. It might be useful, if you do not have control over\n * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.\n *\n * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,\n * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal\n * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits\n * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.\n * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split\n * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source\n * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a\n * little bit more, to ensure that they are emitted at expected moments.\n *\n * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications\n * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`\n * will delay all notifications - including error notifications - while `delay` will pass through error\n * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator\n * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used\n * for notification emissions in general.\n *\n * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>\n * const intervals = Rx.Observable.interval(10); // Intervals are scheduled\n *                                               // with async scheduler by default...\n *\n * intervals\n * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame\n * .subscribe(val => {                           // scheduler to ensure smooth animation.\n *   someDiv.style.height = val + 'px';\n * });\n *\n * @see {@link delay}\n *\n * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.\n * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.\n * @return {Observable<T>} Observable that emits the same notifications as the source Observable,\n * but with provided scheduler.\n *\n * @method observeOn\n * @owner Observable\n */\nfunction observeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function observeOnOperatorFunction(source) {\n        return source.lift(new ObserveOnOperator(scheduler, delay));\n    };\n}\nexports.observeOn = observeOn;\nvar ObserveOnOperator = (function () {\n    function ObserveOnOperator(scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));\n    };\n    return ObserveOnOperator;\n}());\nexports.ObserveOnOperator = ObserveOnOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ObserveOnSubscriber = (function (_super) {\n    __extends(ObserveOnSubscriber, _super);\n    function ObserveOnSubscriber(destination, scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        _super.call(this, destination);\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnSubscriber.dispatch = function (arg) {\n        var notification = arg.notification, destination = arg.destination;\n        notification.observe(destination);\n        this.unsubscribe();\n    };\n    ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {\n        this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));\n    };\n    ObserveOnSubscriber.prototype._next = function (value) {\n        this.scheduleMessage(Notification_1.Notification.createNext(value));\n    };\n    ObserveOnSubscriber.prototype._error = function (err) {\n        this.scheduleMessage(Notification_1.Notification.createError(err));\n    };\n    ObserveOnSubscriber.prototype._complete = function () {\n        this.scheduleMessage(Notification_1.Notification.createComplete());\n    };\n    return ObserveOnSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ObserveOnSubscriber = ObserveOnSubscriber;\nvar ObserveOnMessage = (function () {\n    function ObserveOnMessage(notification, destination) {\n        this.notification = notification;\n        this.destination = destination;\n    }\n    return ObserveOnMessage;\n}());\nexports.ObserveOnMessage = ObserveOnMessage;\n//# sourceMappingURL=observeOn.js.map\n\n/***/ }),\n/* 142 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(1);\n/**\n * Represents a push-based event or value that an {@link Observable} can emit.\n * This class is particularly useful for operators that manage notifications,\n * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and\n * others. Besides wrapping the actual delivered value, it also annotates it\n * with metadata of, for instance, what type of push message it is (`next`,\n * `error`, or `complete`).\n *\n * @see {@link materialize}\n * @see {@link dematerialize}\n * @see {@link observeOn}\n *\n * @class Notification<T>\n */\nvar Notification = (function () {\n    function Notification(kind, value, error) {\n        this.kind = kind;\n        this.value = value;\n        this.error = error;\n        this.hasValue = kind === 'N';\n    }\n    /**\n     * Delivers to the given `observer` the value wrapped by this Notification.\n     * @param {Observer} observer\n     * @return\n     */\n    Notification.prototype.observe = function (observer) {\n        switch (this.kind) {\n            case 'N':\n                return observer.next && observer.next(this.value);\n            case 'E':\n                return observer.error && observer.error(this.error);\n            case 'C':\n                return observer.complete && observer.complete();\n        }\n    };\n    /**\n     * Given some {@link Observer} callbacks, deliver the value represented by the\n     * current Notification to the correctly corresponding callback.\n     * @param {function(value: T): void} next An Observer `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.do = function (next, error, complete) {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return next && next(this.value);\n            case 'E':\n                return error && error(this.error);\n            case 'C':\n                return complete && complete();\n        }\n    };\n    /**\n     * Takes an Observer or its individual callback functions, and calls `observe`\n     * or `do` methods accordingly.\n     * @param {Observer|function(value: T): void} nextOrObserver An Observer or\n     * the `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.accept = function (nextOrObserver, error, complete) {\n        if (nextOrObserver && typeof nextOrObserver.next === 'function') {\n            return this.observe(nextOrObserver);\n        }\n        else {\n            return this.do(nextOrObserver, error, complete);\n        }\n    };\n    /**\n     * Returns a simple Observable that just delivers the notification represented\n     * by this Notification instance.\n     * @return {any}\n     */\n    Notification.prototype.toObservable = function () {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return Observable_1.Observable.of(this.value);\n            case 'E':\n                return Observable_1.Observable.throw(this.error);\n            case 'C':\n                return Observable_1.Observable.empty();\n        }\n        throw new Error('unexpected notification kind value');\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `next` from a\n     * given value.\n     * @param {T} value The `next` value.\n     * @return {Notification<T>} The \"next\" Notification representing the\n     * argument.\n     */\n    Notification.createNext = function (value) {\n        if (typeof value !== 'undefined') {\n            return new Notification('N', value);\n        }\n        return Notification.undefinedValueNotification;\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `error` from a\n     * given error.\n     * @param {any} [err] The `error` error.\n     * @return {Notification<T>} The \"error\" Notification representing the\n     * argument.\n     */\n    Notification.createError = function (err) {\n        return new Notification('E', undefined, err);\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `complete`.\n     * @return {Notification<any>} The valueless \"complete\" Notification.\n     */\n    Notification.createComplete = function () {\n        return Notification.completeNotification;\n    };\n    Notification.completeNotification = new Notification('C');\n    Notification.undefinedValueNotification = new Notification('N', undefined);\n    return Notification;\n}());\nexports.Notification = Notification;\n//# sourceMappingURL=Notification.js.map\n\n/***/ }),\n/* 143 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar mergeAll_1 = __webpack_require__(84);\n/**\n * Converts a higher-order Observable into a first-order Observable by\n * concatenating the inner Observables in order.\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables by putting one\n * inner Observable after the other.</span>\n *\n * <img src=\"./img/concatAll.png\" width=\"100%\">\n *\n * Joins every Observable emitted by the source (a higher-order Observable), in\n * a serial fashion. It subscribes to each inner Observable only after the\n * previous inner Observable has completed, and merges all of their values into\n * the returned observable.\n *\n * __Warning:__ If the source Observable emits Observables quickly and\n * endlessly, and the inner Observables it emits generally complete slower than\n * the source emits, you can run into memory issues as the incoming Observables\n * collect in an unbounded buffer.\n *\n * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));\n * var firstOrder = higherOrder.concatAll();\n * firstOrder.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link combineAll}\n * @see {@link concat}\n * @see {@link concatMap}\n * @see {@link concatMapTo}\n * @see {@link exhaust}\n * @see {@link mergeAll}\n * @see {@link switch}\n * @see {@link zipAll}\n *\n * @return {Observable} An Observable emitting values from all the inner\n * Observables concatenated.\n * @method concatAll\n * @owner Observable\n */\nfunction concatAll() {\n    return mergeAll_1.mergeAll(1);\n}\nexports.concatAll = concatAll;\n//# sourceMappingURL=concatAll.js.map\n\n/***/ }),\n/* 144 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction identity(x) {\n    return x;\n}\nexports.identity = identity;\n//# sourceMappingURL=identity.js.map\n\n/***/ }),\n/* 145 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ArrayObservable_1 = __webpack_require__(25);\nvar ScalarObservable_1 = __webpack_require__(44);\nvar EmptyObservable_1 = __webpack_require__(26);\nvar concat_1 = __webpack_require__(50);\nvar isScheduler_1 = __webpack_require__(27);\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the items you specify as arguments before it begins to emit\n * items emitted by the source Observable.\n *\n * <img src=\"./img/startWith.png\" width=\"100%\">\n *\n * @param {...T} values - Items you want the modified Observable to emit first.\n * @param {Scheduler} [scheduler] - A {@link IScheduler} to use for scheduling\n * the emissions of the `next` notifications.\n * @return {Observable} An Observable that emits the items in the specified Iterable and then emits the items\n * emitted by the source Observable.\n * @method startWith\n * @owner Observable\n */\nfunction startWith() {\n    var array = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        array[_i - 0] = arguments[_i];\n    }\n    return function (source) {\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len === 1) {\n            return concat_1.concat(new ScalarObservable_1.ScalarObservable(array[0], scheduler), source);\n        }\n        else if (len > 1) {\n            return concat_1.concat(new ArrayObservable_1.ArrayObservable(array, scheduler), source);\n        }\n        else {\n            return concat_1.concat(new EmptyObservable_1.EmptyObservable(scheduler), source);\n        }\n    };\n}\nexports.startWith = startWith;\n//# sourceMappingURL=startWith.js.map\n\n/***/ }),\n/* 146 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nvar ArgumentOutOfRangeError_1 = __webpack_require__(147);\nvar EmptyObservable_1 = __webpack_require__(26);\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return function (source) {\n        if (count === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else {\n            return source.lift(new TakeOperator(count));\n        }\n    };\n}\nexports.take = take;\nvar TakeOperator = (function () {\n    function TakeOperator(total) {\n        this.total = total;\n        if (this.total < 0) {\n            throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;\n        }\n    }\n    TakeOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new TakeSubscriber(subscriber, this.total));\n    };\n    return TakeOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar TakeSubscriber = (function (_super) {\n    __extends(TakeSubscriber, _super);\n    function TakeSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    TakeSubscriber.prototype._next = function (value) {\n        var total = this.total;\n        var count = ++this.count;\n        if (count <= total) {\n            this.destination.next(value);\n            if (count === total) {\n                this.destination.complete();\n                this.unsubscribe();\n            }\n        }\n    };\n    return TakeSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=take.js.map\n\n/***/ }),\n/* 147 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an element was queried at a certain index of an\n * Observable, but no such index or position exists in that sequence.\n *\n * @see {@link elementAt}\n * @see {@link take}\n * @see {@link takeLast}\n *\n * @class ArgumentOutOfRangeError\n */\nvar ArgumentOutOfRangeError = (function (_super) {\n    __extends(ArgumentOutOfRangeError, _super);\n    function ArgumentOutOfRangeError() {\n        var err = _super.call(this, 'argument out of range');\n        this.name = err.name = 'ArgumentOutOfRangeError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ArgumentOutOfRangeError;\n}(Error));\nexports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;\n//# sourceMappingURL=ArgumentOutOfRangeError.js.map\n\n/***/ }),\n/* 148 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar pluck_1 = __webpack_require__(7);\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar partition_1 = __webpack_require__(149);\r\nvar merge_1 = __webpack_require__(36);\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar tap_1 = __webpack_require__(6);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar map_1 = __webpack_require__(2);\r\nfunction setScrollEffect(xs, inputs) {\r\n    {\r\n        /**\r\n         * Group the incoming event with window, document & scrollProportionally argument\r\n         */\r\n        var tupleStream$ = xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$, inputs.document$, inputs.option$.pipe(pluck_1.pluck(\"scrollProportionally\"))));\r\n        /**\r\n         * Split the stream between document scrolls and element scrolls\r\n         */\r\n        var _a = partition_1.partition(function (_a) {\r\n            var event = _a[0];\r\n            return event.tagName === \"document\";\r\n        })(tupleStream$), document$ = _a[0], element$ = _a[1];\r\n        /**\r\n         * Further split the element scroll between those matching in `scrollElementMapping`\r\n         * and regular element scrolls\r\n         */\r\n        var _b = partition_1.partition(function (_a) {\r\n            var event = _a[0];\r\n            return event.mappingIndex > -1;\r\n        })(element$), mapped$ = _b[0], nonMapped$ = _b[1];\r\n        return merge_1.merge(\r\n        /**\r\n         * Main window scroll\r\n         */\r\n        document$.pipe(tap_1.tap(function (incoming) {\r\n            var event = incoming[0], window = incoming[1], document = incoming[2], scrollProportionally = incoming[3];\r\n            var scrollSpace = browser_utils_1.getDocumentScrollSpace(document);\r\n            if (scrollProportionally) {\r\n                return window.scrollTo(0, scrollSpace.y * event.position.proportional); // % of y axis of scroll to px\r\n            }\r\n            return window.scrollTo(0, event.position.raw.y);\r\n        })), \r\n        /**\r\n         * Regular, non-mapped Element scrolls\r\n         */\r\n        nonMapped$.pipe(tap_1.tap(function (incoming) {\r\n            var event = incoming[0], window = incoming[1], document = incoming[2], scrollProportionally = incoming[3];\r\n            var matchingElements = document.getElementsByTagName(event.tagName);\r\n            if (matchingElements && matchingElements.length) {\r\n                var match = matchingElements[event.index];\r\n                if (match) {\r\n                    return scrollElement(match, scrollProportionally, event);\r\n                }\r\n            }\r\n        })), \r\n        /**\r\n         * Element scrolls given in 'scrollElementMapping'\r\n         */\r\n        mapped$.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"scrollElementMapping\"))), \r\n        /**\r\n         * Filter the elements in the option `scrollElementMapping` so\r\n         * that it does not contain the element that triggered the event\r\n         */\r\n        map_1.map(function (_a) {\r\n            var incoming = _a[0], scrollElementMapping = _a[1];\r\n            var event = incoming[0];\r\n            return [\r\n                incoming,\r\n                scrollElementMapping.filter(function (item, index) { return index !== event.mappingIndex; })\r\n            ];\r\n        }), \r\n        /**\r\n         * Now perform the scroll on all other matching elements\r\n         */\r\n        tap_1.tap(function (_a) {\r\n            var incoming = _a[0], scrollElementMapping = _a[1];\r\n            var event = incoming[0], window = incoming[1], document = incoming[2], scrollProportionally = incoming[3];\r\n            scrollElementMapping\r\n                .map(function (selector) { return document.querySelector(selector); })\r\n                .forEach(function (element) {\r\n                scrollElement(element, scrollProportionally, event);\r\n            });\r\n        }))).pipe(ignoreElements_1.ignoreElements());\r\n    }\r\n}\r\nexports.setScrollEffect = setScrollEffect;\r\nfunction scrollElement(element, scrollProportionally, event) {\r\n    if (scrollProportionally) {\r\n        return element.scrollTo(0, element.scrollHeight * event.position.proportional); // % of y axis of scroll to px\r\n    }\r\n    return element.scrollTo(0, event.position.raw.y);\r\n}\r\n\n\n/***/ }),\n/* 149 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar not_1 = __webpack_require__(150);\nvar filter_1 = __webpack_require__(4);\n/**\n * Splits the source Observable into two, one with values that satisfy a\n * predicate, and another with values that don't satisfy the predicate.\n *\n * <span class=\"informal\">It's like {@link filter}, but returns two Observables:\n * one like the output of {@link filter}, and the other with values that did not\n * pass the condition.</span>\n *\n * <img src=\"./img/partition.png\" width=\"100%\">\n *\n * `partition` outputs an array with two Observables that partition the values\n * from the source Observable through the given `predicate` function. The first\n * Observable in that array emits source values for which the predicate argument\n * returns true. The second Observable emits source values for which the\n * predicate returns false. The first behaves like {@link filter} and the second\n * behaves like {@link filter} with the predicate negated.\n *\n * @example <caption>Partition click events into those on DIV elements and those elsewhere</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var parts = clicks.partition(ev => ev.target.tagName === 'DIV');\n * var clicksOnDivs = parts[0];\n * var clicksElsewhere = parts[1];\n * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));\n * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));\n *\n * @see {@link filter}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted on the first Observable in the returned array, if\n * `false` the value is emitted on the second Observable in the array. The\n * `index` parameter is the number `i` for the i-th source emission that has\n * happened since the subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {[Observable<T>, Observable<T>]} An array with two Observables: one\n * with values that passed the predicate, and another with values that did not\n * pass the predicate.\n * @method partition\n * @owner Observable\n */\nfunction partition(predicate, thisArg) {\n    return function (source) { return [\n        filter_1.filter(predicate, thisArg)(source),\n        filter_1.filter(not_1.not(predicate, thisArg))(source)\n    ]; };\n}\nexports.partition = partition;\n//# sourceMappingURL=partition.js.map\n\n/***/ }),\n/* 150 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction not(pred, thisArg) {\n    function notPred() {\n        return !(notPred.pred.apply(notPred.thisArg, arguments));\n    }\n    notPred.pred = pred;\n    notPred.thisArg = thisArg;\n    return notPred;\n}\nexports.not = not;\n//# sourceMappingURL=not.js.map\n\n/***/ }),\n/* 151 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar map_1 = __webpack_require__(2);\r\nvar Log = __webpack_require__(16);\r\nfunction incomingBrowserNotify(xs) {\r\n    return xs.pipe(map_1.map(function (event) { return Log.overlayInfo(event.message, event.timeout); }));\r\n}\r\nexports.incomingBrowserNotify = incomingBrowserNotify;\r\n\n\n/***/ }),\n/* 152 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar pluck_1 = __webpack_require__(7);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar browser_set_location_effect_1 = __webpack_require__(86);\r\nfunction incomingBrowserLocation(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"ghostMode\", \"location\"))), filter_1.filter(function (_a) {\r\n        var canSyncLocation = _a[1];\r\n        return canSyncLocation === true;\r\n    }), map_1.map(function (_a) {\r\n        var event = _a[0];\r\n        return browser_set_location_effect_1.browserSetLocation(event);\r\n    }));\r\n}\r\nexports.incomingBrowserLocation = incomingBrowserLocation;\r\n\n\n/***/ }),\n/* 153 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar SubscribeOnObservable_1 = __webpack_require__(154);\n/**\n * Asynchronously subscribes Observers to this Observable on the specified IScheduler.\n *\n * <img src=\"./img/subscribeOn.png\" width=\"100%\">\n *\n * @param {Scheduler} scheduler - The IScheduler to perform subscription actions on.\n * @return {Observable<T>} The source Observable modified so that its subscriptions happen on the specified IScheduler.\n .\n * @method subscribeOn\n * @owner Observable\n */\nfunction subscribeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function subscribeOnOperatorFunction(source) {\n        return source.lift(new SubscribeOnOperator(scheduler, delay));\n    };\n}\nexports.subscribeOn = subscribeOn;\nvar SubscribeOnOperator = (function () {\n    function SubscribeOnOperator(scheduler, delay) {\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    SubscribeOnOperator.prototype.call = function (subscriber, source) {\n        return new SubscribeOnObservable_1.SubscribeOnObservable(source, this.delay, this.scheduler).subscribe(subscriber);\n    };\n    return SubscribeOnOperator;\n}());\n//# sourceMappingURL=subscribeOn.js.map\n\n/***/ }),\n/* 154 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\nvar asap_1 = __webpack_require__(155);\nvar isNumeric_1 = __webpack_require__(73);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar SubscribeOnObservable = (function (_super) {\n    __extends(SubscribeOnObservable, _super);\n    function SubscribeOnObservable(source, delayTime, scheduler) {\n        if (delayTime === void 0) { delayTime = 0; }\n        if (scheduler === void 0) { scheduler = asap_1.asap; }\n        _super.call(this);\n        this.source = source;\n        this.delayTime = delayTime;\n        this.scheduler = scheduler;\n        if (!isNumeric_1.isNumeric(delayTime) || delayTime < 0) {\n            this.delayTime = 0;\n        }\n        if (!scheduler || typeof scheduler.schedule !== 'function') {\n            this.scheduler = asap_1.asap;\n        }\n    }\n    SubscribeOnObservable.create = function (source, delay, scheduler) {\n        if (delay === void 0) { delay = 0; }\n        if (scheduler === void 0) { scheduler = asap_1.asap; }\n        return new SubscribeOnObservable(source, delay, scheduler);\n    };\n    SubscribeOnObservable.dispatch = function (arg) {\n        var source = arg.source, subscriber = arg.subscriber;\n        return this.add(source.subscribe(subscriber));\n    };\n    SubscribeOnObservable.prototype._subscribe = function (subscriber) {\n        var delay = this.delayTime;\n        var source = this.source;\n        var scheduler = this.scheduler;\n        return scheduler.schedule(SubscribeOnObservable.dispatch, delay, {\n            source: source, subscriber: subscriber\n        });\n    };\n    return SubscribeOnObservable;\n}(Observable_1.Observable));\nexports.SubscribeOnObservable = SubscribeOnObservable;\n//# sourceMappingURL=SubscribeOnObservable.js.map\n\n/***/ }),\n/* 155 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar AsapAction_1 = __webpack_require__(156);\nvar AsapScheduler_1 = __webpack_require__(159);\n/**\n *\n * Asap Scheduler\n *\n * <span class=\"informal\">Perform task as fast as it can be performed asynchronously</span>\n *\n * `asap` scheduler behaves the same as {@link async} scheduler when you use it to delay task\n * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing\n * code to end and then it will try to execute given task as fast as possible.\n *\n * `asap` scheduler will do its best to minimize time between end of currently executing code\n * and start of scheduled task. This makes it best candidate for performing so called \"deferring\".\n * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves\n * some (although minimal) unwanted delay.\n *\n * Note that using `asap` scheduler does not necessarily mean that your task will be first to process\n * after currently executing code. In particular, if some task was also scheduled with `asap` before,\n * that task will execute first. That being said, if you need to schedule task asynchronously, but\n * as soon as possible, `asap` scheduler is your best bet.\n *\n * @example <caption>Compare async and asap scheduler</caption>\n *\n * Rx.Scheduler.async.schedule(() => console.log('async')); // scheduling 'async' first...\n * Rx.Scheduler.asap.schedule(() => console.log('asap'));\n *\n * // Logs:\n * // \"asap\"\n * // \"async\"\n * // ... but 'asap' goes first!\n *\n * @static true\n * @name asap\n * @owner Scheduler\n */\nexports.asap = new AsapScheduler_1.AsapScheduler(AsapAction_1.AsapAction);\n//# sourceMappingURL=asap.js.map\n\n/***/ }),\n/* 156 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Immediate_1 = __webpack_require__(157);\nvar AsyncAction_1 = __webpack_require__(75);\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsapAction = (function (_super) {\n    __extends(AsapAction, _super);\n    function AsapAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.work = work;\n    }\n    AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay is greater than 0, request as an async action.\n        if (delay !== null && delay > 0) {\n            return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);\n        }\n        // Push the action to the end of the scheduler queue.\n        scheduler.actions.push(this);\n        // If a microtask has already been scheduled, don't schedule another\n        // one. If a microtask hasn't been scheduled yet, schedule one now. Return\n        // the current scheduled microtask id.\n        return scheduler.scheduled || (scheduler.scheduled = Immediate_1.Immediate.setImmediate(scheduler.flush.bind(scheduler, null)));\n    };\n    AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay exists and is greater than 0, or if the delay is null (the\n        // action wasn't rescheduled) but was originally scheduled as an async\n        // action, then recycle as an async action.\n        if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {\n            return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);\n        }\n        // If the scheduler queue is empty, cancel the requested microtask and\n        // set the scheduled flag to undefined so the next AsapAction will schedule\n        // its own.\n        if (scheduler.actions.length === 0) {\n            Immediate_1.Immediate.clearImmediate(id);\n            scheduler.scheduled = undefined;\n        }\n        // Return undefined so the action knows to request a new async id if it's rescheduled.\n        return undefined;\n    };\n    return AsapAction;\n}(AsyncAction_1.AsyncAction));\nexports.AsapAction = AsapAction;\n//# sourceMappingURL=AsapAction.js.map\n\n/***/ }),\n/* 157 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(clearImmediate, setImmediate) {/**\nSome credit for this helper goes to http://github.com/YuzuJS/setImmediate\n*/\n\nvar root_1 = __webpack_require__(8);\nvar ImmediateDefinition = (function () {\n    function ImmediateDefinition(root) {\n        this.root = root;\n        if (root.setImmediate && typeof root.setImmediate === 'function') {\n            this.setImmediate = root.setImmediate.bind(root);\n            this.clearImmediate = root.clearImmediate.bind(root);\n        }\n        else {\n            this.nextHandle = 1;\n            this.tasksByHandle = {};\n            this.currentlyRunningATask = false;\n            // Don't get fooled by e.g. browserify environments.\n            if (this.canUseProcessNextTick()) {\n                // For Node.js before 0.9\n                this.setImmediate = this.createProcessNextTickSetImmediate();\n            }\n            else if (this.canUsePostMessage()) {\n                // For non-IE10 modern browsers\n                this.setImmediate = this.createPostMessageSetImmediate();\n            }\n            else if (this.canUseMessageChannel()) {\n                // For web workers, where supported\n                this.setImmediate = this.createMessageChannelSetImmediate();\n            }\n            else if (this.canUseReadyStateChange()) {\n                // For IE 6–8\n                this.setImmediate = this.createReadyStateChangeSetImmediate();\n            }\n            else {\n                // For older browsers\n                this.setImmediate = this.createSetTimeoutSetImmediate();\n            }\n            var ci = function clearImmediate(handle) {\n                delete clearImmediate.instance.tasksByHandle[handle];\n            };\n            ci.instance = this;\n            this.clearImmediate = ci;\n        }\n    }\n    ImmediateDefinition.prototype.identify = function (o) {\n        return this.root.Object.prototype.toString.call(o);\n    };\n    ImmediateDefinition.prototype.canUseProcessNextTick = function () {\n        return this.identify(this.root.process) === '[object process]';\n    };\n    ImmediateDefinition.prototype.canUseMessageChannel = function () {\n        return Boolean(this.root.MessageChannel);\n    };\n    ImmediateDefinition.prototype.canUseReadyStateChange = function () {\n        var document = this.root.document;\n        return Boolean(document && 'onreadystatechange' in document.createElement('script'));\n    };\n    ImmediateDefinition.prototype.canUsePostMessage = function () {\n        var root = this.root;\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `root.postMessage` means something completely different and can't be used for this purpose.\n        if (root.postMessage && !root.importScripts) {\n            var postMessageIsAsynchronous_1 = true;\n            var oldOnMessage = root.onmessage;\n            root.onmessage = function () {\n                postMessageIsAsynchronous_1 = false;\n            };\n            root.postMessage('', '*');\n            root.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous_1;\n        }\n        return false;\n    };\n    // This function accepts the same arguments as setImmediate, but\n    // returns a function that requires no arguments.\n    ImmediateDefinition.prototype.partiallyApplied = function (handler) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var fn = function result() {\n            var _a = result, handler = _a.handler, args = _a.args;\n            if (typeof handler === 'function') {\n                handler.apply(undefined, args);\n            }\n            else {\n                (new Function('' + handler))();\n            }\n        };\n        fn.handler = handler;\n        fn.args = args;\n        return fn;\n    };\n    ImmediateDefinition.prototype.addFromSetImmediateArguments = function (args) {\n        this.tasksByHandle[this.nextHandle] = this.partiallyApplied.apply(undefined, args);\n        return this.nextHandle++;\n    };\n    ImmediateDefinition.prototype.createProcessNextTickSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent, handle));\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createPostMessageSetImmediate = function () {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n        var root = this.root;\n        var messagePrefix = 'setImmediate$' + root.Math.random() + '$';\n        var onGlobalMessage = function globalMessageHandler(event) {\n            var instance = globalMessageHandler.instance;\n            if (event.source === root &&\n                typeof event.data === 'string' &&\n                event.data.indexOf(messagePrefix) === 0) {\n                instance.runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n        onGlobalMessage.instance = this;\n        root.addEventListener('message', onGlobalMessage, false);\n        var fn = function setImmediate() {\n            var _a = setImmediate, messagePrefix = _a.messagePrefix, instance = _a.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.postMessage(messagePrefix + handle, '*');\n            return handle;\n        };\n        fn.instance = this;\n        fn.messagePrefix = messagePrefix;\n        return fn;\n    };\n    ImmediateDefinition.prototype.runIfPresent = function (handle) {\n        // From the spec: 'Wait until any invocations of this algorithm started before this one have completed.'\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (this.currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // 'too much recursion' error.\n            this.root.setTimeout(this.partiallyApplied(this.runIfPresent, handle), 0);\n        }\n        else {\n            var task = this.tasksByHandle[handle];\n            if (task) {\n                this.currentlyRunningATask = true;\n                try {\n                    task();\n                }\n                finally {\n                    this.clearImmediate(handle);\n                    this.currentlyRunningATask = false;\n                }\n            }\n        }\n    };\n    ImmediateDefinition.prototype.createMessageChannelSetImmediate = function () {\n        var _this = this;\n        var channel = new this.root.MessageChannel();\n        channel.port1.onmessage = function (event) {\n            var handle = event.data;\n            _this.runIfPresent(handle);\n        };\n        var fn = function setImmediate() {\n            var _a = setImmediate, channel = _a.channel, instance = _a.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            channel.port2.postMessage(handle);\n            return handle;\n        };\n        fn.channel = channel;\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createReadyStateChangeSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var root = instance.root;\n            var doc = root.document;\n            var html = doc.documentElement;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement('script');\n            script.onreadystatechange = function () {\n                instance.runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createSetTimeoutSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.setTimeout(instance.partiallyApplied(instance.runIfPresent, handle), 0);\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    return ImmediateDefinition;\n}());\nexports.ImmediateDefinition = ImmediateDefinition;\nexports.Immediate = new ImmediateDefinition(root_1.root);\n//# sourceMappingURL=Immediate.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(93).clearImmediate, __webpack_require__(93).setImmediate))\n\n/***/ }),\n/* 158 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(58)))\n\n/***/ }),\n/* 159 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar AsyncScheduler_1 = __webpack_require__(76);\nvar AsapScheduler = (function (_super) {\n    __extends(AsapScheduler, _super);\n    function AsapScheduler() {\n        _super.apply(this, arguments);\n    }\n    AsapScheduler.prototype.flush = function (action) {\n        this.active = true;\n        this.scheduled = undefined;\n        var actions = this.actions;\n        var error;\n        var index = -1;\n        var count = actions.length;\n        action = action || actions.shift();\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (++index < count && (action = actions.shift()));\n        this.active = false;\n        if (error) {\n            while (++index < count && (action = actions.shift())) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsapScheduler;\n}(AsyncScheduler_1.AsyncScheduler));\nexports.AsapScheduler = AsapScheduler;\n//# sourceMappingURL=AsapScheduler.js.map\n\n/***/ }),\n/* 160 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar filter_1 = __webpack_require__(4);\r\nvar empty_1 = __webpack_require__(18);\r\nvar utils_1 = __webpack_require__(23);\r\nvar of_1 = __webpack_require__(11);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nvar file_reload_effect_1 = __webpack_require__(82);\r\nvar BrowserReload_1 = __webpack_require__(51);\r\nfunction incomingFileReload(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$), filter_1.filter(function (_a) {\r\n        var event = _a[0], options = _a[1];\r\n        return options.codeSync;\r\n    }), mergeMap_1.mergeMap(function (_a) {\r\n        var event = _a[0], options = _a[1];\r\n        if (event.url || !options.injectChanges) {\r\n            return BrowserReload_1.reloadBrowserSafe();\r\n        }\r\n        if (event.basename && event.ext && utils_1.isBlacklisted(event)) {\r\n            return empty_1.empty();\r\n        }\r\n        return of_1.of(file_reload_effect_1.fileReload(event));\r\n    }));\r\n}\r\nexports.incomingFileReload = incomingFileReload;\r\n\n\n/***/ }),\n/* 161 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar pluck_1 = __webpack_require__(7);\r\nvar of_1 = __webpack_require__(11);\r\nvar Log = __webpack_require__(16);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar mergeMap_1 = __webpack_require__(17);\r\nvar set_options_effect_1 = __webpack_require__(49);\r\nvar BrowserReload_1 = __webpack_require__(51);\r\nfunction incomingConnection(xs, inputs) {\r\n    return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.option$.pipe(pluck_1.pluck(\"logPrefix\"))), mergeMap_1.mergeMap(function (_a, index) {\r\n        var x = _a[0], logPrefix = _a[1];\r\n        if (index === 0) {\r\n            return of_1.of(set_options_effect_1.setOptions(x), Log.overlayInfo(logPrefix + \": connected\"));\r\n        }\r\n        return BrowserReload_1.reloadBrowserSafe();\r\n    }));\r\n}\r\nexports.incomingConnection = incomingConnection;\r\n\n\n/***/ }),\n/* 162 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar ignoreElements_1 = __webpack_require__(13);\r\nvar tap_1 = __webpack_require__(6);\r\nfunction incomingDisconnect(xs) {\r\n    return xs.pipe(tap_1.tap(function (x) { return console.log(x); }), ignoreElements_1.ignoreElements());\r\n}\r\nexports.incomingDisconnect = incomingDisconnect;\r\n\n\n/***/ }),\n/* 163 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar map_1 = __webpack_require__(2);\r\nvar set_options_effect_1 = __webpack_require__(49);\r\nfunction incomingOptionsSet(xs) {\r\n    return xs.pipe(map_1.map(function (event) { return set_options_effect_1.setOptions(event.options); }));\r\n}\r\nexports.incomingOptionsSet = incomingOptionsSet;\r\n\n\n/***/ }),\n/* 164 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar effects_1 = __webpack_require__(9);\r\nvar BehaviorSubject_1 = __webpack_require__(15);\r\nvar empty_1 = __webpack_require__(18);\r\nvar of_1 = __webpack_require__(11);\r\nvar Log = __webpack_require__(16);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar map_1 = __webpack_require__(2);\r\nvar set_window_name_dom_effect_1 = __webpack_require__(80);\r\nvar set_scroll_dom_effect_1 = __webpack_require__(79);\r\nexports.PREFIX = \"<<BS_START>>\";\r\nexports.SUFFIX = \"<<BS_START>>\";\r\nexports.regex = new RegExp(exports.PREFIX + \"(.+?)\" + exports.SUFFIX);\r\nfunction initWindowName(window) {\r\n    var saved = (function () {\r\n        /**\r\n         * On page load, check window.name for an existing\r\n         * BS json blob & parse it.\r\n         */\r\n        try {\r\n            var json = window.name.match(exports.regex);\r\n            if (json) {\r\n                return JSON.parse(json[1]);\r\n            }\r\n        }\r\n        catch (e) {\r\n            return {};\r\n        }\r\n    })();\r\n    /**\r\n     * Remove any existing BS json from window.name\r\n     * to ensure we don't interfere with any other\r\n     * libs who may be using it.\r\n     */\r\n    window.name = window.name.replace(exports.regex, \"\");\r\n    /**\r\n     * If the JSON was parsed correctly, try to\r\n     * find a scroll property and restore it.\r\n     */\r\n    if (saved && saved.bs && saved.bs.hardReload && saved.bs.scroll) {\r\n        var _a = saved.bs.scroll, x = _a.x, y = _a.y;\r\n        return of_1.of(set_scroll_dom_effect_1.setScroll(x, y), Log.consoleDebug(\"[ScrollRestore] x = \" + x + \" y = \" + y));\r\n    }\r\n    return empty_1.empty();\r\n}\r\nexports.initWindowName = initWindowName;\r\nexports.scrollRestoreHandlers$ = new BehaviorSubject_1.BehaviorSubject((_a = {},\r\n    // [EffectNames.SetOptions]: (xs, inputs: Inputs) => {\r\n    //     return xs.pipe(\r\n    //         withLatestFrom(inputs.window$),\r\n    //         take(1),\r\n    //         mergeMap(([options, window]) => {\r\n    //             if (options.scrollRestoreTechnique === \"window.name\") {\r\n    //                 return initWindowName(window);\r\n    //             }\r\n    //             return empty();\r\n    //         })\r\n    //     );\r\n    // },\r\n    /**\r\n     * Save the current scroll position\r\n     * before the browser is reloaded (via window.location.reload(true))\r\n     * @param xs\r\n     * @param {Inputs} inputs\r\n     */\r\n    _a[effects_1.EffectNames.PreBrowserReload] = function (xs, inputs) {\r\n        return xs.pipe(withLatestFrom_1.withLatestFrom(inputs.window$, inputs.document$), map_1.map(function (_a) {\r\n            var window = _a[1], document = _a[2];\r\n            return [\r\n                window.name,\r\n                exports.PREFIX,\r\n                JSON.stringify({\r\n                    bs: {\r\n                        hardReload: true,\r\n                        scroll: browser_utils_1.getBrowserScrollPosition(window, document)\r\n                    }\r\n                }),\r\n                exports.SUFFIX\r\n            ].join(\"\");\r\n        }), map_1.map(function (value) { return set_window_name_dom_effect_1.setWindowName(value); }));\r\n    },\r\n    _a));\r\nvar _a;\r\n\n\n/***/ }),\n/* 165 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar merge_1 = __webpack_require__(36);\r\nvar form_inputs_listener_1 = __webpack_require__(166);\r\nvar clicks_listener_1 = __webpack_require__(168);\r\nvar scroll_listener_1 = __webpack_require__(169);\r\nvar form_toggles_listener_1 = __webpack_require__(170);\r\nfunction initListeners(window, document, socket$, option$) {\r\n    var merged$ = merge_1.merge(scroll_listener_1.getScrollStream(window, document, socket$, option$), clicks_listener_1.getClickStream(document, socket$, option$), form_inputs_listener_1.getFormInputStream(document, socket$, option$), form_toggles_listener_1.getFormTogglesStream(document, socket$, option$));\r\n    return merged$;\r\n}\r\nexports.initListeners = initListeners;\r\n\n\n/***/ }),\n/* 166 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar utils_1 = __webpack_require__(23);\r\nvar KeyupEvent = __webpack_require__(92);\r\nvar filter_1 = __webpack_require__(4);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar map_1 = __webpack_require__(2);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar skip_1 = __webpack_require__(37);\r\nvar distinctUntilChanged_1 = __webpack_require__(38);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar empty_1 = __webpack_require__(18);\r\nvar fromEvent_1 = __webpack_require__(39);\r\nfunction getFormInputStream(document, socket$, option$) {\r\n    var canSync$ = utils_1.createTimedBooleanSwitch(socket$.pipe(filter_1.filter(function (_a) {\r\n        var name = _a[0];\r\n        return name === socket_messages_1.IncomingSocketNames.Keyup;\r\n    })));\r\n    return option$.pipe(skip_1.skip(1), // initial option set before the connection event\r\n    pluck_1.pluck(\"ghostMode\", \"forms\", \"inputs\"), distinctUntilChanged_1.distinctUntilChanged(), switchMap_1.switchMap(function (formInputs) {\r\n        if (!formInputs) {\r\n            return empty_1.empty();\r\n        }\r\n        return fromEvent_1.fromEvent(document.body, \"keyup\", true).pipe(map_1.map(function (e) { return e.target || e.srcElement; }), filter_1.filter(function (target) {\r\n            return target.tagName === \"INPUT\" ||\r\n                target.tagName === \"TEXTAREA\";\r\n        }), withLatestFrom_1.withLatestFrom(canSync$), filter_1.filter(function (_a) {\r\n            var canSync = _a[1];\r\n            return canSync;\r\n        }), map_1.map(function (_a) {\r\n            var eventTarget = _a[0];\r\n            var target = browser_utils_1.getElementData(eventTarget);\r\n            var value = eventTarget.value;\r\n            return KeyupEvent.outgoing(target, value);\r\n        }));\r\n    }));\r\n}\r\nexports.getFormInputStream = getFormInputStream;\r\n\n\n/***/ }),\n/* 167 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = __webpack_require__(1);\nvar tryCatch_1 = __webpack_require__(41);\nvar isFunction_1 = __webpack_require__(40);\nvar errorObject_1 = __webpack_require__(29);\nvar Subscription_1 = __webpack_require__(14);\nvar toString = Object.prototype.toString;\nfunction isNodeStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';\n}\nfunction isJQueryStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';\n}\nfunction isNodeList(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object NodeList]';\n}\nfunction isHTMLCollection(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object HTMLCollection]';\n}\nfunction isEventTarget(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';\n}\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromEventObservable = (function (_super) {\n    __extends(FromEventObservable, _super);\n    function FromEventObservable(sourceObj, eventName, selector, options) {\n        _super.call(this);\n        this.sourceObj = sourceObj;\n        this.eventName = eventName;\n        this.selector = selector;\n        this.options = options;\n    }\n    /* tslint:enable:max-line-length */\n    /**\n     * Creates an Observable that emits events of a specific type coming from the\n     * given event target.\n     *\n     * <span class=\"informal\">Creates an Observable from DOM events, or Node.js\n     * EventEmitter events or others.</span>\n     *\n     * <img src=\"./img/fromEvent.png\" width=\"100%\">\n     *\n     * `fromEvent` accepts as a first argument event target, which is an object with methods\n     * for registering event handler functions. As a second argument it takes string that indicates\n     * type of event we want to listen for. `fromEvent` supports selected types of event targets,\n     * which are described in detail below. If your event target does not match any of the ones listed,\n     * you should use {@link fromEventPattern}, which can be used on arbitrary APIs.\n     * When it comes to APIs supported by `fromEvent`, their methods for adding and removing event\n     * handler functions have different names, but they all accept a string describing event type\n     * and function itself, which will be called whenever said event happens.\n     *\n     * Every time resulting Observable is subscribed, event handler function will be registered\n     * to event target on given event type. When that event fires, value\n     * passed as a first argument to registered function will be emitted by output Observable.\n     * When Observable is unsubscribed, function will be unregistered from event target.\n     *\n     * Note that if event target calls registered function with more than one argument, second\n     * and following arguments will not appear in resulting stream. In order to get access to them,\n     * you can pass to `fromEvent` optional project function, which will be called with all arguments\n     * passed to event handler. Output Observable will then emit value returned by project function,\n     * instead of the usual value.\n     *\n     * Remember that event targets listed below are checked via duck typing. It means that\n     * no matter what kind of object you have and no matter what environment you work in,\n     * you can safely use `fromEvent` on that object if it exposes described methods (provided\n     * of course they behave as was described above). So for example if Node.js library exposes\n     * event target which has the same method names as DOM EventTarget, `fromEvent` is still\n     * a good choice.\n     *\n     * If the API you use is more callback then event handler oriented (subscribed\n     * callback function fires only once and thus there is no need to manually\n     * unregister it), you should use {@link bindCallback} or {@link bindNodeCallback}\n     * instead.\n     *\n     * `fromEvent` supports following types of event targets:\n     *\n     * **DOM EventTarget**\n     *\n     * This is an object with `addEventListener` and `removeEventListener` methods.\n     *\n     * In the browser, `addEventListener` accepts - apart from event type string and event\n     * handler function arguments - optional third parameter, which is either an object or boolean,\n     * both used for additional configuration how and when passed function will be called. When\n     * `fromEvent` is used with event target of that type, you can provide this values\n     * as third parameter as well.\n     *\n     * **Node.js EventEmitter**\n     *\n     * An object with `addListener` and `removeListener` methods.\n     *\n     * **JQuery-style event target**\n     *\n     * An object with `on` and `off` methods\n     *\n     * **DOM NodeList**\n     *\n     * List of DOM Nodes, returned for example by `document.querySelectorAll` or `Node.childNodes`.\n     *\n     * Although this collection is not event target in itself, `fromEvent` will iterate over all Nodes\n     * it contains and install event handler function in every of them. When returned Observable\n     * is unsubscribed, function will be removed from all Nodes.\n     *\n     * **DOM HtmlCollection**\n     *\n     * Just as in case of NodeList it is a collection of DOM nodes. Here as well event handler function is\n     * installed and removed in each of elements.\n     *\n     *\n     * @example <caption>Emits clicks happening on the DOM document</caption>\n     * var clicks = Rx.Observable.fromEvent(document, 'click');\n     * clicks.subscribe(x => console.log(x));\n     *\n     * // Results in:\n     * // MouseEvent object logged to console every time a click\n     * // occurs on the document.\n     *\n     *\n     * @example <caption>Use addEventListener with capture option</caption>\n     * var clicksInDocument = Rx.Observable.fromEvent(document, 'click', true); // note optional configuration parameter\n     *                                                                          // which will be passed to addEventListener\n     * var clicksInDiv = Rx.Observable.fromEvent(someDivInDocument, 'click');\n     *\n     * clicksInDocument.subscribe(() => console.log('document'));\n     * clicksInDiv.subscribe(() => console.log('div'));\n     *\n     * // By default events bubble UP in DOM tree, so normally\n     * // when we would click on div in document\n     * // \"div\" would be logged first and then \"document\".\n     * // Since we specified optional `capture` option, document\n     * // will catch event when it goes DOWN DOM tree, so console\n     * // will log \"document\" and then \"div\".\n     *\n     * @see {@link bindCallback}\n     * @see {@link bindNodeCallback}\n     * @see {@link fromEventPattern}\n     *\n     * @param {EventTargetLike} target The DOM EventTarget, Node.js\n     * EventEmitter, JQuery-like event target, NodeList or HTMLCollection to attach the event handler to.\n     * @param {string} eventName The event name of interest, being emitted by the\n     * `target`.\n     * @param {EventListenerOptions} [options] Options to pass through to addEventListener\n     * @param {SelectorMethodSignature<T>} [selector] An optional function to\n     * post-process results. It takes the arguments from the event handler and\n     * should return a single value.\n     * @return {Observable<T>}\n     * @static true\n     * @name fromEvent\n     * @owner Observable\n     */\n    FromEventObservable.create = function (target, eventName, options, selector) {\n        if (isFunction_1.isFunction(options)) {\n            selector = options;\n            options = undefined;\n        }\n        return new FromEventObservable(target, eventName, selector, options);\n    };\n    FromEventObservable.setupSubscription = function (sourceObj, eventName, handler, subscriber, options) {\n        var unsubscribe;\n        if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {\n            for (var i = 0, len = sourceObj.length; i < len; i++) {\n                FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber, options);\n            }\n        }\n        else if (isEventTarget(sourceObj)) {\n            var source_1 = sourceObj;\n            sourceObj.addEventListener(eventName, handler, options);\n            unsubscribe = function () {\n                return source_1.removeEventListener(eventName, handler);\n            };\n        }\n        else if (isJQueryStyleEventEmitter(sourceObj)) {\n            var source_2 = sourceObj;\n            sourceObj.on(eventName, handler);\n            unsubscribe = function () { return source_2.off(eventName, handler); };\n        }\n        else if (isNodeStyleEventEmitter(sourceObj)) {\n            var source_3 = sourceObj;\n            sourceObj.addListener(eventName, handler);\n            unsubscribe = function () { return source_3.removeListener(eventName, handler); };\n        }\n        else {\n            throw new TypeError('Invalid event target');\n        }\n        subscriber.add(new Subscription_1.Subscription(unsubscribe));\n    };\n    FromEventObservable.prototype._subscribe = function (subscriber) {\n        var sourceObj = this.sourceObj;\n        var eventName = this.eventName;\n        var options = this.options;\n        var selector = this.selector;\n        var handler = selector ? function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            var result = tryCatch_1.tryCatch(selector).apply(void 0, args);\n            if (result === errorObject_1.errorObject) {\n                subscriber.error(errorObject_1.errorObject.e);\n            }\n            else {\n                subscriber.next(result);\n            }\n        } : function (e) { return subscriber.next(e); };\n        FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber, options);\n    };\n    return FromEventObservable;\n}(Observable_1.Observable));\nexports.FromEventObservable = FromEventObservable;\n//# sourceMappingURL=FromEventObservable.js.map\n\n\n/***/ }),\n/* 168 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar utils_1 = __webpack_require__(23);\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar ClickEvent = __webpack_require__(91);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar skip_1 = __webpack_require__(37);\r\nvar distinctUntilChanged_1 = __webpack_require__(38);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar fromEvent_1 = __webpack_require__(39);\r\nvar empty_1 = __webpack_require__(18);\r\nfunction getClickStream(document, socket$, option$) {\r\n    var canSync$ = utils_1.createTimedBooleanSwitch(socket$.pipe(filter_1.filter(function (_a) {\r\n        var name = _a[0];\r\n        return name === socket_messages_1.IncomingSocketNames.Click;\r\n    })));\r\n    return option$.pipe(skip_1.skip(1), // initial option set before the connection event\r\n    pluck_1.pluck(\"ghostMode\", \"clicks\"), distinctUntilChanged_1.distinctUntilChanged(), switchMap_1.switchMap(function (canClick) {\r\n        if (!canClick) {\r\n            return empty_1.empty();\r\n        }\r\n        return fromEvent_1.fromEvent(document, \"click\", true).pipe(map_1.map(function (e) { return e.target; }), filter_1.filter(function (target) {\r\n            if (target.tagName === \"LABEL\") {\r\n                var id = target.getAttribute(\"for\");\r\n                if (id && document.getElementById(id)) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }), withLatestFrom_1.withLatestFrom(canSync$), filter_1.filter(function (_a) {\r\n            var canSync = _a[1];\r\n            return canSync;\r\n        }), map_1.map(function (_a) {\r\n            var target = _a[0];\r\n            return ClickEvent.outgoing(browser_utils_1.getElementData(target));\r\n        }));\r\n    }));\r\n}\r\nexports.getClickStream = getClickStream;\r\n\n\n/***/ }),\n/* 169 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar utils_1 = __webpack_require__(23);\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar ScrollEvent = __webpack_require__(81);\r\nvar filter_1 = __webpack_require__(4);\r\nvar map_1 = __webpack_require__(2);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar distinctUntilChanged_1 = __webpack_require__(38);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar empty_1 = __webpack_require__(18);\r\nvar skip_1 = __webpack_require__(37);\r\nvar fromEvent_1 = __webpack_require__(39);\r\nfunction getScrollStream(window, document, socket$, option$) {\r\n    var canSync$ = utils_1.createTimedBooleanSwitch(socket$.pipe(filter_1.filter(function (_a) {\r\n        var name = _a[0];\r\n        return name === socket_messages_1.IncomingSocketNames.Scroll;\r\n    })));\r\n    /**\r\n     * If the option 'scrollElementMapping' is provided\r\n     * we cache thw\r\n     * @type {Observable<(Element | null)[]>}\r\n     */\r\n    var elemMap$ = option$.pipe(pluck_1.pluck(\"scrollElementMapping\"), map_1.map(function (selectors) {\r\n        return selectors.map(function (selector) { return document.querySelector(selector); });\r\n    }));\r\n    return option$.pipe(skip_1.skip(1), // initial option set before the connection event\r\n    pluck_1.pluck(\"ghostMode\", \"scroll\"), distinctUntilChanged_1.distinctUntilChanged(), switchMap_1.switchMap(function (scroll) {\r\n        if (!scroll)\r\n            return empty_1.empty();\r\n        return fromEvent_1.fromEvent(document, \"scroll\", true).pipe(map_1.map(function (e) { return e.target; }), withLatestFrom_1.withLatestFrom(canSync$, elemMap$), filter_1.filter(function (_a) {\r\n            var canSync = _a[1];\r\n            return Boolean(canSync);\r\n        }), map_1.map(function (_a) {\r\n            var target = _a[0], canSync = _a[1], elemMap = _a[2];\r\n            if (target === document) {\r\n                return ScrollEvent.outgoing(browser_utils_1.getScrollPosition(window, document), \"document\", 0);\r\n            }\r\n            var elems = document.getElementsByTagName(target.tagName);\r\n            var index = Array.prototype.indexOf.call(elems || [], target);\r\n            return ScrollEvent.outgoing(browser_utils_1.getScrollPositionForElement(target), target.tagName, index, elemMap.indexOf(target));\r\n        }));\r\n    }));\r\n}\r\nexports.getScrollStream = getScrollStream;\r\n\n\n/***/ }),\n/* 170 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar socket_messages_1 = __webpack_require__(12);\r\nvar browser_utils_1 = __webpack_require__(24);\r\nvar utils_1 = __webpack_require__(23);\r\nvar FormToggleEvent = __webpack_require__(94);\r\nvar filter_1 = __webpack_require__(4);\r\nvar skip_1 = __webpack_require__(37);\r\nvar pluck_1 = __webpack_require__(7);\r\nvar distinctUntilChanged_1 = __webpack_require__(38);\r\nvar withLatestFrom_1 = __webpack_require__(0);\r\nvar map_1 = __webpack_require__(2);\r\nvar switchMap_1 = __webpack_require__(22);\r\nvar empty_1 = __webpack_require__(18);\r\nvar fromEvent_1 = __webpack_require__(39);\r\nfunction getFormTogglesStream(document, socket$, option$) {\r\n    var canSync$ = utils_1.createTimedBooleanSwitch(socket$.pipe(filter_1.filter(function (_a) {\r\n        var name = _a[0];\r\n        return name === socket_messages_1.IncomingSocketNames.InputToggle;\r\n    })));\r\n    return option$.pipe(skip_1.skip(1), pluck_1.pluck(\"ghostMode\", \"forms\", \"toggles\"), distinctUntilChanged_1.distinctUntilChanged(), switchMap_1.switchMap(function (canToggle) {\r\n        if (!canToggle) {\r\n            return empty_1.empty();\r\n        }\r\n        return fromEvent_1.fromEvent(document, \"change\", true).pipe(map_1.map(function (e) { return e.target || e.srcElement; }), filter_1.filter(function (elem) { return elem.tagName === \"SELECT\"; }), withLatestFrom_1.withLatestFrom(canSync$), filter_1.filter(function (_a) {\r\n            var canSync = _a[1];\r\n            return canSync;\r\n        }), map_1.map(function (_a) {\r\n            var elem = _a[0], canSync = _a[1];\r\n            var data = browser_utils_1.getElementData(elem);\r\n            return FormToggleEvent.outgoing(data, {\r\n                type: elem.type,\r\n                checked: elem.checked,\r\n                value: elem.value\r\n            });\r\n        }));\r\n    }));\r\n}\r\nexports.getFormTogglesStream = getFormTogglesStream;\r\n\n\n/***/ }),\n/* 171 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(3);\nvar Subscription_1 = __webpack_require__(14);\nvar Observable_1 = __webpack_require__(1);\nvar Subject_1 = __webpack_require__(35);\nvar Map_1 = __webpack_require__(172);\nvar FastMap_1 = __webpack_require__(174);\n/* tslint:enable:max-line-length */\n/**\n * Groups the items emitted by an Observable according to a specified criterion,\n * and emits these grouped items as `GroupedObservables`, one\n * {@link GroupedObservable} per group.\n *\n * <img src=\"./img/groupBy.png\" width=\"100%\">\n *\n * @example <caption>Group objects by id and return as array</caption>\n * Observable.of<Obj>({id: 1, name: 'aze1'},\n *                    {id: 2, name: 'sf2'},\n *                    {id: 2, name: 'dg2'},\n *                    {id: 1, name: 'erg1'},\n *                    {id: 1, name: 'df1'},\n *                    {id: 2, name: 'sfqfb2'},\n *                    {id: 3, name: 'qfs3'},\n *                    {id: 2, name: 'qsgqsfg2'}\n *     )\n *     .groupBy(p => p.id)\n *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], []))\n *     .subscribe(p => console.log(p));\n *\n * // displays:\n * // [ { id: 1, name: 'aze1' },\n * //   { id: 1, name: 'erg1' },\n * //   { id: 1, name: 'df1' } ]\n * //\n * // [ { id: 2, name: 'sf2' },\n * //   { id: 2, name: 'dg2' },\n * //   { id: 2, name: 'sfqfb2' },\n * //   { id: 2, name: 'qsgqsfg2' } ]\n * //\n * // [ { id: 3, name: 'qfs3' } ]\n *\n * @example <caption>Pivot data on the id field</caption>\n * Observable.of<Obj>({id: 1, name: 'aze1'},\n *                    {id: 2, name: 'sf2'},\n *                    {id: 2, name: 'dg2'},\n *                    {id: 1, name: 'erg1'},\n *                    {id: 1, name: 'df1'},\n *                    {id: 2, name: 'sfqfb2'},\n *                    {id: 3, name: 'qfs1'},\n *                    {id: 2, name: 'qsgqsfg2'}\n *                   )\n *     .groupBy(p => p.id, p => p.name)\n *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], [\"\" + group$.key]))\n *     .map(arr => ({'id': parseInt(arr[0]), 'values': arr.slice(1)}))\n *     .subscribe(p => console.log(p));\n *\n * // displays:\n * // { id: 1, values: [ 'aze1', 'erg1', 'df1' ] }\n * // { id: 2, values: [ 'sf2', 'dg2', 'sfqfb2', 'qsgqsfg2' ] }\n * // { id: 3, values: [ 'qfs1' ] }\n *\n * @param {function(value: T): K} keySelector A function that extracts the key\n * for each item.\n * @param {function(value: T): R} [elementSelector] A function that extracts the\n * return element for each item.\n * @param {function(grouped: GroupedObservable<K,R>): Observable<any>} [durationSelector]\n * A function that returns an Observable to determine how long each group should\n * exist.\n * @return {Observable<GroupedObservable<K,R>>} An Observable that emits\n * GroupedObservables, each of which corresponds to a unique key value and each\n * of which emits those items from the source Observable that share that key\n * value.\n * @method groupBy\n * @owner Observable\n */\nfunction groupBy(keySelector, elementSelector, durationSelector, subjectSelector) {\n    return function (source) {\n        return source.lift(new GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector));\n    };\n}\nexports.groupBy = groupBy;\nvar GroupByOperator = (function () {\n    function GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector) {\n        this.keySelector = keySelector;\n        this.elementSelector = elementSelector;\n        this.durationSelector = durationSelector;\n        this.subjectSelector = subjectSelector;\n    }\n    GroupByOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector, this.subjectSelector));\n    };\n    return GroupByOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar GroupBySubscriber = (function (_super) {\n    __extends(GroupBySubscriber, _super);\n    function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector, subjectSelector) {\n        _super.call(this, destination);\n        this.keySelector = keySelector;\n        this.elementSelector = elementSelector;\n        this.durationSelector = durationSelector;\n        this.subjectSelector = subjectSelector;\n        this.groups = null;\n        this.attemptedToUnsubscribe = false;\n        this.count = 0;\n    }\n    GroupBySubscriber.prototype._next = function (value) {\n        var key;\n        try {\n            key = this.keySelector(value);\n        }\n        catch (err) {\n            this.error(err);\n            return;\n        }\n        this._group(value, key);\n    };\n    GroupBySubscriber.prototype._group = function (value, key) {\n        var groups = this.groups;\n        if (!groups) {\n            groups = this.groups = typeof key === 'string' ? new FastMap_1.FastMap() : new Map_1.Map();\n        }\n        var group = groups.get(key);\n        var element;\n        if (this.elementSelector) {\n            try {\n                element = this.elementSelector(value);\n            }\n            catch (err) {\n                this.error(err);\n            }\n        }\n        else {\n            element = value;\n        }\n        if (!group) {\n            group = this.subjectSelector ? this.subjectSelector() : new Subject_1.Subject();\n            groups.set(key, group);\n            var groupedObservable = new GroupedObservable(key, group, this);\n            this.destination.next(groupedObservable);\n            if (this.durationSelector) {\n                var duration = void 0;\n                try {\n                    duration = this.durationSelector(new GroupedObservable(key, group));\n                }\n                catch (err) {\n                    this.error(err);\n                    return;\n                }\n                this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this)));\n            }\n        }\n        if (!group.closed) {\n            group.next(element);\n        }\n    };\n    GroupBySubscriber.prototype._error = function (err) {\n        var groups = this.groups;\n        if (groups) {\n            groups.forEach(function (group, key) {\n                group.error(err);\n            });\n            groups.clear();\n        }\n        this.destination.error(err);\n    };\n    GroupBySubscriber.prototype._complete = function () {\n        var groups = this.groups;\n        if (groups) {\n            groups.forEach(function (group, key) {\n                group.complete();\n            });\n            groups.clear();\n        }\n        this.destination.complete();\n    };\n    GroupBySubscriber.prototype.removeGroup = function (key) {\n        this.groups.delete(key);\n    };\n    GroupBySubscriber.prototype.unsubscribe = function () {\n        if (!this.closed) {\n            this.attemptedToUnsubscribe = true;\n            if (this.count === 0) {\n                _super.prototype.unsubscribe.call(this);\n            }\n        }\n    };\n    return GroupBySubscriber;\n}(Subscriber_1.Subscriber));\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar GroupDurationSubscriber = (function (_super) {\n    __extends(GroupDurationSubscriber, _super);\n    function GroupDurationSubscriber(key, group, parent) {\n        _super.call(this, group);\n        this.key = key;\n        this.group = group;\n        this.parent = parent;\n    }\n    GroupDurationSubscriber.prototype._next = function (value) {\n        this.complete();\n    };\n    GroupDurationSubscriber.prototype._unsubscribe = function () {\n        var _a = this, parent = _a.parent, key = _a.key;\n        this.key = this.parent = null;\n        if (parent) {\n            parent.removeGroup(key);\n        }\n    };\n    return GroupDurationSubscriber;\n}(Subscriber_1.Subscriber));\n/**\n * An Observable representing values belonging to the same group represented by\n * a common key. The values emitted by a GroupedObservable come from the source\n * Observable. The common key is available as the field `key` on a\n * GroupedObservable instance.\n *\n * @class GroupedObservable<K, T>\n */\nvar GroupedObservable = (function (_super) {\n    __extends(GroupedObservable, _super);\n    function GroupedObservable(key, groupSubject, refCountSubscription) {\n        _super.call(this);\n        this.key = key;\n        this.groupSubject = groupSubject;\n        this.refCountSubscription = refCountSubscription;\n    }\n    GroupedObservable.prototype._subscribe = function (subscriber) {\n        var subscription = new Subscription_1.Subscription();\n        var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject;\n        if (refCountSubscription && !refCountSubscription.closed) {\n            subscription.add(new InnerRefCountSubscription(refCountSubscription));\n        }\n        subscription.add(groupSubject.subscribe(subscriber));\n        return subscription;\n    };\n    return GroupedObservable;\n}(Observable_1.Observable));\nexports.GroupedObservable = GroupedObservable;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerRefCountSubscription = (function (_super) {\n    __extends(InnerRefCountSubscription, _super);\n    function InnerRefCountSubscription(parent) {\n        _super.call(this);\n        this.parent = parent;\n        parent.count++;\n    }\n    InnerRefCountSubscription.prototype.unsubscribe = function () {\n        var parent = this.parent;\n        if (!parent.closed && !this.closed) {\n            _super.prototype.unsubscribe.call(this);\n            parent.count -= 1;\n            if (parent.count === 0 && parent.attemptedToUnsubscribe) {\n                parent.unsubscribe();\n            }\n        }\n    };\n    return InnerRefCountSubscription;\n}(Subscription_1.Subscription));\n//# sourceMappingURL=groupBy.js.map\n\n/***/ }),\n/* 172 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar root_1 = __webpack_require__(8);\nvar MapPolyfill_1 = __webpack_require__(173);\nexports.Map = root_1.root.Map || (function () { return MapPolyfill_1.MapPolyfill; })();\n//# sourceMappingURL=Map.js.map\n\n/***/ }),\n/* 173 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar MapPolyfill = (function () {\n    function MapPolyfill() {\n        this.size = 0;\n        this._values = [];\n        this._keys = [];\n    }\n    MapPolyfill.prototype.get = function (key) {\n        var i = this._keys.indexOf(key);\n        return i === -1 ? undefined : this._values[i];\n    };\n    MapPolyfill.prototype.set = function (key, value) {\n        var i = this._keys.indexOf(key);\n        if (i === -1) {\n            this._keys.push(key);\n            this._values.push(value);\n            this.size++;\n        }\n        else {\n            this._values[i] = value;\n        }\n        return this;\n    };\n    MapPolyfill.prototype.delete = function (key) {\n        var i = this._keys.indexOf(key);\n        if (i === -1) {\n            return false;\n        }\n        this._values.splice(i, 1);\n        this._keys.splice(i, 1);\n        this.size--;\n        return true;\n    };\n    MapPolyfill.prototype.clear = function () {\n        this._keys.length = 0;\n        this._values.length = 0;\n        this.size = 0;\n    };\n    MapPolyfill.prototype.forEach = function (cb, thisArg) {\n        for (var i = 0; i < this.size; i++) {\n            cb.call(thisArg, this._values[i], this._keys[i]);\n        }\n    };\n    return MapPolyfill;\n}());\nexports.MapPolyfill = MapPolyfill;\n//# sourceMappingURL=MapPolyfill.js.map\n\n/***/ }),\n/* 174 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar FastMap = (function () {\n    function FastMap() {\n        this.values = {};\n    }\n    FastMap.prototype.delete = function (key) {\n        this.values[key] = null;\n        return true;\n    };\n    FastMap.prototype.set = function (key, value) {\n        this.values[key] = value;\n        return this;\n    };\n    FastMap.prototype.get = function (key) {\n        return this.values[key];\n    };\n    FastMap.prototype.forEach = function (cb, thisArg) {\n        var values = this.values;\n        for (var key in values) {\n            if (values.hasOwnProperty(key) && values[key] !== null) {\n                cb.call(thisArg, values[key], key);\n            }\n        }\n    };\n    FastMap.prototype.clear = function () {\n        this.values = {};\n    };\n    return FastMap;\n}());\nexports.FastMap = FastMap;\n//# sourceMappingURL=FastMap.js.map\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// index.min.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 = 95);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap e10c8ac77355846295d0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/* tslint:enable:max-line-length */\n/**\n * Combines the source Observable with other Observables to create an Observable\n * whose values are calculated from the latest values of each, only when the\n * source emits.\n *\n * <span class=\"informal\">Whenever the source Observable emits a value, it\n * computes a formula using that value plus the latest values from other input\n * Observables, then emits the output of that formula.</span>\n *\n * <img src=\"./img/withLatestFrom.png\" width=\"100%\">\n *\n * `withLatestFrom` combines each value from the source Observable (the\n * instance) with the latest values from the other input Observables only when\n * the source emits a value, optionally using a `project` function to determine\n * the value to be emitted on the output Observable. All input Observables must\n * emit at least one value before the output Observable will emit a value.\n *\n * @example <caption>On every click event, emit an array with the latest timer event plus the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var timer = Rx.Observable.interval(1000);\n * var result = clicks.withLatestFrom(timer);\n * result.subscribe(x => console.log(x));\n *\n * @see {@link combineLatest}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {Function} [project] Projection function for combining values\n * together. Receives all values in order of the Observables passed, where the\n * first parameter is a value from the source Observable. (e.g.\n * `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not\n * passed, arrays will be emitted on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method withLatestFrom\n * @owner Observable\n */\nfunction withLatestFrom() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i - 0] = arguments[_i];\n    }\n    return function (source) {\n        var project;\n        if (typeof args[args.length - 1] === 'function') {\n            project = args.pop();\n        }\n        var observables = args;\n        return source.lift(new WithLatestFromOperator(observables, project));\n    };\n}\nexports.withLatestFrom = withLatestFrom;\nvar WithLatestFromOperator = (function () {\n    function WithLatestFromOperator(observables, project) {\n        this.observables = observables;\n        this.project = project;\n    }\n    WithLatestFromOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));\n    };\n    return WithLatestFromOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar WithLatestFromSubscriber = (function (_super) {\n    __extends(WithLatestFromSubscriber, _super);\n    function WithLatestFromSubscriber(destination, observables, project) {\n        _super.call(this, destination);\n        this.observables = observables;\n        this.project = project;\n        this.toRespond = [];\n        var len = observables.length;\n        this.values = new Array(len);\n        for (var i = 0; i < len; i++) {\n            this.toRespond.push(i);\n        }\n        for (var i = 0; i < len; i++) {\n            var observable = observables[i];\n            this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i));\n        }\n    }\n    WithLatestFromSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.values[outerIndex] = innerValue;\n        var toRespond = this.toRespond;\n        if (toRespond.length > 0) {\n            var found = toRespond.indexOf(outerIndex);\n            if (found !== -1) {\n                toRespond.splice(found, 1);\n            }\n        }\n    };\n    WithLatestFromSubscriber.prototype.notifyComplete = function () {\n        // noop\n    };\n    WithLatestFromSubscriber.prototype._next = function (value) {\n        if (this.toRespond.length === 0) {\n            var args = [value].concat(this.values);\n            if (this.project) {\n                this._tryProject(args);\n            }\n            else {\n                this.destination.next(args);\n            }\n        }\n    };\n    WithLatestFromSubscriber.prototype._tryProject = function (args) {\n        var result;\n        try {\n            result = this.project.apply(this, args);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return WithLatestFromSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=withLatestFrom.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/withLatestFrom.js\n// module id = 0\n// module chunks = 0","\"use strict\";\nvar root_1 = require('./util/root');\nvar toSubscriber_1 = require('./util/toSubscriber');\nvar observable_1 = require('./symbol/observable');\nvar pipe_1 = require('./util/pipe');\n/**\n * A representation of any set of values over any amount of time. This is the most basic building block\n * of RxJS.\n *\n * @class Observable<T>\n */\nvar Observable = (function () {\n    /**\n     * @constructor\n     * @param {Function} subscribe the function that is called when the Observable is\n     * initially subscribed to. This function is given a Subscriber, to which new values\n     * can be `next`ed, or an `error` method can be called to raise an error, or\n     * `complete` can be called to notify of a successful completion.\n     */\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    /**\n     * Creates a new Observable, with this Observable as the source, and the passed\n     * operator defined as the new observable's operator.\n     * @method lift\n     * @param {Operator} operator the operator defining the operation to take on the observable\n     * @return {Observable} a new observable with the Operator applied\n     */\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    /**\n     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.\n     *\n     * <span class=\"informal\">Use it when you have all these Observables, but still nothing is happening.</span>\n     *\n     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It\n     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is\n     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling\n     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often\n     * thought.\n     *\n     * Apart from starting the execution of an Observable, this method allows you to listen for values\n     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two\n     * following ways.\n     *\n     * The first way is creating an object that implements {@link Observer} interface. It should have methods\n     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create\n     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do\n     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also\n     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't\n     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will\n     * be left uncaught.\n     *\n     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.\n     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent\n     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,\n     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,\n     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes\n     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.\n     *\n     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.\n     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean\n     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback\n     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.\n     *\n     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.\n     * It is an Observable itself that decides when these functions will be called. For example {@link of}\n     * by default emits all its values synchronously. Always check documentation for how given Observable\n     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.\n     *\n     * @example <caption>Subscribe with an Observer</caption>\n     * const sumObserver = {\n     *   sum: 0,\n     *   next(value) {\n     *     console.log('Adding: ' + value);\n     *     this.sum = this.sum + value;\n     *   },\n     *   error() { // We actually could just remove this method,\n     *   },        // since we do not really care about errors right now.\n     *   complete() {\n     *     console.log('Sum equals: ' + this.sum);\n     *   }\n     * };\n     *\n     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.\n     * .subscribe(sumObserver);\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Subscribe with functions</caption>\n     * let sum = 0;\n     *\n     * Rx.Observable.of(1, 2, 3)\n     * .subscribe(\n     *   function(value) {\n     *     console.log('Adding: ' + value);\n     *     sum = sum + value;\n     *   },\n     *   undefined,\n     *   function() {\n     *     console.log('Sum equals: ' + sum);\n     *   }\n     * );\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Cancel a subscription</caption>\n     * const subscription = Rx.Observable.interval(1000).subscribe(\n     *   num => console.log(num),\n     *   undefined,\n     *   () => console.log('completed!') // Will not be called, even\n     * );                                // when cancelling subscription\n     *\n     *\n     * setTimeout(() => {\n     *   subscription.unsubscribe();\n     *   console.log('unsubscribed!');\n     * }, 2500);\n     *\n     * // Logs:\n     * // 0 after 1s\n     * // 1 after 2s\n     * // \"unsubscribed!\" after 2.5s\n     *\n     *\n     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,\n     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed\n     *  Observable.\n     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,\n     *  the error will be thrown as unhandled.\n     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.\n     * @return {ISubscription} a subscription reference to the registered handlers\n     * @method subscribe\n     */\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            operator.call(sink, this.source);\n        }\n        else {\n            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));\n        }\n        if (sink.syncErrorThrowable) {\n            sink.syncErrorThrowable = false;\n            if (sink.syncErrorThrown) {\n                throw sink.syncErrorValue;\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            sink.syncErrorThrown = true;\n            sink.syncErrorValue = err;\n            sink.error(err);\n        }\n    };\n    /**\n     * @method forEach\n     * @param {Function} next a handler for each value emitted by the observable\n     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise\n     * @return {Promise} a promise that either resolves on observable completion or\n     *  rejects with the handled error\n     */\n    Observable.prototype.forEach = function (next, PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            // Must be declared in a separate statement to avoid a RefernceError when\n            // accessing subscription below in the closure due to Temporal Dead Zone.\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                if (subscription) {\n                    // if there is a subscription, then we can surmise\n                    // the next handling is asynchronous. Any errors thrown\n                    // need to be rejected explicitly and unsubscribe must be\n                    // called manually\n                    try {\n                        next(value);\n                    }\n                    catch (err) {\n                        reject(err);\n                        subscription.unsubscribe();\n                    }\n                }\n                else {\n                    // if there is NO subscription, then we're getting a nexted\n                    // value synchronously during subscription. We can just call it.\n                    // If it errors, Observable's `subscribe` will ensure the\n                    // unsubscription logic is called, then synchronously rethrow the error.\n                    // After that, Promise will trap the error and send it\n                    // down the rejection path.\n                    next(value);\n                }\n            }, reject, resolve);\n        });\n    };\n    Observable.prototype._subscribe = function (subscriber) {\n        return this.source.subscribe(subscriber);\n    };\n    /**\n     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable\n     * @method Symbol.observable\n     * @return {Observable} this instance of the observable\n     */\n    Observable.prototype[observable_1.observable] = function () {\n        return this;\n    };\n    /* tslint:enable:max-line-length */\n    /**\n     * Used to stitch together functional operators into a chain.\n     * @method pipe\n     * @return {Observable} the Observable result of all of the operators having\n     * been called in the order they were passed in.\n     *\n     * @example\n     *\n     * import { map, filter, scan } from 'rxjs/operators';\n     *\n     * Rx.Observable.interval(1000)\n     *   .pipe(\n     *     filter(x => x % 2 === 0),\n     *     map(x => x + x),\n     *     scan((acc, x) => acc + x)\n     *   )\n     *   .subscribe(x => console.log(x))\n     */\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i - 0] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipe_1.pipeFromArray(operations)(this);\n    };\n    /* tslint:enable:max-line-length */\n    Observable.prototype.toPromise = function (PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    // HACK: Since TypeScript inherits static properties too, we have to\n    // fight against TypeScript here so Subject can have a different static create signature\n    /**\n     * Creates a new cold Observable by calling the Observable constructor\n     * @static true\n     * @owner Observable\n     * @method create\n     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor\n     * @return {Observable} a new cold observable\n     */\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Observable.js\n// module id = 1\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nexports.map = map;\nvar MapOperator = (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexports.MapOperator = MapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapSubscriber = (function (_super) {\n    __extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        _super.call(this, destination);\n        this.project = project;\n        this.count = 0;\n        this.thisArg = thisArg || this;\n    }\n    // NOTE: This looks unoptimized, but it's actually purposefully NOT\n    // using try/catch optimizations.\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=map.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/map.js\n// module id = 2\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isFunction_1 = require('./util/isFunction');\nvar Subscription_1 = require('./Subscription');\nvar Observer_1 = require('./Observer');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber<T>\n */\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    /**\n     * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n     * defined Observer or a `next` callback function.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     */\n    function Subscriber(destinationOrNext, error, complete) {\n        _super.call(this);\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = Observer_1.empty;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = Observer_1.empty;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    if (destinationOrNext instanceof Subscriber) {\n                        this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n                        this.destination = destinationOrNext;\n                        this.destination.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };\n    /**\n     * A static factory for a Subscriber, given a (potentially partial) definition\n     * of an Observer.\n     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)\n     * Observer represented by the given arguments.\n     */\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `next` from\n     * the Observable, with a value. The Observable may call this method 0 or more\n     * times.\n     * @param {T} [value] The `next` value.\n     * @return {void}\n     */\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `error` from\n     * the Observable, with an attached {@link Error}. Notifies the Observer that\n     * the Observable has experienced an error condition.\n     * @param {any} [err] The `error` exception.\n     * @return {void}\n     */\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive a valueless notification of type\n     * `complete` from the Observable. Notifies the Observer that the Observable\n     * has finished sending push-based notifications.\n     * @return {void}\n     */\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        this._parent = null;\n        this._parents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parent = _parent;\n        this._parents = _parents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        _super.call(this);\n        this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = this;\n        if (isFunction_1.isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== Observer_1.empty) {\n                context = Object.create(observerOrNext);\n                if (isFunction_1.isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._error) {\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                throw err;\n            }\n            else {\n                _parentSubscriber.syncErrorValue = err;\n                _parentSubscriber.syncErrorThrown = true;\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            throw err;\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            parent.syncErrorValue = err;\n            parent.syncErrorThrown = true;\n            return true;\n        }\n        return false;\n    };\n    SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\n//# sourceMappingURL=Subscriber.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Subscriber.js\n// module id = 3\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return function filterOperatorFunction(source) {\n        return source.lift(new FilterOperator(predicate, thisArg));\n    };\n}\nexports.filter = filter;\nvar FilterOperator = (function () {\n    function FilterOperator(predicate, thisArg) {\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n    }\n    FilterOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));\n    };\n    return FilterOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar FilterSubscriber = (function (_super) {\n    __extends(FilterSubscriber, _super);\n    function FilterSubscriber(destination, predicate, thisArg) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n        this.count = 0;\n    }\n    // the try catch block below is left specifically for\n    // optimization and perf reasons. a tryCatcher is not necessary here.\n    FilterSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.predicate.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.destination.next(value);\n        }\n    };\n    return FilterSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=filter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/filter.js\n// module id = 4\n// module chunks = 0","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//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 5\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @name tap\n */\nfunction tap(nextOrObserver, error, complete) {\n    return function tapOperatorFunction(source) {\n        return source.lift(new DoOperator(nextOrObserver, error, complete));\n    };\n}\nexports.tap = tap;\nvar DoOperator = (function () {\n    function DoOperator(nextOrObserver, error, complete) {\n        this.nextOrObserver = nextOrObserver;\n        this.error = error;\n        this.complete = complete;\n    }\n    DoOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DoSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));\n    };\n    return DoOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DoSubscriber = (function (_super) {\n    __extends(DoSubscriber, _super);\n    function DoSubscriber(destination, nextOrObserver, error, complete) {\n        _super.call(this, destination);\n        var safeSubscriber = new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n        safeSubscriber.syncErrorThrowable = true;\n        this.add(safeSubscriber);\n        this.safeSubscriber = safeSubscriber;\n    }\n    DoSubscriber.prototype._next = function (value) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.next(value);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.next(value);\n        }\n    };\n    DoSubscriber.prototype._error = function (err) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.error(err);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.error(err);\n        }\n    };\n    DoSubscriber.prototype._complete = function () {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.complete();\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    return DoSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=tap.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/tap.js\n// module id = 6\n// module chunks = 0","\"use strict\";\nvar map_1 = require('./map');\n/**\n * Maps each source value (an object) to its specified nested property.\n *\n * <span class=\"informal\">Like {@link map}, but meant only for picking one of\n * the nested properties of every emitted object.</span>\n *\n * <img src=\"./img/pluck.png\" width=\"100%\">\n *\n * Given a list of strings describing a path to an object property, retrieves\n * the value of a specified nested property from all values in the source\n * Observable. If a property can't be resolved, it will return `undefined` for\n * that value.\n *\n * @example <caption>Map every click to the tagName of the clicked target element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var tagNames = clicks.pluck('target', 'tagName');\n * tagNames.subscribe(x => console.log(x));\n *\n * @see {@link map}\n *\n * @param {...string} properties The nested properties to pluck from each source\n * value (an object).\n * @return {Observable} A new Observable of property values from the source values.\n * @method pluck\n * @owner Observable\n */\nfunction pluck() {\n    var properties = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        properties[_i - 0] = arguments[_i];\n    }\n    var length = properties.length;\n    if (length === 0) {\n        throw new Error('list of properties cannot be empty.');\n    }\n    return function (source) { return map_1.map(plucker(properties, length))(source); };\n}\nexports.pluck = pluck;\nfunction plucker(props, length) {\n    var mapper = function (x) {\n        var currentProp = x;\n        for (var i = 0; i < length; i++) {\n            var p = currentProp[props[i]];\n            if (typeof p !== 'undefined') {\n                currentProp = p;\n            }\n            else {\n                return undefined;\n            }\n        }\n        return currentProp;\n    };\n    return mapper;\n}\n//# sourceMappingURL=pluck.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/pluck.js\n// module id = 7\n// module chunks = 0","\"use strict\";\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _root = __window || __global || __self;\nexports.root = _root;\n// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.\n// This is needed when used with angular/tsickle which inserts a goog.module statement.\n// Wrap in IIFE\n(function () {\n    if (!_root) {\n        throw new Error('RxJS could not find any global context (window, self, global)');\n    }\n})();\n//# sourceMappingURL=root.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/root.js\n// module id = 8\n// module chunks = 0","import { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { setOptionsEffect } from \"./effects/set-options.effect\";\nimport { fileReloadEffect } from \"./effects/file-reload.effect\";\nimport { browserSetLocationEffect } from \"./effects/browser-set-location.effect\";\nimport { simulateClickEffect } from \"./effects/simulate-click.effect\";\nimport { setElementValueEffect } from \"./effects/set-element-value.effect\";\nimport { setElementToggleValueEffect } from \"./effects/set-element-toggle-value.effect\";\nimport { setScrollEffect } from \"./effects/set-scroll\";\nimport { browserReloadEffect } from \"./effects/browser-reload.effect\";\n\nexport enum EffectNames {\n    FileReload = \"@@FileReload\",\n    PreBrowserReload = \"@@PreBrowserReload\",\n    BrowserReload = \"@@BrowserReload\",\n    BrowserSetLocation = \"@@BrowserSetLocation\",\n    BrowserSetScroll = \"@@BrowserSetScroll\",\n    SetOptions = \"@@SetOptions\",\n    SimulateClick = \"@@SimulateClick\",\n    SetElementValue = \"@@SetElementValue\",\n    SetElementToggleValue = \"@@SetElementToggleValue\"\n}\n\nexport const effectOutputHandlers$ = new BehaviorSubject({\n    [EffectNames.SetOptions]: setOptionsEffect,\n    [EffectNames.FileReload]: fileReloadEffect,\n    [EffectNames.BrowserReload]: browserReloadEffect,\n    [EffectNames.BrowserSetLocation]: browserSetLocationEffect,\n    [EffectNames.SimulateClick]: simulateClickEffect,\n    [EffectNames.SetElementValue]: setElementValueEffect,\n    [EffectNames.SetElementToggleValue]: setElementToggleValueEffect,\n    [EffectNames.BrowserSetScroll]: setScrollEffect\n});\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects.ts","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (!r && typeof process !== 'undefined' && 'env' in process) {\n    r = process.env.DEBUG;\n  }\n\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/debug/src/browser.js\n// module id = 10\n// module chunks = 0","\"use strict\";\nvar ArrayObservable_1 = require('./ArrayObservable');\nexports.of = ArrayObservable_1.ArrayObservable.of;\n//# sourceMappingURL=of.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/of.js\n// module id = 11\n// module chunks = 0","import { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { incomingScrollHandler } from \"./messages/ScrollEvent\";\nimport { incomingHandler$ } from \"./messages/ClickEvent\";\nimport { incomingKeyupHandler } from \"./messages/KeyupEvent\";\nimport { incomingBrowserNotify } from \"./messages/BrowserNotify\";\nimport { incomingBrowserLocation } from \"./messages/BrowserLocation\";\nimport { incomingBrowserReload } from \"./messages/BrowserReload\";\nimport { incomingFileReload } from \"./messages/FileReload\";\nimport { incomingConnection } from \"./messages/Connection\";\nimport { incomingDisconnect } from \"./messages/Disconnect\";\nimport { incomingInputsToggles } from \"./messages/FormToggleEvent\";\nimport { incomingOptionsSet } from \"./messages/OptionsSet\";\n\nexport enum IncomingSocketNames {\n    Connection = \"connection\",\n    Disconnect = \"disconnect\",\n    FileReload = \"file:reload\",\n    BrowserReload = \"browser:reload\",\n    BrowserLocation = \"browser:location\",\n    BrowserNotify = \"browser:notify\",\n    Scroll = \"scroll\",\n    Click = \"click\",\n    Keyup = \"input:text\",\n    InputToggle = \"input:toggles\",\n    OptionsSet = \"options:set\"\n}\n\nexport enum OutgoingSocketEvents {\n    Scroll = \"@@outgoing/scroll\",\n    Click = \"@@outgoing/click\",\n    Keyup = \"@@outgoing/keyup\",\n    InputToggle = \"@@outgoing/Toggle\"\n}\n\nexport type SocketEvent = [IncomingSocketNames, any];\nexport type OutgoingSocketEvent = [OutgoingSocketEvents, any];\n\nexport const socketHandlers$ = new BehaviorSubject({\n    [IncomingSocketNames.Connection]: incomingConnection,\n    [IncomingSocketNames.Disconnect]: incomingDisconnect,\n    [IncomingSocketNames.FileReload]: incomingFileReload,\n    [IncomingSocketNames.BrowserReload]: incomingBrowserReload,\n    [IncomingSocketNames.BrowserLocation]: incomingBrowserLocation,\n    [IncomingSocketNames.BrowserNotify]: incomingBrowserNotify,\n    [IncomingSocketNames.Scroll]: incomingScrollHandler,\n    [IncomingSocketNames.Click]: incomingHandler$,\n    [IncomingSocketNames.Keyup]: incomingKeyupHandler,\n    [IncomingSocketNames.InputToggle]: incomingInputsToggles,\n    [IncomingSocketNames.OptionsSet]: incomingOptionsSet,\n    [OutgoingSocketEvents.Scroll]: emitWithPathname(IncomingSocketNames.Scroll),\n    [OutgoingSocketEvents.Click]: emitWithPathname(IncomingSocketNames.Click),\n    [OutgoingSocketEvents.Keyup]: emitWithPathname(IncomingSocketNames.Keyup),\n    [OutgoingSocketEvents.InputToggle]: emitWithPathname(\n        IncomingSocketNames.InputToggle\n    )\n});\n\nfunction emitWithPathname(name) {\n    return function(xs, inputs) {\n        return xs.pipe(\n            withLatestFrom(\n                inputs.io$,\n                inputs.window$.pipe(pluck(\"location\", \"pathname\"))\n            ),\n            tap(([event, io, pathname]) =>\n                io.emit(name, { ...event, pathname })\n            ),\n            ignoreElements()\n        );\n    };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/socket-messages.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar noop_1 = require('../util/noop');\n/**\n * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.\n *\n * <img src=\"./img/ignoreElements.png\" width=\"100%\">\n *\n * @return {Observable} An empty Observable that only calls `complete`\n * or `error`, based on which one is called by the source Observable.\n * @method ignoreElements\n * @owner Observable\n */\nfunction ignoreElements() {\n    return function ignoreElementsOperatorFunction(source) {\n        return source.lift(new IgnoreElementsOperator());\n    };\n}\nexports.ignoreElements = ignoreElements;\nvar IgnoreElementsOperator = (function () {\n    function IgnoreElementsOperator() {\n    }\n    IgnoreElementsOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new IgnoreElementsSubscriber(subscriber));\n    };\n    return IgnoreElementsOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar IgnoreElementsSubscriber = (function (_super) {\n    __extends(IgnoreElementsSubscriber, _super);\n    function IgnoreElementsSubscriber() {\n        _super.apply(this, arguments);\n    }\n    IgnoreElementsSubscriber.prototype._next = function (unused) {\n        noop_1.noop();\n    };\n    return IgnoreElementsSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ignoreElements.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/ignoreElements.js\n// module id = 13\n// module chunks = 0","\"use strict\";\nvar isArray_1 = require('./util/isArray');\nvar isObject_1 = require('./util/isObject');\nvar isFunction_1 = require('./util/isFunction');\nvar tryCatch_1 = require('./util/tryCatch');\nvar errorObject_1 = require('./util/errorObject');\nvar UnsubscriptionError_1 = require('./util/UnsubscriptionError');\n/**\n * Represents a disposable resource, such as the execution of an Observable. A\n * Subscription has one important method, `unsubscribe`, that takes no argument\n * and just disposes the resource held by the subscription.\n *\n * Additionally, subscriptions may be grouped together through the `add()`\n * method, which will attach a child Subscription to the current Subscription.\n * When a Subscription is unsubscribed, all its children (and its grandchildren)\n * will be unsubscribed as well.\n *\n * @class Subscription\n */\nvar Subscription = (function () {\n    /**\n     * @param {function(): void} [unsubscribe] A function describing how to\n     * perform the disposal of resources when the `unsubscribe` method is called.\n     */\n    function Subscription(unsubscribe) {\n        /**\n         * A flag to indicate whether this Subscription has already been unsubscribed.\n         * @type {boolean}\n         */\n        this.closed = false;\n        this._parent = null;\n        this._parents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    /**\n     * Disposes the resources held by the subscription. May, for instance, cancel\n     * an ongoing Observable execution or cancel any other type of work that\n     * started when the Subscription was created.\n     * @return {void}\n     */\n    Subscription.prototype.unsubscribe = function () {\n        var hasErrors = false;\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parent = null;\n        this._parents = null;\n        // null out _subscriptions first so any child subscriptions that attempt\n        // to remove themselves from this subscription will noop\n        this._subscriptions = null;\n        var index = -1;\n        var len = _parents ? _parents.length : 0;\n        // if this._parent is null, then so is this._parents, and we\n        // don't have to remove ourselves from any parent subscriptions.\n        while (_parent) {\n            _parent.remove(this);\n            // if this._parents is null or index >= len,\n            // then _parent is set to null, and the loop exits\n            _parent = ++index < len && _parents[index] || null;\n        }\n        if (isFunction_1.isFunction(_unsubscribe)) {\n            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);\n            if (trial === errorObject_1.errorObject) {\n                hasErrors = true;\n                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?\n                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);\n            }\n        }\n        if (isArray_1.isArray(_subscriptions)) {\n            index = -1;\n            len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject_1.isObject(sub)) {\n                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);\n                    if (trial === errorObject_1.errorObject) {\n                        hasErrors = true;\n                        errors = errors || [];\n                        var err = errorObject_1.errorObject.e;\n                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));\n                        }\n                        else {\n                            errors.push(err);\n                        }\n                    }\n                }\n            }\n        }\n        if (hasErrors) {\n            throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n        }\n    };\n    /**\n     * Adds a tear down to be called during the unsubscribe() of this\n     * Subscription.\n     *\n     * If the tear down being added is a subscription that is already\n     * unsubscribed, is the same reference `add` is being called on, or is\n     * `Subscription.EMPTY`, it will not be added.\n     *\n     * If this subscription is already in an `closed` state, the passed\n     * tear down logic will be executed immediately.\n     *\n     * @param {TeardownLogic} teardown The additional logic to execute on\n     * teardown.\n     * @return {Subscription} Returns the Subscription used or created to be\n     * added to the inner subscriptions list. This Subscription can be used with\n     * `remove()` to remove the passed teardown logic from the inner subscriptions\n     * list.\n     */\n    Subscription.prototype.add = function (teardown) {\n        if (!teardown || (teardown === Subscription.EMPTY)) {\n            return Subscription.EMPTY;\n        }\n        if (teardown === this) {\n            return this;\n        }\n        var subscription = teardown;\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (typeof subscription._addParent !== 'function' /* quack quack */) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default:\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n        }\n        var subscriptions = this._subscriptions || (this._subscriptions = []);\n        subscriptions.push(subscription);\n        subscription._addParent(this);\n        return subscription;\n    };\n    /**\n     * Removes a Subscription from the internal list of subscriptions that will\n     * unsubscribe during the unsubscribe process of this Subscription.\n     * @param {Subscription} subscription The subscription to remove.\n     * @return {void}\n     */\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        if (!_parent || _parent === parent) {\n            // If we don't have a parent, or the new parent is the same as the\n            // current parent, then set this._parent to the new parent.\n            this._parent = parent;\n        }\n        else if (!_parents) {\n            // If there's already one parent, but not multiple, allocate an Array to\n            // store the rest of the parent Subscriptions.\n            this._parents = [parent];\n        }\n        else if (_parents.indexOf(parent) === -1) {\n            // Only add the new parent to the _parents list if it's not already there.\n            _parents.push(parent);\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Subscription.js\n// module id = 14\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('./Subject');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\n/**\n * @class BehaviorSubject<T>\n */\nvar BehaviorSubject = (function (_super) {\n    __extends(BehaviorSubject, _super);\n    function BehaviorSubject(_value) {\n        _super.call(this);\n        this._value = _value;\n    }\n    Object.defineProperty(BehaviorSubject.prototype, \"value\", {\n        get: function () {\n            return this.getValue();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    BehaviorSubject.prototype._subscribe = function (subscriber) {\n        var subscription = _super.prototype._subscribe.call(this, subscriber);\n        if (subscription && !subscription.closed) {\n            subscriber.next(this._value);\n        }\n        return subscription;\n    };\n    BehaviorSubject.prototype.getValue = function () {\n        if (this.hasError) {\n            throw this.thrownError;\n        }\n        else if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return this._value;\n        }\n    };\n    BehaviorSubject.prototype.next = function (value) {\n        _super.prototype.next.call(this, this._value = value);\n    };\n    return BehaviorSubject;\n}(Subject_1.Subject));\nexports.BehaviorSubject = BehaviorSubject;\n//# sourceMappingURL=BehaviorSubject.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/BehaviorSubject.js\n// module id = 15\n// module chunks = 0","import { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { timer } from \"rxjs/observable/timer\";\nimport { Observable } from \"rxjs/Observable\";\nimport { of } from \"rxjs/observable/of\";\nimport { Nanologger } from \"../vendor/logger\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { Inputs } from \"./index\";\nimport { pluck } from \"rxjs/operators/pluck\";\n\nexport function initLogger(options: IBrowserSyncOptions) {\n    const log = new Nanologger(options.logPrefix, {\n        colors: { magenta: \"#0F2634\" }\n    });\n    return of(log);\n}\n\nexport enum LogNames {\n    Log = \"@@Log\",\n    Info = \"@@Log.info\",\n    Debug = \"@@Log.debug\"\n}\n\nexport enum Overlay {\n    Info = \"@@Overlay.info\"\n}\n\nexport type ConsolePayload = [LogNames, any[]];\n\nexport function consoleInfo(...args): [LogNames.Log, ConsolePayload] {\n    return [LogNames.Log, [LogNames.Info, args]];\n}\n\nexport function consoleDebug(...args): [LogNames.Log, ConsolePayload] {\n    return [LogNames.Log, [LogNames.Debug, args]];\n}\n\nexport type OverlayInfoPayload = [string, number];\n\nexport function overlayInfo(\n    message: string,\n    timeout = 2000\n): [Overlay.Info, OverlayInfoPayload] {\n    return [Overlay.Info, [message, timeout]];\n}\n\nexport const logHandler$ = new BehaviorSubject({\n    [LogNames.Log]: (xs: Observable<[LogNames, any]>, inputs: Inputs) => {\n        return xs.pipe(\n            /**\n             * access injectNotification from the options stream\n             */\n            withLatestFrom(\n                inputs.logInstance$,\n                inputs.option$.pipe(pluck(\"injectNotification\"))\n            ),\n            /**\n             * only accept messages if injectNotification !== console\n             */\n            filter(\n                ([, , injectNotification]) => injectNotification === \"console\"\n            ),\n            tap(([event, log]) => {\n                switch (event[0]) {\n                    case LogNames.Info: {\n                        return log.info.apply(log, event[1]);\n                    }\n                    case LogNames.Debug: {\n                        return log.debug.apply(log, event[1]);\n                    }\n                }\n            })\n        );\n    },\n    [Overlay.Info]: (xs: Observable<[LogNames, any]>, inputs: Inputs) => {\n        return xs.pipe(\n            withLatestFrom(\n                inputs.option$,\n                inputs.notifyElement$,\n                inputs.document$\n            ),\n            /**\n             * Reject all notifications if notify: false\n             */\n            filter(([, options]) => Boolean(options.notify)),\n            /**\n             * Set the HTML of the notify element\n             */\n            tap(([event, options, element, document]) => {\n                element.innerHTML = event[0];\n                element.style.display = \"block\";\n                document.body.appendChild(element);\n            }),\n            /**\n             * Now remove the element after the given timeout\n             */\n            switchMap(([event, options, element, document]) => {\n                return timer(event[1] || 2000).pipe(\n                    tap(() => {\n                        element.style.display = \"none\";\n                        if (element.parentNode) {\n                            document.body.removeChild(element);\n                        }\n                    })\n                );\n            })\n        );\n    }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./lib/log.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return function mergeMapOperatorFunction(source) {\n        if (typeof resultSelector === 'number') {\n            concurrent = resultSelector;\n            resultSelector = null;\n        }\n        return source.lift(new MergeMapOperator(project, resultSelector, concurrent));\n    };\n}\nexports.mergeMap = mergeMap;\nvar MergeMapOperator = (function () {\n    function MergeMapOperator(project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n    }\n    MergeMapOperator.prototype.call = function (observer, source) {\n        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent));\n    };\n    return MergeMapOperator;\n}());\nexports.MergeMapOperator = MergeMapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MergeMapSubscriber = (function (_super) {\n    __extends(MergeMapSubscriber, _super);\n    function MergeMapSubscriber(destination, project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n        this.hasCompleted = false;\n        this.buffer = [];\n        this.active = 0;\n        this.index = 0;\n    }\n    MergeMapSubscriber.prototype._next = function (value) {\n        if (this.active < this.concurrent) {\n            this._tryNext(value);\n        }\n        else {\n            this.buffer.push(value);\n        }\n    };\n    MergeMapSubscriber.prototype._tryNext = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.active++;\n        this._innerSub(result, value, index);\n    };\n    MergeMapSubscriber.prototype._innerSub = function (ish, value, index) {\n        this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index));\n    };\n    MergeMapSubscriber.prototype._complete = function () {\n        this.hasCompleted = true;\n        if (this.active === 0 && this.buffer.length === 0) {\n            this.destination.complete();\n        }\n    };\n    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    MergeMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var buffer = this.buffer;\n        this.remove(innerSub);\n        this.active--;\n        if (buffer.length > 0) {\n            this._next(buffer.shift());\n        }\n        else if (this.active === 0 && this.hasCompleted) {\n            this.destination.complete();\n        }\n    };\n    return MergeMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.MergeMapSubscriber = MergeMapSubscriber;\n//# sourceMappingURL=mergeMap.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/mergeMap.js\n// module id = 17\n// module chunks = 0","\"use strict\";\nvar EmptyObservable_1 = require('./EmptyObservable');\nexports.empty = EmptyObservable_1.EmptyObservable.create;\n//# sourceMappingURL=empty.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/empty.js\n// module id = 18\n// module chunks = 0","\r\n/**\r\n * Expose `Emitter`.\r\n */\r\n\r\nif (typeof module !== 'undefined') {\r\n  module.exports = Emitter;\r\n}\r\n\r\n/**\r\n * Initialize a new `Emitter`.\r\n *\r\n * @api public\r\n */\r\n\r\nfunction Emitter(obj) {\r\n  if (obj) return mixin(obj);\r\n};\r\n\r\n/**\r\n * Mixin the emitter properties.\r\n *\r\n * @param {Object} obj\r\n * @return {Object}\r\n * @api private\r\n */\r\n\r\nfunction mixin(obj) {\r\n  for (var key in Emitter.prototype) {\r\n    obj[key] = Emitter.prototype[key];\r\n  }\r\n  return obj;\r\n}\r\n\r\n/**\r\n * Listen on the given `event` with `fn`.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.on =\r\nEmitter.prototype.addEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n    .push(fn);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Adds an `event` listener that will be invoked a single\r\n * time then automatically removed.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.once = function(event, fn){\r\n  function on() {\r\n    this.off(event, on);\r\n    fn.apply(this, arguments);\r\n  }\r\n\r\n  on.fn = fn;\r\n  this.on(event, on);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove the given callback for `event` or all\r\n * registered callbacks.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.off =\r\nEmitter.prototype.removeListener =\r\nEmitter.prototype.removeAllListeners =\r\nEmitter.prototype.removeEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n\r\n  // all\r\n  if (0 == arguments.length) {\r\n    this._callbacks = {};\r\n    return this;\r\n  }\r\n\r\n  // specific event\r\n  var callbacks = this._callbacks['$' + event];\r\n  if (!callbacks) return this;\r\n\r\n  // remove all handlers\r\n  if (1 == arguments.length) {\r\n    delete this._callbacks['$' + event];\r\n    return this;\r\n  }\r\n\r\n  // remove specific handler\r\n  var cb;\r\n  for (var i = 0; i < callbacks.length; i++) {\r\n    cb = callbacks[i];\r\n    if (cb === fn || cb.fn === fn) {\r\n      callbacks.splice(i, 1);\r\n      break;\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Emit `event` with the given args.\r\n *\r\n * @param {String} event\r\n * @param {Mixed} ...\r\n * @return {Emitter}\r\n */\r\n\r\nEmitter.prototype.emit = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  var args = [].slice.call(arguments, 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  if (callbacks) {\r\n    callbacks = callbacks.slice(0);\r\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n      callbacks[i].apply(this, args);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return array of callbacks for `event`.\r\n *\r\n * @param {String} event\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.listeners = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  return this._callbacks['$' + event] || [];\r\n};\r\n\r\n/**\r\n * Check if this emitter has `event` handlers.\r\n *\r\n * @param {String} event\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.hasListeners = function(event){\r\n  return !! this.listeners(event).length;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/component-emitter/index.js\n// module id = 19\n// module chunks = 0","/**\n * Module dependencies.\n */\n\nvar keys = require('./keys');\nvar hasBinary = require('has-binary2');\nvar sliceBuffer = require('arraybuffer.slice');\nvar after = require('after');\nvar utf8 = require('./utf8');\n\nvar base64encoder;\nif (global && global.ArrayBuffer) {\n  base64encoder = require('base64-arraybuffer');\n}\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n    open:     0    // non-ws\n  , close:    1    // non-ws\n  , ping:     2\n  , pong:     3\n  , message:  4\n  , upgrade:  5\n  , noop:     6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = require('blob');\n\n/**\n * Encodes a packet.\n *\n *     <packet type id> [ <data> ]\n *\n * Example:\n *\n *     5hello world\n *     3\n *     4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = false;\n  }\n\n  if (typeof utf8encode === 'function') {\n    callback = utf8encode;\n    utf8encode = null;\n  }\n\n  var data = (packet.data === undefined)\n    ? undefined\n    : packet.data.buffer || packet.data;\n\n  if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n    return encodeArrayBuffer(packet, supportsBinary, callback);\n  } else if (Blob && data instanceof global.Blob) {\n    return encodeBlob(packet, supportsBinary, callback);\n  }\n\n  // might be an object with { base64: true, data: dataAsBase64String }\n  if (data && data.base64) {\n    return encodeBase64Object(packet, callback);\n  }\n\n  // Sending data as a utf-8 string\n  var encoded = packets[packet.type];\n\n  // data fragment is optional\n  if (undefined !== packet.data) {\n    encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);\n  }\n\n  return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n  // packet data is an object { base64: true, data: dataAsBase64String }\n  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n  return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var data = packet.data;\n  var contentArray = new Uint8Array(data);\n  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n  resultBuffer[0] = packets[packet.type];\n  for (var i = 0; i < contentArray.length; i++) {\n    resultBuffer[i+1] = contentArray[i];\n  }\n\n  return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var fr = new FileReader();\n  fr.onload = function() {\n    packet.data = fr.result;\n    exports.encodePacket(packet, supportsBinary, true, callback);\n  };\n  return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  if (dontSendBlobs) {\n    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n  }\n\n  var length = new Uint8Array(1);\n  length[0] = packets[packet.type];\n  var blob = new Blob([length.buffer, packet.data]);\n\n  return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n  var message = 'b' + exports.packets[packet.type];\n  if (Blob && packet.data instanceof global.Blob) {\n    var fr = new FileReader();\n    fr.onload = function() {\n      var b64 = fr.result.split(',')[1];\n      callback(message + b64);\n    };\n    return fr.readAsDataURL(packet.data);\n  }\n\n  var b64data;\n  try {\n    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n  } catch (e) {\n    // iPhone Safari doesn't let you apply with typed arrays\n    var typed = new Uint8Array(packet.data);\n    var basic = new Array(typed.length);\n    for (var i = 0; i < typed.length; i++) {\n      basic[i] = typed[i];\n    }\n    b64data = String.fromCharCode.apply(null, basic);\n  }\n  message += global.btoa(b64data);\n  return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n  if (data === undefined) {\n    return err;\n  }\n  // String data\n  if (typeof data === 'string') {\n    if (data.charAt(0) === 'b') {\n      return exports.decodeBase64Packet(data.substr(1), binaryType);\n    }\n\n    if (utf8decode) {\n      data = tryDecode(data);\n      if (data === false) {\n        return err;\n      }\n    }\n    var type = data.charAt(0);\n\n    if (Number(type) != type || !packetslist[type]) {\n      return err;\n    }\n\n    if (data.length > 1) {\n      return { type: packetslist[type], data: data.substring(1) };\n    } else {\n      return { type: packetslist[type] };\n    }\n  }\n\n  var asArray = new Uint8Array(data);\n  var type = asArray[0];\n  var rest = sliceBuffer(data, 1);\n  if (Blob && binaryType === 'blob') {\n    rest = new Blob([rest]);\n  }\n  return { type: packetslist[type], data: rest };\n};\n\nfunction tryDecode(data) {\n  try {\n    data = utf8.decode(data, { strict: false });\n  } catch (e) {\n    return false;\n  }\n  return data;\n}\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n  var type = packetslist[msg.charAt(0)];\n  if (!base64encoder) {\n    return { type: type, data: { base64: true, data: msg.substr(1) } };\n  }\n\n  var data = base64encoder.decode(msg.substr(1));\n\n  if (binaryType === 'blob' && Blob) {\n    data = new Blob([data]);\n  }\n\n  return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n *     <length>:data\n *\n * Example:\n *\n *     11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = null;\n  }\n\n  var isBinary = hasBinary(packets);\n\n  if (supportsBinary && isBinary) {\n    if (Blob && !dontSendBlobs) {\n      return exports.encodePayloadAsBlob(packets, callback);\n    }\n\n    return exports.encodePayloadAsArrayBuffer(packets, callback);\n  }\n\n  if (!packets.length) {\n    return callback('0:');\n  }\n\n  function setLengthHeader(message) {\n    return message.length + ':' + message;\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, !isBinary ? false : supportsBinary, false, function(message) {\n      doneCallback(null, setLengthHeader(message));\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(results.join(''));\n  });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n  var result = new Array(ary.length);\n  var next = after(ary.length, done);\n\n  var eachWithIndex = function(i, el, cb) {\n    each(el, function(error, msg) {\n      result[i] = msg;\n      cb(error, result);\n    });\n  };\n\n  for (var i = 0; i < ary.length; i++) {\n    eachWithIndex(i, ary[i], next);\n  }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n  if (typeof data !== 'string') {\n    return exports.decodePayloadAsBinary(data, binaryType, callback);\n  }\n\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var packet;\n  if (data === '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n  var length = '', n, msg;\n\n  for (var i = 0, l = data.length; i < l; i++) {\n    var chr = data.charAt(i);\n\n    if (chr !== ':') {\n      length += chr;\n      continue;\n    }\n\n    if (length === '' || (length != (n = Number(length)))) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    msg = data.substr(i + 1, n);\n\n    if (length != msg.length) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    if (msg.length) {\n      packet = exports.decodePacket(msg, binaryType, false);\n\n      if (err.type === packet.type && err.data === packet.data) {\n        // parser error in individual packet - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      var ret = callback(packet, i + n, l);\n      if (false === ret) return;\n    }\n\n    // advance cursor\n    i += n;\n    length = '';\n  }\n\n  if (length !== '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n  if (!packets.length) {\n    return callback(new ArrayBuffer(0));\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(data) {\n      return doneCallback(null, data);\n    });\n  }\n\n  map(packets, encodeOne, function(err, encodedPackets) {\n    var totalLength = encodedPackets.reduce(function(acc, p) {\n      var len;\n      if (typeof p === 'string'){\n        len = p.length;\n      } else {\n        len = p.byteLength;\n      }\n      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n    }, 0);\n\n    var resultArray = new Uint8Array(totalLength);\n\n    var bufferIndex = 0;\n    encodedPackets.forEach(function(p) {\n      var isString = typeof p === 'string';\n      var ab = p;\n      if (isString) {\n        var view = new Uint8Array(p.length);\n        for (var i = 0; i < p.length; i++) {\n          view[i] = p.charCodeAt(i);\n        }\n        ab = view.buffer;\n      }\n\n      if (isString) { // not true binary\n        resultArray[bufferIndex++] = 0;\n      } else { // true binary\n        resultArray[bufferIndex++] = 1;\n      }\n\n      var lenStr = ab.byteLength.toString();\n      for (var i = 0; i < lenStr.length; i++) {\n        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n      }\n      resultArray[bufferIndex++] = 255;\n\n      var view = new Uint8Array(ab);\n      for (var i = 0; i < view.length; i++) {\n        resultArray[bufferIndex++] = view[i];\n      }\n    });\n\n    return callback(resultArray.buffer);\n  });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(encoded) {\n      var binaryIdentifier = new Uint8Array(1);\n      binaryIdentifier[0] = 1;\n      if (typeof encoded === 'string') {\n        var view = new Uint8Array(encoded.length);\n        for (var i = 0; i < encoded.length; i++) {\n          view[i] = encoded.charCodeAt(i);\n        }\n        encoded = view.buffer;\n        binaryIdentifier[0] = 0;\n      }\n\n      var len = (encoded instanceof ArrayBuffer)\n        ? encoded.byteLength\n        : encoded.size;\n\n      var lenStr = len.toString();\n      var lengthAry = new Uint8Array(lenStr.length + 1);\n      for (var i = 0; i < lenStr.length; i++) {\n        lengthAry[i] = parseInt(lenStr[i]);\n      }\n      lengthAry[lenStr.length] = 255;\n\n      if (Blob) {\n        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n        doneCallback(null, blob);\n      }\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(new Blob(results));\n  });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var bufferTail = data;\n  var buffers = [];\n\n  while (bufferTail.byteLength > 0) {\n    var tailArray = new Uint8Array(bufferTail);\n    var isString = tailArray[0] === 0;\n    var msgLength = '';\n\n    for (var i = 1; ; i++) {\n      if (tailArray[i] === 255) break;\n\n      // 310 = char length of Number.MAX_VALUE\n      if (msgLength.length > 310) {\n        return callback(err, 0, 1);\n      }\n\n      msgLength += tailArray[i];\n    }\n\n    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n    msgLength = parseInt(msgLength);\n\n    var msg = sliceBuffer(bufferTail, 0, msgLength);\n    if (isString) {\n      try {\n        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n      } catch (e) {\n        // iPhone Safari doesn't let you apply to typed arrays\n        var typed = new Uint8Array(msg);\n        msg = '';\n        for (var i = 0; i < typed.length; i++) {\n          msg += String.fromCharCode(typed[i]);\n        }\n      }\n    }\n\n    buffers.push(msg);\n    bufferTail = sliceBuffer(bufferTail, msgLength);\n  }\n\n  var total = buffers.length;\n  buffers.forEach(function(buffer, i) {\n    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-parser/lib/browser.js\n// module id = 20\n// module chunks = 0","import { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { propSetDomEffect } from \"./dom-effects/prop-set.dom-effect\";\nimport { styleSetDomEffect } from \"./dom-effects/style-set.dom-effect\";\nimport { linkReplaceDomEffect } from \"./dom-effects/link-replace.dom-effect\";\nimport { setScrollDomEffect } from \"./dom-effects/set-scroll.dom-effect\";\nimport { setWindowNameDomEffect } from \"./dom-effects/set-window-name.dom-effect\";\n\nexport enum Events {\n    PropSet = \"@@BSDOM.Events.PropSet\",\n    StyleSet = \"@@BSDOM.Events.StyleSet\",\n    LinkReplace = \"@@BSDOM.Events.LinkReplace\",\n    SetScroll = \"@@BSDOM.Events.SetScroll\",\n    SetWindowName = \"@@BSDOM.Events.SetWindowName\"\n}\n\nexport const domHandlers$ = new BehaviorSubject({\n    [Events.PropSet]: propSetDomEffect,\n    [Events.StyleSet]: styleSetDomEffect,\n    [Events.LinkReplace]: linkReplaceDomEffect,\n    [Events.SetScroll]: setScrollDomEffect,\n    [Events.SetWindowName]: setWindowNameDomEffect\n});\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, emitting values only from the most recently projected Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link switch}.</span>\n *\n * <img src=\"./img/switchMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each time it observes one of these\n * inner Observables, the output Observable begins emitting the items emitted by\n * that inner Observable. When a new inner Observable is emitted, `switchMap`\n * stops emitting items from the earlier-emitted inner Observable and begins\n * emitting items from the new one. It continues to behave like this for\n * subsequent inner Observables.\n *\n * @example <caption>Rerun an interval Observable on every click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));\n * result.subscribe(x => console.log(x));\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switch}\n * @see {@link switchMapTo}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking only the values from the most recently\n * projected inner Observable.\n * @method switchMap\n * @owner Observable\n */\nfunction switchMap(project, resultSelector) {\n    return function switchMapOperatorFunction(source) {\n        return source.lift(new SwitchMapOperator(project, resultSelector));\n    };\n}\nexports.switchMap = switchMap;\nvar SwitchMapOperator = (function () {\n    function SwitchMapOperator(project, resultSelector) {\n        this.project = project;\n        this.resultSelector = resultSelector;\n    }\n    SwitchMapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new SwitchMapSubscriber(subscriber, this.project, this.resultSelector));\n    };\n    return SwitchMapOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SwitchMapSubscriber = (function (_super) {\n    __extends(SwitchMapSubscriber, _super);\n    function SwitchMapSubscriber(destination, project, resultSelector) {\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.index = 0;\n    }\n    SwitchMapSubscriber.prototype._next = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (error) {\n            this.destination.error(error);\n            return;\n        }\n        this._innerSub(result, value, index);\n    };\n    SwitchMapSubscriber.prototype._innerSub = function (result, value, index) {\n        var innerSubscription = this.innerSubscription;\n        if (innerSubscription) {\n            innerSubscription.unsubscribe();\n        }\n        this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, result, value, index));\n    };\n    SwitchMapSubscriber.prototype._complete = function () {\n        var innerSubscription = this.innerSubscription;\n        if (!innerSubscription || innerSubscription.closed) {\n            _super.prototype._complete.call(this);\n        }\n    };\n    SwitchMapSubscriber.prototype._unsubscribe = function () {\n        this.innerSubscription = null;\n    };\n    SwitchMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.remove(innerSub);\n        this.innerSubscription = null;\n        if (this.isStopped) {\n            _super.prototype._complete.call(this);\n        }\n    };\n    SwitchMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    SwitchMapSubscriber.prototype._tryNotifyNext = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return SwitchMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=switchMap.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/switchMap.js\n// module id = 22\n// module chunks = 0","import { concat } from \"rxjs/observable/concat\";\nimport { timer } from \"rxjs/observable/timer\";\nimport { of } from \"rxjs/observable/of\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { startWith } from \"rxjs/operators/startWith\";\nimport { mapTo } from \"rxjs/operators/mapTo\";\n\nexport function each(incoming) {\n    return [].slice.call(incoming || []);\n}\n\nexport const splitUrl = function(url) {\n    let hash, index, params;\n    if ((index = url.indexOf(\"#\")) >= 0) {\n        hash = url.slice(index);\n        url = url.slice(0, index);\n    } else {\n        hash = \"\";\n    }\n\n    if ((index = url.indexOf(\"?\")) >= 0) {\n        params = url.slice(index);\n        url = url.slice(0, index);\n    } else {\n        params = \"\";\n    }\n\n    return { url, params, hash };\n};\n\nexport const pathFromUrl = function(url) {\n    let path;\n    ({ url } = splitUrl(url));\n    if (url.indexOf(\"file://\") === 0) {\n        path = url.replace(new RegExp(`^file://(localhost)?`), \"\");\n    } else {\n        //                        http  :   // hostname  :8080  /\n        path = url.replace(new RegExp(`^([^:]+:)?//([^:/]+)(:\\\\d*)?/`), \"/\");\n    }\n\n    // decodeURI has special handling of stuff like semicolons, so use decodeURIComponent\n    return decodeURIComponent(path);\n};\n\nexport const pickBestMatch = function(path, objects, pathFunc): any {\n    let score;\n    let bestMatch = { score: 0, object: null };\n\n    objects.forEach(object => {\n        score = numberOfMatchingSegments(path, pathFunc(object));\n        if (score > bestMatch.score) {\n            bestMatch = { object, score };\n        }\n    });\n\n    if (bestMatch.score > 0) {\n        return bestMatch;\n    } else {\n        return null;\n    }\n};\n\nexport const numberOfMatchingSegments = function(path1, path2) {\n    // get rid of leading slashes and normalize to lower case\n    path1 = path1.replace(/^\\/+/, \"\").toLowerCase();\n    path2 = path2.replace(/^\\/+/, \"\").toLowerCase();\n\n    if (path1 === path2) {\n        return 10000;\n    }\n\n    const comps1 = path1.split(\"/\").reverse();\n    const comps2 = path2.split(\"/\").reverse();\n    const len = Math.min(comps1.length, comps2.length);\n\n    let eqCount = 0;\n    while (eqCount < len && comps1[eqCount] === comps2[eqCount]) {\n        ++eqCount;\n    }\n\n    return eqCount;\n};\n\nexport const pathsMatch = (path1, path2) =>\n    numberOfMatchingSegments(path1, path2) > 0;\n\nexport function getLocation(url: string) {\n    var location = document.createElement(\"a\");\n    location.href = url;\n\n    if (location.host === \"\") {\n        location.href = location.href;\n    }\n\n    return location;\n}\n\n/**\n * @param {string} search\n * @param {string} key\n * @param {string} suffix\n */\nexport function updateSearch(search, key, suffix) {\n    if (search === \"\") {\n        return \"?\" + suffix;\n    }\n\n    return (\n        \"?\" +\n        search\n            .slice(1)\n            .split(\"&\")\n            .map(function(item) {\n                return item.split(\"=\");\n            })\n            .filter(function(tuple) {\n                return tuple[0] !== key;\n            })\n            .map(function(item) {\n                return [item[0], item[1]].join(\"=\");\n            })\n            .concat(suffix)\n            .join(\"&\")\n    );\n}\n\nconst blacklist = [\n    // never allow .map files through\n    function(incoming) {\n        return incoming.ext === \"map\";\n    }\n];\n\n/**\n * @param incoming\n * @returns {boolean}\n */\nexport function isBlacklisted(incoming) {\n    return blacklist.some(function(fn) {\n        return fn(incoming);\n    });\n}\n\nexport function createTimedBooleanSwitch(source$, timeout = 1000) {\n    return source$.pipe(\n        switchMap(() => {\n            return concat(of(false), timer(timeout).pipe(mapTo(true)));\n        }),\n        startWith(true)\n    );\n}\n\nexport function array(incoming) {\n    return [].slice.call(incoming);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils.ts","/**\n * @returns {window}\n */\nimport * as ScrollEvent from \"./messages/ScrollEvent\";\nimport ICoords = ScrollEvent.ICoords;\n\nexport function getWindow() {\n    return window;\n}\n\n/**\n * @returns {HTMLDocument}\n */\nexport function getDocument() {\n    return document;\n}\n\n/**\n * Get the current x/y position crossbow\n * @returns {{x: *, y: *}}\n */\nexport function getBrowserScrollPosition(window, document): ICoords {\n    let scrollX;\n    let scrollY;\n    const dElement = document.documentElement;\n    const dBody = document.body;\n\n    if (window.pageYOffset !== undefined) {\n        scrollX = window.pageXOffset;\n        scrollY = window.pageYOffset;\n    } else {\n        scrollX = dElement.scrollLeft || dBody.scrollLeft || 0;\n        scrollY = dElement.scrollTop || dBody.scrollTop || 0;\n    }\n\n    return {\n        x: scrollX,\n        y: scrollY\n    };\n}\n\n/**\n * @returns {{x: number, y: number}}\n */\nexport function getDocumentScrollSpace(\n    document: Document\n): ScrollEvent.ICoords {\n    const dElement = document.documentElement;\n    const dBody = document.body;\n    return {\n        x: dBody.scrollHeight - dElement.clientWidth,\n        y: dBody.scrollHeight - dElement.clientHeight\n    };\n}\n\n/**\n * Saves scroll position into cookies\n */\nexport function saveScrollPosition(window, document) {\n    const pos = getBrowserScrollPosition(window, document);\n    document.cookie = \"bs_scroll_pos=\" + [pos.x, pos.y].join(\",\");\n}\n\n/**\n * Restores scroll position from cookies\n */\nexport function restoreScrollPosition() {\n    const pos = getDocument()\n        .cookie.replace(\n            /(?:(?:^|.*;\\s*)bs_scroll_pos\\s*\\=\\s*([^;]*).*$)|^.*$/,\n            \"$1\"\n        )\n        .split(\",\");\n    getWindow().scrollTo(Number(pos[0]), Number(pos[1]));\n}\n\n/**\n * @param tagName\n * @param elem\n * @returns {*|number}\n */\nexport function getElementIndex(tagName, elem) {\n    var allElems = getDocument().getElementsByTagName(tagName);\n    return Array.prototype.indexOf.call(allElems, elem);\n}\n\n/**\n * Force Change event on radio & checkboxes (IE)\n */\nexport function forceChange(elem) {\n    elem.blur();\n    elem.focus();\n}\n\n/**\n * @param elem\n * @returns {{tagName: (elem.tagName|*), index: *}}\n */\nexport function getElementData(elem) {\n    var tagName = elem.tagName;\n    var index = getElementIndex(tagName, elem);\n    return {\n        tagName: tagName,\n        index: index\n    };\n}\n\n/**\n * @param {string} tagName\n * @param {number} index\n */\nexport function getSingleElement(tagName, index) {\n    var elems = getDocument().getElementsByTagName(tagName);\n    return elems[index];\n}\n\n/**\n * Get the body element\n */\nexport function getBody() {\n    return getDocument().getElementsByTagName(\"body\")[0];\n}\n\n/**\n * @param {{x: number, y: number}} pos\n */\nexport function setScroll(pos) {\n    getWindow().scrollTo(pos.x, pos.y);\n}\n\n/**\n * Hard reload\n */\nexport function reloadBrowser() {\n    getWindow().location.reload(true);\n}\n\n/**\n * Foreach polyfill\n * @param coll\n * @param fn\n */\nexport function forEach(coll, fn) {\n    for (var i = 0, n = coll.length; i < n; i += 1) {\n        fn(coll[i], i, coll);\n    }\n}\n\n/**\n * Are we dealing with old IE?\n * @returns {boolean}\n */\nexport function isOldIe() {\n    return typeof getWindow().attachEvent !== \"undefined\";\n}\n\n/**\n * Split the URL information\n * @returns {object}\n */\nexport function getLocation(url) {\n    const location = getDocument().createElement(\"a\");\n    location.href = url;\n\n    if (location.host === \"\") {\n        location.href = location.href;\n    }\n\n    return location;\n}\n\n/**\n * @param {String} val\n * @returns {boolean}\n */\nexport function isUndefined(val) {\n    return \"undefined\" === typeof val;\n}\n\n/**\n * @param obj\n * @param path\n */\nexport function getByPath(obj, path) {\n    for (\n        var i = 0, tempPath = path.split(\".\"), len = tempPath.length;\n        i < len;\n        i++\n    ) {\n        if (!obj || typeof obj !== \"object\") {\n            return false;\n        }\n        obj = obj[tempPath[i]];\n    }\n\n    if (typeof obj === \"undefined\") {\n        return false;\n    }\n\n    return obj;\n}\n\nexport function getScrollPosition(\n    window: Window,\n    document: Document\n): ScrollEvent.Data {\n    const pos = getBrowserScrollPosition(window, document);\n    return {\n        raw: pos, // Get px of x and y axis of scroll\n        proportional: getScrollTopPercentage(pos, document) // Get % of y axis of scroll\n    };\n}\n\nexport function getScrollPositionForElement(\n    element: HTMLElement\n): ScrollEvent.Data {\n    const raw: ICoords = {\n        x: element.scrollLeft,\n        y: element.scrollTop\n    };\n    const scrollSpace: ICoords = {\n        x: element.scrollWidth,\n        y: element.scrollHeight\n    };\n    return {\n        raw, // Get px of x and y axis of scroll\n        proportional: getScrollPercentage(scrollSpace, raw).y // Get % of y axis of scroll\n    };\n}\n\nexport function getScrollTopPercentage(pos, document): number {\n    const scrollSpace = getDocumentScrollSpace(document);\n    const percentage = getScrollPercentage(scrollSpace, pos);\n    return percentage.y;\n}\n\nexport function getScrollPercentage(\n    scrollSpace: ICoords,\n    scrollPosition: ICoords\n): ICoords {\n    const x = scrollPosition.x / scrollSpace.x;\n    const y = scrollPosition.y / scrollSpace.y;\n\n    return {\n        x: x || 0,\n        y: y\n    };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/browser.utils.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\nvar isScheduler_1 = require('../util/isScheduler');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayObservable = (function (_super) {\n    __extends(ArrayObservable, _super);\n    function ArrayObservable(array, scheduler) {\n        _super.call(this);\n        this.array = array;\n        this.scheduler = scheduler;\n        if (!scheduler && array.length === 1) {\n            this._isScalar = true;\n            this.value = array[0];\n        }\n    }\n    ArrayObservable.create = function (array, scheduler) {\n        return new ArrayObservable(array, scheduler);\n    };\n    /**\n     * Creates an Observable that emits some values you specify as arguments,\n     * immediately one after the other, and then emits a complete notification.\n     *\n     * <span class=\"informal\">Emits the arguments you provide, then completes.\n     * </span>\n     *\n     * <img src=\"./img/of.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the arguments given, and the complete notification thereafter. It can\n     * be used for composing with other Observables, such as with {@link concat}.\n     * By default, it uses a `null` IScheduler, which means the `next`\n     * notifications are sent synchronously, although with a different IScheduler\n     * it is possible to determine when those notifications will be delivered.\n     *\n     * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>\n     * var numbers = Rx.Observable.of(10, 20, 30);\n     * var letters = Rx.Observable.of('a', 'b', 'c');\n     * var interval = Rx.Observable.interval(1000);\n     * var result = numbers.concat(letters).concat(interval);\n     * result.subscribe(x => console.log(x));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link throw}\n     *\n     * @param {...T} values Arguments that represent `next` values to be emitted.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emissions of the `next` notifications.\n     * @return {Observable<T>} An Observable that emits each given input value.\n     * @static true\n     * @name of\n     * @owner Observable\n     */\n    ArrayObservable.of = function () {\n        var array = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            array[_i - 0] = arguments[_i];\n        }\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len > 1) {\n            return new ArrayObservable(array, scheduler);\n        }\n        else if (len === 1) {\n            return new ScalarObservable_1.ScalarObservable(array[0], scheduler);\n        }\n        else {\n            return new EmptyObservable_1.EmptyObservable(scheduler);\n        }\n    };\n    ArrayObservable.dispatch = function (state) {\n        var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber;\n        if (index >= count) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(array[index]);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    ArrayObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var array = this.array;\n        var count = array.length;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ArrayObservable.dispatch, 0, {\n                array: array, index: index, count: count, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < count && !subscriber.closed; i++) {\n                subscriber.next(array[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayObservable;\n}(Observable_1.Observable));\nexports.ArrayObservable = ArrayObservable;\n//# sourceMappingURL=ArrayObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/ArrayObservable.js\n// module id = 25\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar EmptyObservable = (function (_super) {\n    __extends(EmptyObservable, _super);\n    function EmptyObservable(scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits a complete notification.\n     *\n     * <span class=\"informal\">Just emits 'complete', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/empty.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the complete notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then complete.</caption>\n     * var result = Rx.Observable.empty().startWith(7);\n     * result.subscribe(x => console.log(x));\n     *\n     * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()\n     * );\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following to the console:\n     * // x is equal to the count on the interval eg(0,1,2,3,...)\n     * // x will occur every 1000ms\n     * // if x % 2 is equal to 1 print abc\n     * // if x % 2 is not equal to 1 nothing will be output\n     *\n     * @see {@link create}\n     * @see {@link never}\n     * @see {@link of}\n     * @see {@link throw}\n     *\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the complete notification.\n     * @return {Observable} An \"empty\" Observable: emits only the complete\n     * notification.\n     * @static true\n     * @name empty\n     * @owner Observable\n     */\n    EmptyObservable.create = function (scheduler) {\n        return new EmptyObservable(scheduler);\n    };\n    EmptyObservable.dispatch = function (arg) {\n        var subscriber = arg.subscriber;\n        subscriber.complete();\n    };\n    EmptyObservable.prototype._subscribe = function (subscriber) {\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber });\n        }\n        else {\n            subscriber.complete();\n        }\n    };\n    return EmptyObservable;\n}(Observable_1.Observable));\nexports.EmptyObservable = EmptyObservable;\n//# sourceMappingURL=EmptyObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/EmptyObservable.js\n// module id = 26\n// module chunks = 0","\"use strict\";\nfunction isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\nexports.isScheduler = isScheduler;\n//# sourceMappingURL=isScheduler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isScheduler.js\n// module id = 27\n// module chunks = 0","\"use strict\";\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isArray.js\n// module id = 28\n// module chunks = 0","\"use strict\";\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/errorObject.js\n// module id = 29\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar OuterSubscriber = (function (_super) {\n    __extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        _super.apply(this, arguments);\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber_1.Subscriber));\nexports.OuterSubscriber = OuterSubscriber;\n//# sourceMappingURL=OuterSubscriber.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/OuterSubscriber.js\n// module id = 30\n// module chunks = 0","\"use strict\";\nvar root_1 = require('./root');\nvar isArrayLike_1 = require('./isArrayLike');\nvar isPromise_1 = require('./isPromise');\nvar isObject_1 = require('./isObject');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\nvar InnerSubscriber_1 = require('../InnerSubscriber');\nvar observable_1 = require('../symbol/observable');\nfunction subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {\n    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    if (destination.closed) {\n        return null;\n    }\n    if (result instanceof Observable_1.Observable) {\n        if (result._isScalar) {\n            destination.next(result.value);\n            destination.complete();\n            return null;\n        }\n        else {\n            destination.syncErrorThrowable = true;\n            return result.subscribe(destination);\n        }\n    }\n    else if (isArrayLike_1.isArrayLike(result)) {\n        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {\n            destination.next(result[i]);\n        }\n        if (!destination.closed) {\n            destination.complete();\n        }\n    }\n    else if (isPromise_1.isPromise(result)) {\n        result.then(function (value) {\n            if (!destination.closed) {\n                destination.next(value);\n                destination.complete();\n            }\n        }, function (err) { return destination.error(err); })\n            .then(null, function (err) {\n            // Escaping the Promise trap: globally throw unhandled errors\n            root_1.root.setTimeout(function () { throw err; });\n        });\n        return destination;\n    }\n    else if (result && typeof result[iterator_1.iterator] === 'function') {\n        var iterator = result[iterator_1.iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                destination.complete();\n                break;\n            }\n            destination.next(item.value);\n            if (destination.closed) {\n                break;\n            }\n        } while (true);\n    }\n    else if (result && typeof result[observable_1.observable] === 'function') {\n        var obs = result[observable_1.observable]();\n        if (typeof obs.subscribe !== 'function') {\n            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));\n        }\n        else {\n            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));\n        }\n    }\n    else {\n        var value = isObject_1.isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = (\"You provided \" + value + \" where a stream was expected.\")\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        destination.error(new TypeError(msg));\n    }\n    return null;\n}\nexports.subscribeToResult = subscribeToResult;\n//# sourceMappingURL=subscribeToResult.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/subscribeToResult.js\n// module id = 31\n// module chunks = 0","\"use strict\";\nvar root_1 = require('../util/root');\nfunction symbolIteratorPonyfill(root) {\n    var Symbol = root.Symbol;\n    if (typeof Symbol === 'function') {\n        if (!Symbol.iterator) {\n            Symbol.iterator = Symbol('iterator polyfill');\n        }\n        return Symbol.iterator;\n    }\n    else {\n        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)\n        var Set_1 = root.Set;\n        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {\n            return '@@iterator';\n        }\n        var Map_1 = root.Map;\n        // required for compatability with es6-shim\n        if (Map_1) {\n            var keys = Object.getOwnPropertyNames(Map_1.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.\n                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {\n                    return key;\n                }\n            }\n        }\n        return '@@iterator';\n    }\n}\nexports.symbolIteratorPonyfill = symbolIteratorPonyfill;\nexports.iterator = symbolIteratorPonyfill(root_1.root);\n/**\n * @deprecated use iterator instead\n */\nexports.$$iterator = exports.iterator;\n//# sourceMappingURL=iterator.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/symbol/iterator.js\n// module id = 32\n// module chunks = 0","/**\r\n * Compiles a querystring\r\n * Returns string representation of the object\r\n *\r\n * @param {Object}\r\n * @api private\r\n */\r\n\r\nexports.encode = function (obj) {\r\n  var str = '';\r\n\r\n  for (var i in obj) {\r\n    if (obj.hasOwnProperty(i)) {\r\n      if (str.length) str += '&';\r\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\r\n    }\r\n  }\r\n\r\n  return str;\r\n};\r\n\r\n/**\r\n * Parses a simple querystring into an object\r\n *\r\n * @param {String} qs\r\n * @api private\r\n */\r\n\r\nexports.decode = function(qs){\r\n  var qry = {};\r\n  var pairs = qs.split('&');\r\n  for (var i = 0, l = pairs.length; i < l; i++) {\r\n    var pair = pairs[i].split('=');\r\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\r\n  }\r\n  return qry;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/parseqs/index.js\n// module id = 33\n// module chunks = 0","\nmodule.exports = function(a, b){\n  var fn = function(){};\n  fn.prototype = b.prototype;\n  a.prototype = new fn;\n  a.prototype.constructor = a;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/component-inherit/index.js\n// module id = 34\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('./Observable');\nvar Subscriber_1 = require('./Subscriber');\nvar Subscription_1 = require('./Subscription');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\nvar SubjectSubscription_1 = require('./SubjectSubscription');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * @class SubjectSubscriber<T>\n */\nvar SubjectSubscriber = (function (_super) {\n    __extends(SubjectSubscriber, _super);\n    function SubjectSubscriber(destination) {\n        _super.call(this, destination);\n        this.destination = destination;\n    }\n    return SubjectSubscriber;\n}(Subscriber_1.Subscriber));\nexports.SubjectSubscriber = SubjectSubscriber;\n/**\n * @class Subject<T>\n */\nvar Subject = (function (_super) {\n    __extends(Subject, _super);\n    function Subject() {\n        _super.call(this);\n        this.observers = [];\n        this.closed = false;\n        this.isStopped = false;\n        this.hasError = false;\n        this.thrownError = null;\n    }\n    Subject.prototype[rxSubscriber_1.rxSubscriber] = function () {\n        return new SubjectSubscriber(this);\n    };\n    Subject.prototype.lift = function (operator) {\n        var subject = new AnonymousSubject(this, this);\n        subject.operator = operator;\n        return subject;\n    };\n    Subject.prototype.next = function (value) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        if (!this.isStopped) {\n            var observers = this.observers;\n            var len = observers.length;\n            var copy = observers.slice();\n            for (var i = 0; i < len; i++) {\n                copy[i].next(value);\n            }\n        }\n    };\n    Subject.prototype.error = function (err) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.hasError = true;\n        this.thrownError = err;\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].error(err);\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.complete = function () {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].complete();\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.unsubscribe = function () {\n        this.isStopped = true;\n        this.closed = true;\n        this.observers = null;\n    };\n    Subject.prototype._trySubscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return _super.prototype._trySubscribe.call(this, subscriber);\n        }\n    };\n    Subject.prototype._subscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else if (this.hasError) {\n            subscriber.error(this.thrownError);\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else if (this.isStopped) {\n            subscriber.complete();\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else {\n            this.observers.push(subscriber);\n            return new SubjectSubscription_1.SubjectSubscription(this, subscriber);\n        }\n    };\n    Subject.prototype.asObservable = function () {\n        var observable = new Observable_1.Observable();\n        observable.source = this;\n        return observable;\n    };\n    Subject.create = function (destination, source) {\n        return new AnonymousSubject(destination, source);\n    };\n    return Subject;\n}(Observable_1.Observable));\nexports.Subject = Subject;\n/**\n * @class AnonymousSubject<T>\n */\nvar AnonymousSubject = (function (_super) {\n    __extends(AnonymousSubject, _super);\n    function AnonymousSubject(destination, source) {\n        _super.call(this);\n        this.destination = destination;\n        this.source = source;\n    }\n    AnonymousSubject.prototype.next = function (value) {\n        var destination = this.destination;\n        if (destination && destination.next) {\n            destination.next(value);\n        }\n    };\n    AnonymousSubject.prototype.error = function (err) {\n        var destination = this.destination;\n        if (destination && destination.error) {\n            this.destination.error(err);\n        }\n    };\n    AnonymousSubject.prototype.complete = function () {\n        var destination = this.destination;\n        if (destination && destination.complete) {\n            this.destination.complete();\n        }\n    };\n    AnonymousSubject.prototype._subscribe = function (subscriber) {\n        var source = this.source;\n        if (source) {\n            return this.source.subscribe(subscriber);\n        }\n        else {\n            return Subscription_1.Subscription.EMPTY;\n        }\n    };\n    return AnonymousSubject;\n}(Subject));\nexports.AnonymousSubject = AnonymousSubject;\n//# sourceMappingURL=Subject.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Subject.js\n// module id = 35\n// module chunks = 0","\"use strict\";\nvar Observable_1 = require('../Observable');\nvar ArrayObservable_1 = require('./ArrayObservable');\nvar isScheduler_1 = require('../util/isScheduler');\nvar mergeAll_1 = require('../operators/mergeAll');\n/* tslint:enable:max-line-length */\n/**\n * Creates an output Observable which concurrently emits all values from every\n * given input Observable.\n *\n * <span class=\"informal\">Flattens multiple Observables together by blending\n * their values into one Observable.</span>\n *\n * <img src=\"./img/merge.png\" width=\"100%\">\n *\n * `merge` subscribes to each given input Observable (as arguments), and simply\n * forwards (without doing any transformation) all the values from all the input\n * Observables to the output Observable. The output Observable only completes\n * once all input Observables have completed. Any error delivered by an input\n * Observable will be immediately emitted on the output Observable.\n *\n * @example <caption>Merge together two Observables: 1s interval and clicks</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var timer = Rx.Observable.interval(1000);\n * var clicksOrTimer = Rx.Observable.merge(clicks, timer);\n * clicksOrTimer.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // timer will emit ascending values, one every second(1000ms) to console\n * // clicks logs MouseEvents to console everytime the \"document\" is clicked\n * // Since the two streams are merged you see these happening\n * // as they occur.\n *\n * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>\n * var timer1 = Rx.Observable.interval(1000).take(10);\n * var timer2 = Rx.Observable.interval(2000).take(6);\n * var timer3 = Rx.Observable.interval(500).take(10);\n * var concurrent = 2; // the argument\n * var merged = Rx.Observable.merge(timer1, timer2, timer3, concurrent);\n * merged.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // - First timer1 and timer2 will run concurrently\n * // - timer1 will emit a value every 1000ms for 10 iterations\n * // - timer2 will emit a value every 2000ms for 6 iterations\n * // - after timer1 hits it's max iteration, timer2 will\n * //   continue, and timer3 will start to run concurrently with timer2\n * // - when timer2 hits it's max iteration it terminates, and\n * //   timer3 will continue to emit a value every 500ms until it is complete\n *\n * @see {@link mergeAll}\n * @see {@link mergeMap}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n *\n * @param {...ObservableInput} observables Input Observables to merge together.\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @param {Scheduler} [scheduler=null] The IScheduler to use for managing\n * concurrency of input Observables.\n * @return {Observable} an Observable that emits items that are the result of\n * every input Observable.\n * @static true\n * @name merge\n * @owner Observable\n */\nfunction merge() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var concurrent = Number.POSITIVE_INFINITY;\n    var scheduler = null;\n    var last = observables[observables.length - 1];\n    if (isScheduler_1.isScheduler(last)) {\n        scheduler = observables.pop();\n        if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') {\n            concurrent = observables.pop();\n        }\n    }\n    else if (typeof last === 'number') {\n        concurrent = observables.pop();\n    }\n    if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable_1.Observable) {\n        return observables[0];\n    }\n    return mergeAll_1.mergeAll(concurrent)(new ArrayObservable_1.ArrayObservable(observables, scheduler));\n}\nexports.merge = merge;\n//# sourceMappingURL=merge.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/merge.js\n// module id = 36\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Returns an Observable that skips the first `count` items emitted by the source Observable.\n *\n * <img src=\"./img/skip.png\" width=\"100%\">\n *\n * @param {Number} count - The number of times, items emitted by source Observable should be skipped.\n * @return {Observable} An Observable that skips values emitted by the source Observable.\n *\n * @method skip\n * @owner Observable\n */\nfunction skip(count) {\n    return function (source) { return source.lift(new SkipOperator(count)); };\n}\nexports.skip = skip;\nvar SkipOperator = (function () {\n    function SkipOperator(total) {\n        this.total = total;\n    }\n    SkipOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new SkipSubscriber(subscriber, this.total));\n    };\n    return SkipOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SkipSubscriber = (function (_super) {\n    __extends(SkipSubscriber, _super);\n    function SkipSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    SkipSubscriber.prototype._next = function (x) {\n        if (++this.count > this.total) {\n            this.destination.next(x);\n        }\n    };\n    return SkipSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=skip.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/skip.js\n// module id = 37\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar tryCatch_1 = require('../util/tryCatch');\nvar errorObject_1 = require('../util/errorObject');\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.\n *\n * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted.\n *\n * If a comparator function is not provided, an equality check is used by default.\n *\n * @example <caption>A simple example with numbers</caption>\n * Observable.of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4)\n *   .distinctUntilChanged()\n *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4\n *\n * @example <caption>An example using a compare function</caption>\n * interface Person {\n *    age: number,\n *    name: string\n * }\n *\n * Observable.of<Person>(\n *     { age: 4, name: 'Foo'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo'})\n *     { age: 6, name: 'Foo'})\n *     .distinctUntilChanged((p: Person, q: Person) => p.name === q.name)\n *     .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Foo' }\n * // { age: 7, name: 'Bar' }\n * // { age: 5, name: 'Foo' }\n *\n * @see {@link distinct}\n * @see {@link distinctUntilKeyChanged}\n *\n * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.\n * @return {Observable} An Observable that emits items from the source Observable with distinct values.\n * @method distinctUntilChanged\n * @owner Observable\n */\nfunction distinctUntilChanged(compare, keySelector) {\n    return function (source) { return source.lift(new DistinctUntilChangedOperator(compare, keySelector)); };\n}\nexports.distinctUntilChanged = distinctUntilChanged;\nvar DistinctUntilChangedOperator = (function () {\n    function DistinctUntilChangedOperator(compare, keySelector) {\n        this.compare = compare;\n        this.keySelector = keySelector;\n    }\n    DistinctUntilChangedOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));\n    };\n    return DistinctUntilChangedOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DistinctUntilChangedSubscriber = (function (_super) {\n    __extends(DistinctUntilChangedSubscriber, _super);\n    function DistinctUntilChangedSubscriber(destination, compare, keySelector) {\n        _super.call(this, destination);\n        this.keySelector = keySelector;\n        this.hasKey = false;\n        if (typeof compare === 'function') {\n            this.compare = compare;\n        }\n    }\n    DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {\n        return x === y;\n    };\n    DistinctUntilChangedSubscriber.prototype._next = function (value) {\n        var keySelector = this.keySelector;\n        var key = value;\n        if (keySelector) {\n            key = tryCatch_1.tryCatch(this.keySelector)(value);\n            if (key === errorObject_1.errorObject) {\n                return this.destination.error(errorObject_1.errorObject.e);\n            }\n        }\n        var result = false;\n        if (this.hasKey) {\n            result = tryCatch_1.tryCatch(this.compare)(this.key, key);\n            if (result === errorObject_1.errorObject) {\n                return this.destination.error(errorObject_1.errorObject.e);\n            }\n        }\n        else {\n            this.hasKey = true;\n        }\n        if (Boolean(result) === false) {\n            this.key = key;\n            this.destination.next(value);\n        }\n    };\n    return DistinctUntilChangedSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=distinctUntilChanged.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/distinctUntilChanged.js\n// module id = 38\n// module chunks = 0","\"use strict\";\nvar FromEventObservable_1 = require('./FromEventObservable');\nexports.fromEvent = FromEventObservable_1.FromEventObservable.create;\n//# sourceMappingURL=fromEvent.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/fromEvent.js\n// module id = 39\n// module chunks = 0","\"use strict\";\nfunction isFunction(x) {\n    return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isFunction.js\n// module id = 40\n// module chunks = 0","\"use strict\";\nvar errorObject_1 = require('./errorObject');\nvar tryCatchTarget;\nfunction tryCatcher() {\n    try {\n        return tryCatchTarget.apply(this, arguments);\n    }\n    catch (e) {\n        errorObject_1.errorObject.e = e;\n        return errorObject_1.errorObject;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/tryCatch.js\n// module id = 41\n// module chunks = 0","\"use strict\";\nvar root_1 = require('../util/root');\nvar Symbol = root_1.root.Symbol;\nexports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?\n    Symbol.for('rxSubscriber') : '@@rxSubscriber';\n/**\n * @deprecated use rxSubscriber instead\n */\nexports.$$rxSubscriber = exports.rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/symbol/rxSubscriber.js\n// module id = 42\n// module chunks = 0","\"use strict\";\nvar root_1 = require('../util/root');\nfunction getSymbolObservable(context) {\n    var $$observable;\n    var Symbol = context.Symbol;\n    if (typeof Symbol === 'function') {\n        if (Symbol.observable) {\n            $$observable = Symbol.observable;\n        }\n        else {\n            $$observable = Symbol('observable');\n            Symbol.observable = $$observable;\n        }\n    }\n    else {\n        $$observable = '@@observable';\n    }\n    return $$observable;\n}\nexports.getSymbolObservable = getSymbolObservable;\nexports.observable = getSymbolObservable(root_1.root);\n/**\n * @deprecated use observable instead\n */\nexports.$$observable = exports.observable;\n//# sourceMappingURL=observable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/symbol/observable.js\n// module id = 43\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ScalarObservable = (function (_super) {\n    __extends(ScalarObservable, _super);\n    function ScalarObservable(value, scheduler) {\n        _super.call(this);\n        this.value = value;\n        this.scheduler = scheduler;\n        this._isScalar = true;\n        if (scheduler) {\n            this._isScalar = false;\n        }\n    }\n    ScalarObservable.create = function (value, scheduler) {\n        return new ScalarObservable(value, scheduler);\n    };\n    ScalarObservable.dispatch = function (state) {\n        var done = state.done, value = state.value, subscriber = state.subscriber;\n        if (done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(value);\n        if (subscriber.closed) {\n            return;\n        }\n        state.done = true;\n        this.schedule(state);\n    };\n    ScalarObservable.prototype._subscribe = function (subscriber) {\n        var value = this.value;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ScalarObservable.dispatch, 0, {\n                done: false, value: value, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.next(value);\n            if (!subscriber.closed) {\n                subscriber.complete();\n            }\n        }\n    };\n    return ScalarObservable;\n}(Observable_1.Observable));\nexports.ScalarObservable = ScalarObservable;\n//# sourceMappingURL=ScalarObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/ScalarObservable.js\n// module id = 44\n// module chunks = 0","\n/**\n * Module dependencies.\n */\n\nvar debug = require('debug')('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar hasBin = require('has-binary2');\nvar binary = require('./binary');\nvar isBuf = require('./is-buffer');\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n  'CONNECT',\n  'DISCONNECT',\n  'EVENT',\n  'ACK',\n  'ERROR',\n  'BINARY_EVENT',\n  'BINARY_ACK'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n  if ((obj.type === exports.EVENT || obj.type === exports.ACK) && hasBin(obj.data)) {\n    obj.type = obj.type === exports.EVENT ? exports.BINARY_EVENT : exports.BINARY_ACK;\n  }\n\n  debug('encoding packet %j', obj);\n\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    encodeAsBinary(obj, callback);\n  }\n  else {\n    var encoding = encodeAsString(obj);\n    callback([encoding]);\n  }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n\n  // first is type\n  var str = '' + obj.type;\n\n  // attachments if we have them\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    str += obj.attachments + '-';\n  }\n\n  // if we have a namespace other than `/`\n  // we append it followed by a comma `,`\n  if (obj.nsp && '/' !== obj.nsp) {\n    str += obj.nsp + ',';\n  }\n\n  // immediately followed by the id\n  if (null != obj.id) {\n    str += obj.id;\n  }\n\n  // json data\n  if (null != obj.data) {\n    str += JSON.stringify(obj.data);\n  }\n\n  debug('encoded %j as %s', obj, str);\n  return str;\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n  function writeEncoding(bloblessData) {\n    var deconstruction = binary.deconstructPacket(bloblessData);\n    var pack = encodeAsString(deconstruction.packet);\n    var buffers = deconstruction.buffers;\n\n    buffers.unshift(pack); // add packet info to beginning of data list\n    callback(buffers); // write all the buffers\n  }\n\n  binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n  this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an ecoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n  var packet;\n  if (typeof obj === 'string') {\n    packet = decodeString(obj);\n    if (exports.BINARY_EVENT === packet.type || exports.BINARY_ACK === packet.type) { // binary packet's json\n      this.reconstructor = new BinaryReconstructor(packet);\n\n      // no attachments, labeled binary but no binary data to follow\n      if (this.reconstructor.reconPack.attachments === 0) {\n        this.emit('decoded', packet);\n      }\n    } else { // non-binary full packet\n      this.emit('decoded', packet);\n    }\n  }\n  else if (isBuf(obj) || obj.base64) { // raw binary data\n    if (!this.reconstructor) {\n      throw new Error('got binary data when not reconstructing a packet');\n    } else {\n      packet = this.reconstructor.takeBinaryData(obj);\n      if (packet) { // received final buffer\n        this.reconstructor = null;\n        this.emit('decoded', packet);\n      }\n    }\n  }\n  else {\n    throw new Error('Unknown type: ' + obj);\n  }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n  var i = 0;\n  // look up type\n  var p = {\n    type: Number(str.charAt(0))\n  };\n\n  if (null == exports.types[p.type]) return error();\n\n  // look up attachments if type binary\n  if (exports.BINARY_EVENT === p.type || exports.BINARY_ACK === p.type) {\n    var buf = '';\n    while (str.charAt(++i) !== '-') {\n      buf += str.charAt(i);\n      if (i == str.length) break;\n    }\n    if (buf != Number(buf) || str.charAt(i) !== '-') {\n      throw new Error('Illegal attachments');\n    }\n    p.attachments = Number(buf);\n  }\n\n  // look up namespace (if any)\n  if ('/' === str.charAt(i + 1)) {\n    p.nsp = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' === c) break;\n      p.nsp += c;\n      if (i === str.length) break;\n    }\n  } else {\n    p.nsp = '/';\n  }\n\n  // look up id\n  var next = str.charAt(i + 1);\n  if ('' !== next && Number(next) == next) {\n    p.id = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      p.id += str.charAt(i);\n      if (i === str.length) break;\n    }\n    p.id = Number(p.id);\n  }\n\n  // look up json data\n  if (str.charAt(++i)) {\n    p = tryParse(p, str.substr(i));\n  }\n\n  debug('decoded %s as %j', str, p);\n  return p;\n}\n\nfunction tryParse(p, str) {\n  try {\n    p.data = JSON.parse(str);\n  } catch(e){\n    return error();\n  }\n  return p; \n}\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n  if (this.reconstructor) {\n    this.reconstructor.finishedReconstruction();\n  }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n  this.reconPack = packet;\n  this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n *   a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n  this.buffers.push(binData);\n  if (this.buffers.length === this.reconPack.attachments) { // done with buffer list\n    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n    this.finishedReconstruction();\n    return packet;\n  }\n  return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n  this.reconPack = null;\n  this.buffers = [];\n};\n\nfunction error() {\n  return {\n    type: exports.ERROR,\n    data: 'parser error'\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-parser/index.js\n// module id = 45\n// module chunks = 0","// browser shim for xmlhttprequest module\n\nvar hasCORS = require('has-cors');\n\nmodule.exports = function (opts) {\n  var xdomain = opts.xdomain;\n\n  // scheme must be same when usign XDomainRequest\n  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n  var xscheme = opts.xscheme;\n\n  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n  // https://github.com/Automattic/engine.io-client/pull/217\n  var enablesXDR = opts.enablesXDR;\n\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) { }\n\n  // Use XDomainRequest for IE8 if enablesXDR is true\n  // because loading bar keeps flashing when using jsonp-polling\n  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n  try {\n    if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {\n      return new XDomainRequest();\n    }\n  } catch (e) { }\n\n  if (!xdomain) {\n    try {\n      return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');\n    } catch (e) { }\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/xmlhttprequest.js\n// module id = 46\n// module chunks = 0","/**\n * Module dependencies.\n */\n\nvar parser = require('engine.io-parser');\nvar Emitter = require('component-emitter');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n  this.path = opts.path;\n  this.hostname = opts.hostname;\n  this.port = opts.port;\n  this.secure = opts.secure;\n  this.query = opts.query;\n  this.timestampParam = opts.timestampParam;\n  this.timestampRequests = opts.timestampRequests;\n  this.readyState = '';\n  this.agent = opts.agent || false;\n  this.socket = opts.socket;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n  this.forceNode = opts.forceNode;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n  this.localAddress = opts.localAddress;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n  var err = new Error(msg);\n  err.type = 'TransportError';\n  err.description = desc;\n  this.emit('error', err);\n  return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n  if ('closed' === this.readyState || '' === this.readyState) {\n    this.readyState = 'opening';\n    this.doOpen();\n  }\n\n  return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.doClose();\n    this.onClose();\n  }\n\n  return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function (packets) {\n  if ('open' === this.readyState) {\n    this.write(packets);\n  } else {\n    throw new Error('Transport not open');\n  }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n  this.readyState = 'open';\n  this.writable = true;\n  this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function (data) {\n  var packet = parser.decodePacket(data, this.socket.binaryType);\n  this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n  this.readyState = 'closed';\n  this.emit('close');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transport.js\n// module id = 47\n// module chunks = 0","\"use strict\";\nvar TimerObservable_1 = require('./TimerObservable');\nexports.timer = TimerObservable_1.TimerObservable.create;\n//# sourceMappingURL=timer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/timer.js\n// module id = 48\n// module chunks = 0","import { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { map } from \"rxjs/operators/map\";\nimport { EffectNames } from \"../effects\";\nimport { consoleInfo } from \"../log\";\n\n/**\n * Set the local client options\n * @param xs\n * @param inputs\n */\nexport function setOptionsEffect(\n    xs: Observable<IBrowserSyncOptions>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        tap(options => inputs.option$.next(options)),\n        // map(() => consoleInfo('set options'))\n        ignoreElements()\n    );\n}\n\nexport function setOptions(options: IBrowserSyncOptions) {\n    return [EffectNames.SetOptions, options];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/set-options.effect.ts","\"use strict\";\nvar isScheduler_1 = require('../util/isScheduler');\nvar of_1 = require('./of');\nvar from_1 = require('./from');\nvar concatAll_1 = require('../operators/concatAll');\n/* tslint:enable:max-line-length */\n/**\n * Creates an output Observable which sequentially emits all values from given\n * Observable and then moves on to the next.\n *\n * <span class=\"informal\">Concatenates multiple Observables together by\n * sequentially emitting their values, one Observable after the other.</span>\n *\n * <img src=\"./img/concat.png\" width=\"100%\">\n *\n * `concat` joins multiple Observables together, by subscribing to them one at a time and\n * merging their results into the output Observable. You can pass either an array of\n * Observables, or put them directly as arguments. Passing an empty array will result\n * in Observable that completes immediately.\n *\n * `concat` will subscribe to first input Observable and emit all its values, without\n * changing or affecting them in any way. When that Observable completes, it will\n * subscribe to then next Observable passed and, again, emit its values. This will be\n * repeated, until the operator runs out of Observables. When last input Observable completes,\n * `concat` will complete as well. At any given moment only one Observable passed to operator\n * emits values. If you would like to emit values from passed Observables concurrently, check out\n * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,\n * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.\n *\n * Note that if some input Observable never completes, `concat` will also never complete\n * and Observables following the one that did not complete will never be subscribed. On the other\n * hand, if some Observable simply completes immediately after it is subscribed, it will be\n * invisible for `concat`, which will just move on to the next Observable.\n *\n * If any Observable in chain errors, instead of passing control to the next Observable,\n * `concat` will error immediately as well. Observables that would be subscribed after\n * the one that emitted error, never will.\n *\n * If you pass to `concat` the same Observable many times, its stream of values\n * will be \"replayed\" on every subscription, which means you can repeat given Observable\n * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,\n * you can always use {@link repeat}.\n *\n * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>\n * var timer = Rx.Observable.interval(1000).take(4);\n * var sequence = Rx.Observable.range(1, 10);\n * var result = Rx.Observable.concat(timer, sequence);\n * result.subscribe(x => console.log(x));\n *\n * // results in:\n * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10\n *\n *\n * @example <caption>Concatenate an array of 3 Observables</caption>\n * var timer1 = Rx.Observable.interval(1000).take(10);\n * var timer2 = Rx.Observable.interval(2000).take(6);\n * var timer3 = Rx.Observable.interval(500).take(10);\n * var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed\n * result.subscribe(x => console.log(x));\n *\n * // results in the following:\n * // (Prints to console sequentially)\n * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9\n * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5\n * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9\n *\n *\n * @example <caption>Concatenate the same Observable to repeat it</caption>\n * const timer = Rx.Observable.interval(1000).take(2);\n *\n * Rx.Observable.concat(timer, timer) // concating the same Observable!\n * .subscribe(\n *   value => console.log(value),\n *   err => {},\n *   () => console.log('...and it is done!')\n * );\n *\n * // Logs:\n * // 0 after 1s\n * // 1 after 2s\n * // 0 after 3s\n * // 1 after 4s\n * // \"...and it is done!\" also after 4s\n *\n * @see {@link concatAll}\n * @see {@link concatMap}\n * @see {@link concatMapTo}\n *\n * @param {ObservableInput} input1 An input Observable to concatenate with others.\n * @param {ObservableInput} input2 An input Observable to concatenate with others.\n * More than one input Observables may be given as argument.\n * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each\n * Observable subscription on.\n * @return {Observable} All values of each passed Observable merged into a\n * single Observable, in order, in serial fashion.\n * @static true\n * @name concat\n * @owner Observable\n */\nfunction concat() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    if (observables.length === 1 || (observables.length === 2 && isScheduler_1.isScheduler(observables[1]))) {\n        return from_1.from(observables[0]);\n    }\n    return concatAll_1.concatAll()(of_1.of.apply(void 0, observables));\n}\nexports.concat = concat;\n//# sourceMappingURL=concat.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/concat.js\n// module id = 50\n// module chunks = 0","import { Inputs } from \"../index\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { concat } from \"rxjs/observable/concat\";\nimport { of } from \"rxjs/observable/of\";\nimport {\n    browserReload,\n    preBrowserReload\n} from \"../effects/browser-reload.effect\";\nimport { subscribeOn } from \"rxjs/operators/subscribeOn\";\nimport { async } from \"rxjs/scheduler/async\";\n\nexport function incomingBrowserReload(xs: Observable<any>, inputs: Inputs) {\n    return xs.pipe(\n        withLatestFrom(inputs.option$),\n        filter(([event, options]) => options.codeSync),\n        mergeMap(reloadBrowserSafe)\n    );\n}\n\nexport function reloadBrowserSafe() {\n    return concat(\n        /**\n         * Emit a warning message allowing others to do some work\n         */\n        of(preBrowserReload()),\n        /**\n         * On the next tick, perform the reload\n         */\n        of(browserReload()).pipe(subscribeOn(async))\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/BrowserReload.ts","\"use strict\";\nfunction isObject(x) {\n    return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isObject.js\n// module id = 52\n// module chunks = 0","\"use strict\";\nexports.empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) { throw err; },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Observer.js\n// module id = 53\n// module chunks = 0","\"use strict\";\n/* tslint:disable:no-empty */\nfunction noop() { }\nexports.noop = noop;\n//# sourceMappingURL=noop.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/noop.js\n// module id = 54\n// module chunks = 0","\"use strict\";\nexports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArrayLike.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isArrayLike.js\n// module id = 55\n// module chunks = 0","\"use strict\";\nfunction isPromise(value) {\n    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nexports.isPromise = isPromise;\n//# sourceMappingURL=isPromise.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isPromise.js\n// module id = 56\n// module chunks = 0","/**\r\n * Parses an URI\r\n *\r\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\r\n * @api private\r\n */\r\n\r\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\r\n\r\nvar parts = [\r\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\r\n];\r\n\r\nmodule.exports = function parseuri(str) {\r\n    var src = str,\r\n        b = str.indexOf('['),\r\n        e = str.indexOf(']');\r\n\r\n    if (b != -1 && e != -1) {\r\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\r\n    }\r\n\r\n    var m = re.exec(str || ''),\r\n        uri = {},\r\n        i = 14;\r\n\r\n    while (i--) {\r\n        uri[parts[i]] = m[i] || '';\r\n    }\r\n\r\n    if (b != -1 && e != -1) {\r\n        uri.source = src;\r\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\r\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\r\n        uri.ipv6uri = true;\r\n    }\r\n\r\n    return uri;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/parseuri/index.js\n// module id = 57\n// module chunks = 0","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/process/browser.js\n// module id = 58\n// module chunks = 0","/* global Blob File */\n\n/*\n * Module requirements.\n */\n\nvar isArray = require('isarray');\n\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof global.Blob === 'function' || toString.call(global.Blob) === '[object BlobConstructor]';\nvar withNativeFile = typeof global.File === 'function' || toString.call(global.File) === '[object FileConstructor]';\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Supports Buffer, ArrayBuffer, Blob and File.\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary (obj) {\n  if (!obj || typeof obj !== 'object') {\n    return false;\n  }\n\n  if (isArray(obj)) {\n    for (var i = 0, l = obj.length; i < l; i++) {\n      if (hasBinary(obj[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  if ((typeof global.Buffer === 'function' && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||\n     (typeof global.ArrayBuffer === 'function' && obj instanceof ArrayBuffer) ||\n     (withNativeBlob && obj instanceof Blob) ||\n     (withNativeFile && obj instanceof File)\n    ) {\n    return true;\n  }\n\n  // see: https://github.com/Automattic/has-binary/pull/4\n  if (obj.toJSON && typeof obj.toJSON === 'function' && arguments.length === 1) {\n    return hasBinary(obj.toJSON(), true);\n  }\n\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/has-binary2/index.js\n// module id = 59\n// module chunks = 0","\nmodule.exports = isBuf;\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n  return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer);\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-parser/is-buffer.js\n// module id = 60\n// module chunks = 0","\n/**\n * Module dependencies.\n */\n\nvar eio = require('engine.io-client');\nvar Socket = require('./socket');\nvar Emitter = require('component-emitter');\nvar parser = require('socket.io-parser');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:manager');\nvar indexOf = require('indexof');\nvar Backoff = require('backo2');\n\n/**\n * IE6+ hasOwnProperty\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager (uri, opts) {\n  if (!(this instanceof Manager)) return new Manager(uri, opts);\n  if (uri && ('object' === typeof uri)) {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n\n  opts.path = opts.path || '/socket.io';\n  this.nsps = {};\n  this.subs = [];\n  this.opts = opts;\n  this.reconnection(opts.reconnection !== false);\n  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n  this.randomizationFactor(opts.randomizationFactor || 0.5);\n  this.backoff = new Backoff({\n    min: this.reconnectionDelay(),\n    max: this.reconnectionDelayMax(),\n    jitter: this.randomizationFactor()\n  });\n  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n  this.readyState = 'closed';\n  this.uri = uri;\n  this.connecting = [];\n  this.lastPing = null;\n  this.encoding = false;\n  this.packetBuffer = [];\n  var _parser = opts.parser || parser;\n  this.encoder = new _parser.Encoder();\n  this.decoder = new _parser.Decoder();\n  this.autoConnect = opts.autoConnect !== false;\n  if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function () {\n  this.emit.apply(this, arguments);\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n    }\n  }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function () {\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].id = this.generateId(nsp);\n    }\n  }\n};\n\n/**\n * generate `socket.id` for the given `nsp`\n *\n * @param {String} nsp\n * @return {String}\n * @api private\n */\n\nManager.prototype.generateId = function (nsp) {\n  return (nsp === '/' ? '' : (nsp + '#')) + this.engine.id;\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function (v) {\n  if (!arguments.length) return this._reconnection;\n  this._reconnection = !!v;\n  return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function (v) {\n  if (!arguments.length) return this._reconnectionAttempts;\n  this._reconnectionAttempts = v;\n  return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function (v) {\n  if (!arguments.length) return this._reconnectionDelay;\n  this._reconnectionDelay = v;\n  this.backoff && this.backoff.setMin(v);\n  return this;\n};\n\nManager.prototype.randomizationFactor = function (v) {\n  if (!arguments.length) return this._randomizationFactor;\n  this._randomizationFactor = v;\n  this.backoff && this.backoff.setJitter(v);\n  return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function (v) {\n  if (!arguments.length) return this._reconnectionDelayMax;\n  this._reconnectionDelayMax = v;\n  this.backoff && this.backoff.setMax(v);\n  return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function (v) {\n  if (!arguments.length) return this._timeout;\n  this._timeout = v;\n  return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function () {\n  // Only try to reconnect if it's the first time we're connecting\n  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n    // keeps reconnection from firing twice for the same reconnection loop\n    this.reconnect();\n  }\n};\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function (fn, opts) {\n  debug('readyState %s', this.readyState);\n  if (~this.readyState.indexOf('open')) return this;\n\n  debug('opening %s', this.uri);\n  this.engine = eio(this.uri, this.opts);\n  var socket = this.engine;\n  var self = this;\n  this.readyState = 'opening';\n  this.skipReconnect = false;\n\n  // emit `open`\n  var openSub = on(socket, 'open', function () {\n    self.onopen();\n    fn && fn();\n  });\n\n  // emit `connect_error`\n  var errorSub = on(socket, 'error', function (data) {\n    debug('connect_error');\n    self.cleanup();\n    self.readyState = 'closed';\n    self.emitAll('connect_error', data);\n    if (fn) {\n      var err = new Error('Connection error');\n      err.data = data;\n      fn(err);\n    } else {\n      // Only do this if there is no fn to handle the error\n      self.maybeReconnectOnOpen();\n    }\n  });\n\n  // emit `connect_timeout`\n  if (false !== this._timeout) {\n    var timeout = this._timeout;\n    debug('connect attempt will timeout after %d', timeout);\n\n    // set timer\n    var timer = setTimeout(function () {\n      debug('connect attempt timed out after %d', timeout);\n      openSub.destroy();\n      socket.close();\n      socket.emit('error', 'timeout');\n      self.emitAll('connect_timeout', timeout);\n    }, timeout);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n\n  this.subs.push(openSub);\n  this.subs.push(errorSub);\n\n  return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function () {\n  debug('open');\n\n  // clear old subs\n  this.cleanup();\n\n  // mark as open\n  this.readyState = 'open';\n  this.emit('open');\n\n  // add new subs\n  var socket = this.engine;\n  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n};\n\n/**\n * Called upon a ping.\n *\n * @api private\n */\n\nManager.prototype.onping = function () {\n  this.lastPing = new Date();\n  this.emitAll('ping');\n};\n\n/**\n * Called upon a packet.\n *\n * @api private\n */\n\nManager.prototype.onpong = function () {\n  this.emitAll('pong', new Date() - this.lastPing);\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function (data) {\n  this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function (err) {\n  debug('error', err);\n  this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function (nsp, opts) {\n  var socket = this.nsps[nsp];\n  if (!socket) {\n    socket = new Socket(this, nsp, opts);\n    this.nsps[nsp] = socket;\n    var self = this;\n    socket.on('connecting', onConnecting);\n    socket.on('connect', function () {\n      socket.id = self.generateId(nsp);\n    });\n\n    if (this.autoConnect) {\n      // manually call here since connecting event is fired before listening\n      onConnecting();\n    }\n  }\n\n  function onConnecting () {\n    if (!~indexOf(self.connecting, socket)) {\n      self.connecting.push(socket);\n    }\n  }\n\n  return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function (socket) {\n  var index = indexOf(this.connecting, socket);\n  if (~index) this.connecting.splice(index, 1);\n  if (this.connecting.length) return;\n\n  this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function (packet) {\n  debug('writing packet %j', packet);\n  var self = this;\n  if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;\n\n  if (!self.encoding) {\n    // encode, then write to engine with result\n    self.encoding = true;\n    this.encoder.encode(packet, function (encodedPackets) {\n      for (var i = 0; i < encodedPackets.length; i++) {\n        self.engine.write(encodedPackets[i], packet.options);\n      }\n      self.encoding = false;\n      self.processPacketQueue();\n    });\n  } else { // add packet to the queue\n    self.packetBuffer.push(packet);\n  }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function () {\n  if (this.packetBuffer.length > 0 && !this.encoding) {\n    var pack = this.packetBuffer.shift();\n    this.packet(pack);\n  }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function () {\n  debug('cleanup');\n\n  var subsLength = this.subs.length;\n  for (var i = 0; i < subsLength; i++) {\n    var sub = this.subs.shift();\n    sub.destroy();\n  }\n\n  this.packetBuffer = [];\n  this.encoding = false;\n  this.lastPing = null;\n\n  this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function () {\n  debug('disconnect');\n  this.skipReconnect = true;\n  this.reconnecting = false;\n  if ('opening' === this.readyState) {\n    // `onclose` will not fire because\n    // an open event never happened\n    this.cleanup();\n  }\n  this.backoff.reset();\n  this.readyState = 'closed';\n  if (this.engine) this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function (reason) {\n  debug('onclose');\n\n  this.cleanup();\n  this.backoff.reset();\n  this.readyState = 'closed';\n  this.emit('close', reason);\n\n  if (this._reconnection && !this.skipReconnect) {\n    this.reconnect();\n  }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function () {\n  if (this.reconnecting || this.skipReconnect) return this;\n\n  var self = this;\n\n  if (this.backoff.attempts >= this._reconnectionAttempts) {\n    debug('reconnect failed');\n    this.backoff.reset();\n    this.emitAll('reconnect_failed');\n    this.reconnecting = false;\n  } else {\n    var delay = this.backoff.duration();\n    debug('will wait %dms before reconnect attempt', delay);\n\n    this.reconnecting = true;\n    var timer = setTimeout(function () {\n      if (self.skipReconnect) return;\n\n      debug('attempting reconnect');\n      self.emitAll('reconnect_attempt', self.backoff.attempts);\n      self.emitAll('reconnecting', self.backoff.attempts);\n\n      // check again for the case socket closed in above events\n      if (self.skipReconnect) return;\n\n      self.open(function (err) {\n        if (err) {\n          debug('reconnect attempt error');\n          self.reconnecting = false;\n          self.reconnect();\n          self.emitAll('reconnect_error', err.data);\n        } else {\n          debug('reconnect success');\n          self.onreconnect();\n        }\n      });\n    }, delay);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function () {\n  var attempt = this.backoff.attempts;\n  this.reconnecting = false;\n  this.backoff.reset();\n  this.updateSocketIds();\n  this.emitAll('reconnect', attempt);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-client/lib/manager.js\n// module id = 61\n// module chunks = 0","/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar XHR = require('./polling-xhr');\nvar JSONP = require('./polling-jsonp');\nvar websocket = require('./websocket');\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling (opts) {\n  var xhr;\n  var xd = false;\n  var xs = false;\n  var jsonp = false !== opts.jsonp;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    xd = opts.hostname !== location.hostname || port !== opts.port;\n    xs = opts.secure !== isSSL;\n  }\n\n  opts.xdomain = xd;\n  opts.xscheme = xs;\n  xhr = new XMLHttpRequest(opts);\n\n  if ('open' in xhr && !opts.forceJSONP) {\n    return new XHR(opts);\n  } else {\n    if (!jsonp) throw new Error('JSONP disabled');\n    return new JSONP(opts);\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transports/index.js\n// module id = 62\n// module chunks = 0","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parseqs = require('parseqs');\nvar parser = require('engine.io-parser');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function () {\n  var XMLHttpRequest = require('xmlhttprequest-ssl');\n  var xhr = new XMLHttpRequest({ xdomain: false });\n  return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (!hasXHR2 || forceBase64) {\n    this.supportsBinary = false;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function () {\n  this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function (onPause) {\n  var self = this;\n\n  this.readyState = 'pausing';\n\n  function pause () {\n    debug('paused');\n    self.readyState = 'paused';\n    onPause();\n  }\n\n  if (this.polling || !this.writable) {\n    var total = 0;\n\n    if (this.polling) {\n      debug('we are currently polling - waiting to pause');\n      total++;\n      this.once('pollComplete', function () {\n        debug('pre-pause polling complete');\n        --total || pause();\n      });\n    }\n\n    if (!this.writable) {\n      debug('we are currently writing - waiting to pause');\n      total++;\n      this.once('drain', function () {\n        debug('pre-pause writing complete');\n        --total || pause();\n      });\n    }\n  } else {\n    pause();\n  }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function () {\n  debug('polling');\n  this.polling = true;\n  this.doPoll();\n  this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function (data) {\n  var self = this;\n  debug('polling got data %s', data);\n  var callback = function (packet, index, total) {\n    // if its the first message we consider the transport open\n    if ('opening' === self.readyState) {\n      self.onOpen();\n    }\n\n    // if its a close packet, we close the ongoing requests\n    if ('close' === packet.type) {\n      self.onClose();\n      return false;\n    }\n\n    // otherwise bypass onData and handle the message\n    self.onPacket(packet);\n  };\n\n  // decode payload\n  parser.decodePayload(data, this.socket.binaryType, callback);\n\n  // if an event did not trigger closing\n  if ('closed' !== this.readyState) {\n    // if we got data we're not polling\n    this.polling = false;\n    this.emit('pollComplete');\n\n    if ('open' === this.readyState) {\n      this.poll();\n    } else {\n      debug('ignoring poll - transport state \"%s\"', this.readyState);\n    }\n  }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function () {\n  var self = this;\n\n  function close () {\n    debug('writing close packet');\n    self.write([{ type: 'close' }]);\n  }\n\n  if ('open' === this.readyState) {\n    debug('transport open - closing');\n    close();\n  } else {\n    // in case we're trying to close while\n    // handshaking is in progress (GH-164)\n    debug('transport not open - deferring close');\n    this.once('open', close);\n  }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n  var callbackfn = function () {\n    self.writable = true;\n    self.emit('drain');\n  };\n\n  parser.encodePayload(packets, this.supportsBinary, function (data) {\n    self.doWrite(data, callbackfn);\n  });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'https' : 'http';\n  var port = '';\n\n  // cache busting is forced\n  if (false !== this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  if (!this.supportsBinary && !query.sid) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // avoid port if default for schema\n  if (this.port && (('https' === schema && Number(this.port) !== 443) ||\n     ('http' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transports/polling.js\n// module id = 63\n// module chunks = 0","'use strict';\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/yeast/index.js\n// module id = 64\n// module chunks = 0","\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/indexof/index.js\n// module id = 65\n// module chunks = 0","\n/**\n * Module dependencies.\n */\n\nvar parser = require('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar toArray = require('to-array');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:socket');\nvar parseqs = require('parseqs');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n  connect: 1,\n  connect_error: 1,\n  connect_timeout: 1,\n  connecting: 1,\n  disconnect: 1,\n  error: 1,\n  reconnect: 1,\n  reconnect_attempt: 1,\n  reconnect_failed: 1,\n  reconnect_error: 1,\n  reconnecting: 1,\n  ping: 1,\n  pong: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket (io, nsp, opts) {\n  this.io = io;\n  this.nsp = nsp;\n  this.json = this; // compat\n  this.ids = 0;\n  this.acks = {};\n  this.receiveBuffer = [];\n  this.sendBuffer = [];\n  this.connected = false;\n  this.disconnected = true;\n  if (opts && opts.query) {\n    this.query = opts.query;\n  }\n  if (this.io.autoConnect) this.open();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function () {\n  if (this.subs) return;\n\n  var io = this.io;\n  this.subs = [\n    on(io, 'open', bind(this, 'onopen')),\n    on(io, 'packet', bind(this, 'onpacket')),\n    on(io, 'close', bind(this, 'onclose'))\n  ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function () {\n  if (this.connected) return this;\n\n  this.subEvents();\n  this.io.open(); // ensure open\n  if ('open' === this.io.readyState) this.onopen();\n  this.emit('connecting');\n  return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function () {\n  var args = toArray(arguments);\n  args.unshift('message');\n  this.emit.apply(this, args);\n  return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function (ev) {\n  if (events.hasOwnProperty(ev)) {\n    emit.apply(this, arguments);\n    return this;\n  }\n\n  var args = toArray(arguments);\n  var packet = { type: parser.EVENT, data: args };\n\n  packet.options = {};\n  packet.options.compress = !this.flags || false !== this.flags.compress;\n\n  // event ack callback\n  if ('function' === typeof args[args.length - 1]) {\n    debug('emitting packet with ack id %d', this.ids);\n    this.acks[this.ids] = args.pop();\n    packet.id = this.ids++;\n  }\n\n  if (this.connected) {\n    this.packet(packet);\n  } else {\n    this.sendBuffer.push(packet);\n  }\n\n  delete this.flags;\n\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function (packet) {\n  packet.nsp = this.nsp;\n  this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function () {\n  debug('transport is open - connecting');\n\n  // write connect packet if necessary\n  if ('/' !== this.nsp) {\n    if (this.query) {\n      var query = typeof this.query === 'object' ? parseqs.encode(this.query) : this.query;\n      debug('sending connect packet with query %s', query);\n      this.packet({type: parser.CONNECT, query: query});\n    } else {\n      this.packet({type: parser.CONNECT});\n    }\n  }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function (reason) {\n  debug('close (%s)', reason);\n  this.connected = false;\n  this.disconnected = true;\n  delete this.id;\n  this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function (packet) {\n  if (packet.nsp !== this.nsp) return;\n\n  switch (packet.type) {\n    case parser.CONNECT:\n      this.onconnect();\n      break;\n\n    case parser.EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.BINARY_EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.ACK:\n      this.onack(packet);\n      break;\n\n    case parser.BINARY_ACK:\n      this.onack(packet);\n      break;\n\n    case parser.DISCONNECT:\n      this.ondisconnect();\n      break;\n\n    case parser.ERROR:\n      this.emit('error', packet.data);\n      break;\n  }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function (packet) {\n  var args = packet.data || [];\n  debug('emitting event %j', args);\n\n  if (null != packet.id) {\n    debug('attaching ack callback to event');\n    args.push(this.ack(packet.id));\n  }\n\n  if (this.connected) {\n    emit.apply(this, args);\n  } else {\n    this.receiveBuffer.push(args);\n  }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function (id) {\n  var self = this;\n  var sent = false;\n  return function () {\n    // prevent double callbacks\n    if (sent) return;\n    sent = true;\n    var args = toArray(arguments);\n    debug('sending ack %j', args);\n\n    self.packet({\n      type: parser.ACK,\n      id: id,\n      data: args\n    });\n  };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function (packet) {\n  var ack = this.acks[packet.id];\n  if ('function' === typeof ack) {\n    debug('calling ack %s with %j', packet.id, packet.data);\n    ack.apply(this, packet.data);\n    delete this.acks[packet.id];\n  } else {\n    debug('bad ack %s', packet.id);\n  }\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function () {\n  this.connected = true;\n  this.disconnected = false;\n  this.emit('connect');\n  this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function () {\n  var i;\n  for (i = 0; i < this.receiveBuffer.length; i++) {\n    emit.apply(this, this.receiveBuffer[i]);\n  }\n  this.receiveBuffer = [];\n\n  for (i = 0; i < this.sendBuffer.length; i++) {\n    this.packet(this.sendBuffer[i]);\n  }\n  this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function () {\n  debug('server disconnect (%s)', this.nsp);\n  this.destroy();\n  this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function () {\n  if (this.subs) {\n    // clean subscriptions to avoid reconnections\n    for (var i = 0; i < this.subs.length; i++) {\n      this.subs[i].destroy();\n    }\n    this.subs = null;\n  }\n\n  this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function () {\n  if (this.connected) {\n    debug('performing disconnect (%s)', this.nsp);\n    this.packet({ type: parser.DISCONNECT });\n  }\n\n  // remove socket from pool\n  this.destroy();\n\n  if (this.connected) {\n    // fire events\n    this.onclose('io client disconnect');\n  }\n  return this;\n};\n\n/**\n * Sets the compress flag.\n *\n * @param {Boolean} if `true`, compresses the sending data\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.compress = function (compress) {\n  this.flags = this.flags || {};\n  this.flags.compress = compress;\n  return this;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-client/lib/socket.js\n// module id = 66\n// module chunks = 0","\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on (obj, ev, fn) {\n  obj.on(ev, fn);\n  return {\n    destroy: function () {\n      obj.removeListener(ev, fn);\n    }\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-client/lib/on.js\n// module id = 67\n// module chunks = 0","/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n  if ('string' == typeof fn) fn = obj[fn];\n  if ('function' != typeof fn) throw new Error('bind() requires a function');\n  var args = slice.call(arguments, 2);\n  return function(){\n    return fn.apply(obj, args.concat(slice.call(arguments)));\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/component-bind/index.js\n// module id = 68\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an action is invalid because the object has been\n * unsubscribed.\n *\n * @see {@link Subject}\n * @see {@link BehaviorSubject}\n *\n * @class ObjectUnsubscribedError\n */\nvar ObjectUnsubscribedError = (function (_super) {\n    __extends(ObjectUnsubscribedError, _super);\n    function ObjectUnsubscribedError() {\n        var err = _super.call(this, 'object unsubscribed');\n        this.name = err.name = 'ObjectUnsubscribedError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ObjectUnsubscribedError;\n}(Error));\nexports.ObjectUnsubscribedError = ObjectUnsubscribedError;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/ObjectUnsubscribedError.js\n// module id = 69\n// module chunks = 0","\"use strict\";\nvar multicast_1 = require('./multicast');\nvar refCount_1 = require('./refCount');\nvar Subject_1 = require('../Subject');\nfunction shareSubjectFactory() {\n    return new Subject_1.Subject();\n}\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n * This is an alias for .multicast(() => new Subject()).refCount().\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return function (source) { return refCount_1.refCount()(multicast_1.multicast(shareSubjectFactory)(source)); };\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/share.js\n// module id = 70\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nfunction refCount() {\n    return function refCountOperatorFunction(source) {\n        return source.lift(new RefCountOperator(source));\n    };\n}\nexports.refCount = refCount;\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=refCount.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/refCount.js\n// module id = 71\n// module chunks = 0","import { map } from \"rxjs/operators/map\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { Observable } from \"rxjs/Observable\";\nimport { Events } from \"../dom-effects\";\nimport * as Log from \"../log\";\n\nexport interface PropSetPayload {\n    target: Element;\n    prop: string;\n    value: string;\n    pathname: string;\n}\n\nexport function propSetDomEffect(xs: Observable<PropSetPayload>) {\n    return xs.pipe(\n        tap(event => {\n            const { target, prop, value } = event;\n            target[prop] = value;\n        }),\n        map(e =>\n            Log.consoleInfo(`[PropSet]`, e.target, `${e.prop} = ${e.pathname}`)\n        )\n    );\n}\n\nexport function propSet(incoming: PropSetPayload): [Events.PropSet, any] {\n    return [Events.PropSet, incoming];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects/prop-set.dom-effect.ts","\"use strict\";\nvar isArray_1 = require('../util/isArray');\nfunction isNumeric(val) {\n    // parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    // adding 1 corrects loss of precision from parseFloat (#15100)\n    return !isArray_1.isArray(val) && (val - parseFloat(val) + 1) >= 0;\n}\nexports.isNumeric = isNumeric;\n;\n//# sourceMappingURL=isNumeric.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isNumeric.js\n// module id = 73\n// module chunks = 0","\"use strict\";\nvar AsyncAction_1 = require('./AsyncAction');\nvar AsyncScheduler_1 = require('./AsyncScheduler');\n/**\n *\n * Async Scheduler\n *\n * <span class=\"informal\">Schedule task as if you used setTimeout(task, duration)</span>\n *\n * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript\n * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating\n * in intervals.\n *\n * If you just want to \"defer\" task, that is to perform it right after currently\n * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),\n * better choice will be the {@link asap} scheduler.\n *\n * @example <caption>Use async scheduler to delay task</caption>\n * const task = () => console.log('it works!');\n *\n * Rx.Scheduler.async.schedule(task, 2000);\n *\n * // After 2 seconds logs:\n * // \"it works!\"\n *\n *\n * @example <caption>Use async scheduler to repeat task in intervals</caption>\n * function task(state) {\n *   console.log(state);\n *   this.schedule(state + 1, 1000); // `this` references currently executing Action,\n *                                   // which we reschedule with new state and delay\n * }\n *\n * Rx.Scheduler.async.schedule(task, 3000, 0);\n *\n * // Logs:\n * // 0 after 3s\n * // 1 after 4s\n * // 2 after 5s\n * // 3 after 6s\n *\n * @static true\n * @name async\n * @owner Scheduler\n */\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/async.js\n// module id = 74\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Action_1 = require('./Action');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsyncAction = (function (_super) {\n    __extends(AsyncAction, _super);\n    function AsyncAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.work = work;\n        this.pending = false;\n    }\n    AsyncAction.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        if (this.closed) {\n            return this;\n        }\n        // Always replace the current state with the new state.\n        this.state = state;\n        // Set the pending flag indicating that this action has been scheduled, or\n        // has recursively rescheduled itself.\n        this.pending = true;\n        var id = this.id;\n        var scheduler = this.scheduler;\n        //\n        // Important implementation note:\n        //\n        // Actions only execute once by default, unless rescheduled from within the\n        // scheduled callback. This allows us to implement single and repeat\n        // actions via the same code path, without adding API surface area, as well\n        // as mimic traditional recursion but across asynchronous boundaries.\n        //\n        // However, JS runtimes and timers distinguish between intervals achieved by\n        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of\n        // serial `setTimeout` calls can be individually delayed, which delays\n        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to\n        // guarantee the interval callback will be invoked more precisely to the\n        // interval period, regardless of load.\n        //\n        // Therefore, we use `setInterval` to schedule single and repeat actions.\n        // If the action reschedules itself with the same delay, the interval is not\n        // canceled. If the action doesn't reschedule, or reschedules with a\n        // different delay, the interval will be canceled after scheduled callback\n        // execution.\n        //\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, delay);\n        }\n        this.delay = delay;\n        // If this action has already an async Id, don't request a new one.\n        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);\n        return this;\n    };\n    AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        return root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);\n    };\n    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If this action is rescheduled with the same delay time, don't clear the interval id.\n        if (delay !== null && this.delay === delay && this.pending === false) {\n            return id;\n        }\n        // Otherwise, if the action's delay time is different from the current delay,\n        // or the action has been rescheduled before it's executed, clear the interval id\n        return root_1.root.clearInterval(id) && undefined || undefined;\n    };\n    /**\n     * Immediately executes this action and the `work` it contains.\n     * @return {any}\n     */\n    AsyncAction.prototype.execute = function (state, delay) {\n        if (this.closed) {\n            return new Error('executing a cancelled action');\n        }\n        this.pending = false;\n        var error = this._execute(state, delay);\n        if (error) {\n            return error;\n        }\n        else if (this.pending === false && this.id != null) {\n            // Dequeue if the action didn't reschedule itself. Don't call\n            // unsubscribe(), because the action could reschedule later.\n            // For example:\n            // ```\n            // scheduler.schedule(function doWork(counter) {\n            //   /* ... I'm a busy worker bee ... */\n            //   var originalAction = this;\n            //   /* wait 100ms before rescheduling the action */\n            //   setTimeout(function () {\n            //     originalAction.schedule(counter + 1);\n            //   }, 100);\n            // }, 1000);\n            // ```\n            this.id = this.recycleAsyncId(this.scheduler, this.id, null);\n        }\n    };\n    AsyncAction.prototype._execute = function (state, delay) {\n        var errored = false;\n        var errorValue = undefined;\n        try {\n            this.work(state);\n        }\n        catch (e) {\n            errored = true;\n            errorValue = !!e && e || new Error(e);\n        }\n        if (errored) {\n            this.unsubscribe();\n            return errorValue;\n        }\n    };\n    AsyncAction.prototype._unsubscribe = function () {\n        var id = this.id;\n        var scheduler = this.scheduler;\n        var actions = scheduler.actions;\n        var index = actions.indexOf(this);\n        this.work = null;\n        this.state = null;\n        this.pending = false;\n        this.scheduler = null;\n        if (index !== -1) {\n            actions.splice(index, 1);\n        }\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, null);\n        }\n        this.delay = null;\n    };\n    return AsyncAction;\n}(Action_1.Action));\nexports.AsyncAction = AsyncAction;\n//# sourceMappingURL=AsyncAction.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/AsyncAction.js\n// module id = 75\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Scheduler_1 = require('../Scheduler');\nvar AsyncScheduler = (function (_super) {\n    __extends(AsyncScheduler, _super);\n    function AsyncScheduler() {\n        _super.apply(this, arguments);\n        this.actions = [];\n        /**\n         * A flag to indicate whether the Scheduler is currently executing a batch of\n         * queued actions.\n         * @type {boolean}\n         */\n        this.active = false;\n        /**\n         * An internal ID used to track the latest asynchronous task such as those\n         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and\n         * others.\n         * @type {any}\n         */\n        this.scheduled = undefined;\n    }\n    AsyncScheduler.prototype.flush = function (action) {\n        var actions = this.actions;\n        if (this.active) {\n            actions.push(action);\n            return;\n        }\n        var error;\n        this.active = true;\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (action = actions.shift()); // exhaust the scheduler queue\n        this.active = false;\n        if (error) {\n            while (action = actions.shift()) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsyncScheduler;\n}(Scheduler_1.Scheduler));\nexports.AsyncScheduler = AsyncScheduler;\n//# sourceMappingURL=AsyncScheduler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/AsyncScheduler.js\n// module id = 76\n// module chunks = 0","import { map } from \"rxjs/operators/map\";\nimport { Events } from \"../dom-effects\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as Log from \"../log\";\n\nexport interface StyleSetPayload {\n    style: string;\n    styleName: string;\n    value: string;\n    newValue: string;\n    pathName: string;\n}\n\nexport function styleSetDomEffect(xs: Observable<StyleSetPayload>) {\n    return xs.pipe(\n        tap(event => {\n            const { style, styleName, newValue } = event;\n            style[styleName] = newValue;\n        }),\n        map(e => Log.consoleInfo(`[StyleSet] ${e.styleName} = ${e.pathName}`))\n    );\n}\n\nexport function styleSet(incoming: StyleSetPayload): [Events.StyleSet, any] {\n    return [Events.StyleSet, incoming];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects/style-set.dom-effect.ts","import { map } from \"rxjs/operators/map\";\nimport { Inputs } from \"../index\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as Log from \"../log\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { Events } from \"../dom-effects\";\n\nexport type LinkReplacePayload = {\n    target: HTMLLinkElement;\n    nextHref: string;\n    prevHref: string;\n    pathname: string;\n    basename: string;\n};\n\nexport function linkReplaceDomEffect(\n    xs: Observable<LinkReplacePayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom<LinkReplacePayload, any>(\n            inputs.option$.pipe(pluck(\"injectNotification\"))\n        ),\n        filter(([, inject]) => inject),\n        map(([incoming, inject]) => {\n            const message = `[LinkReplace] ${incoming.basename}`;\n            if (inject === \"overlay\") {\n                return Log.overlayInfo(message);\n            }\n            return Log.consoleInfo(message);\n        })\n    );\n}\n\nexport function linkReplace(\n    incoming: LinkReplacePayload\n): [Events.LinkReplace, LinkReplacePayload] {\n    return [Events.LinkReplace, incoming];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects/link-replace.dom-effect.ts","import { Inputs } from \"../index\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { Observable } from \"rxjs/Observable\";\nimport { Events } from \"../dom-effects\";\n\nexport type SetScrollPayload = { x: number; y: number };\n\nexport function setScroll(\n    x: number,\n    y: number\n): [Events.SetScroll, SetScrollPayload] {\n    return [Events.SetScroll, { x, y }];\n}\n\nexport function setScrollDomEffect(\n    xs: Observable<SetScrollPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.window$),\n        tap(([event, window]) => window.scrollTo(event.x, event.y)),\n        ignoreElements()\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects/set-scroll.dom-effect.ts","import { Inputs } from \"../index\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { Observable } from \"rxjs/Observable\";\nimport { Events } from \"../dom-effects\";\n\nexport function setWindowNameDomEffect(xs: Observable<string>, inputs: Inputs) {\n    return xs.pipe(\n        withLatestFrom(inputs.window$),\n        tap(([value, window]) => (window.name = value)),\n        ignoreElements()\n    );\n}\n\nexport function setWindowName(\n    incoming: string\n): [Events.SetWindowName, string] {\n    return [Events.SetWindowName, incoming];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/dom-effects/set-window-name.dom-effect.ts","import { OutgoingSocketEvents } from \"../socket-messages\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { EffectNames } from \"../effects\";\n\nexport interface ICoords {\n    x: number;\n    y: number;\n}\n\nexport interface Data {\n    raw: ICoords;\n    proportional: number;\n}\n\nexport interface OutgoingPayload {\n    position: Data;\n    tagName: string;\n    index: number;\n    mappingIndex: number;\n}\n\nexport interface IncomingPayload extends OutgoingPayload {\n    override?: boolean;\n    pathname: string;\n}\n\nexport function outgoing(\n    data: Data,\n    tagName: string,\n    index: number,\n    mappingIndex: number = -1\n): [OutgoingSocketEvents.Scroll, OutgoingPayload] {\n    return [\n        OutgoingSocketEvents.Scroll,\n        { position: data, tagName, index, mappingIndex }\n    ];\n}\n\nexport function incomingScrollHandler(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(\n            inputs.option$.pipe(pluck(\"ghostMode\", \"scroll\")),\n            inputs.window$.pipe(pluck(\"location\", \"pathname\"))\n        ),\n        filter(([event, canScroll, pathname]) => {\n            return canScroll && event.pathname === pathname;\n        }),\n        map(([event]) => {\n            return [EffectNames.BrowserSetScroll, event];\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/ScrollEvent.ts","import { FileReloadEventPayload } from \"../../types/socket\";\nimport { EffectNames } from \"../effects\";\nimport { Inputs } from \"../index\";\nimport { reload } from \"../../vendor/Reloader\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { Observable } from \"rxjs/Observable\";\n\nexport function fileReload(event: FileReloadEventPayload) {\n    return [EffectNames.FileReload, event];\n}\n\n/**\n * Attempt to reload files in place\n * @param xs\n * @param inputs\n */\nexport function fileReloadEffect(\n    xs: Observable<FileReloadEventPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.option$, inputs.document$, inputs.navigator$),\n        mergeMap(([event, options, document, navigator]) => {\n            return reload(document, navigator)(event, {\n                tagNames: options.tagNames,\n                liveCSS: true,\n                liveImg: true\n            });\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/file-reload.effect.ts","\"use strict\";\nvar FromObservable_1 = require('./FromObservable');\nexports.from = FromObservable_1.FromObservable.create;\n//# sourceMappingURL=from.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/from.js\n// module id = 83\n// module chunks = 0","\"use strict\";\nvar mergeMap_1 = require('./mergeMap');\nvar identity_1 = require('../util/identity');\n/**\n * Converts a higher-order Observable into a first-order Observable which\n * concurrently delivers all values that are emitted on the inner Observables.\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables.</span>\n *\n * <img src=\"./img/mergeAll.png\" width=\"100%\">\n *\n * `mergeAll` subscribes to an Observable that emits Observables, also known as\n * a higher-order Observable. Each time it observes one of these emitted inner\n * Observables, it subscribes to that and delivers all the values from the\n * inner Observable on the output Observable. The output Observable only\n * completes once all inner Observables have completed. Any error delivered by\n * a inner Observable will be immediately emitted on the output Observable.\n *\n * @example <caption>Spawn a new interval Observable for each click event, and blend their outputs as one Observable</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000));\n * var firstOrder = higherOrder.mergeAll();\n * firstOrder.subscribe(x => console.log(x));\n *\n * @example <caption>Count from 0 to 9 every second for each click, but only allow 2 concurrent timers</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(10));\n * var firstOrder = higherOrder.mergeAll(2);\n * firstOrder.subscribe(x => console.log(x));\n *\n * @see {@link combineAll}\n * @see {@link concatAll}\n * @see {@link exhaust}\n * @see {@link merge}\n * @see {@link mergeMap}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switch}\n * @see {@link zipAll}\n *\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of inner\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits values coming from all the\n * inner Observables emitted by the source Observable.\n * @method mergeAll\n * @owner Observable\n */\nfunction mergeAll(concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return mergeMap_1.mergeMap(identity_1.identity, null, concurrent);\n}\nexports.mergeAll = mergeAll;\n//# sourceMappingURL=mergeAll.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/mergeAll.js\n// module id = 84\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Emits the given constant value on the output Observable every time the source\n * Observable emits a value.\n *\n * <span class=\"informal\">Like {@link map}, but it maps every source value to\n * the same output value every time.</span>\n *\n * <img src=\"./img/mapTo.png\" width=\"100%\">\n *\n * Takes a constant `value` as argument, and emits that whenever the source\n * Observable emits a value. In other words, ignores the actual source value,\n * and simply uses the emission moment to know when to emit the given `value`.\n *\n * @example <caption>Map every click to the string 'Hi'</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var greetings = clicks.mapTo('Hi');\n * greetings.subscribe(x => console.log(x));\n *\n * @see {@link map}\n *\n * @param {any} value The value to map each source value to.\n * @return {Observable} An Observable that emits the given `value` every time\n * the source Observable emits something.\n * @method mapTo\n * @owner Observable\n */\nfunction mapTo(value) {\n    return function (source) { return source.lift(new MapToOperator(value)); };\n}\nexports.mapTo = mapTo;\nvar MapToOperator = (function () {\n    function MapToOperator(value) {\n        this.value = value;\n    }\n    MapToOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapToSubscriber(subscriber, this.value));\n    };\n    return MapToOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapToSubscriber = (function (_super) {\n    __extends(MapToSubscriber, _super);\n    function MapToSubscriber(destination, value) {\n        _super.call(this, destination);\n        this.value = value;\n    }\n    MapToSubscriber.prototype._next = function (x) {\n        this.destination.next(this.value);\n    };\n    return MapToSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=mapTo.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/mapTo.js\n// module id = 85\n// module chunks = 0","import { Inputs } from \"../index\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { Observable } from \"rxjs/Observable\";\nimport { IncomingPayload } from \"../messages/BrowserLocation\";\nimport { EffectNames } from \"../effects\";\n\nexport function browserSetLocationEffect(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.window$),\n        tap(([event, window]) => {\n            if (event.path) {\n                return ((window.location as any) =\n                    window.location.protocol +\n                    \"//\" +\n                    window.location.host +\n                    event.path);\n            }\n            if (event.url) {\n                return ((window.location as any) = event.url);\n            }\n        }),\n        ignoreElements()\n    );\n}\n\nexport function browserSetLocation(input: IncomingPayload) {\n    return [EffectNames.BrowserSetLocation, input];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/browser-set-location.effect.ts","import { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport * as ClickEvent from \"../messages/ClickEvent\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { EffectNames } from \"../effects\";\nimport { IncomingPayload } from \"../messages/ClickEvent\";\n\nexport function simulateClickEffect(\n    xs: Observable<ClickEvent.IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.window$, inputs.document$),\n        tap(([event, window, document]) => {\n            const elems = document.getElementsByTagName(event.tagName);\n            const match = elems[event.index];\n\n            if (match) {\n                if (document.createEvent) {\n                    window.setTimeout(function() {\n                        const evObj = document.createEvent(\"MouseEvents\");\n                        evObj.initEvent(\"click\", true, true);\n                        match.dispatchEvent(evObj);\n                    }, 0);\n                } else {\n                    window.setTimeout(function() {\n                        if ((document as any).createEventObject) {\n                            const evObj = (document as any).createEventObject();\n                            evObj.cancelBubble = true;\n                            (match as any).fireEvent(\"on\" + \"click\", evObj);\n                        }\n                    }, 0);\n                }\n            }\n        }),\n        ignoreElements()\n    );\n}\n\nexport function simulateClick(event: IncomingPayload) {\n    return [EffectNames.SimulateClick, event];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/simulate-click.effect.ts","import { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as KeyupEvent from \"../messages/KeyupEvent\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { EffectNames } from \"../effects\";\n\nexport function setElementValueEffect(\n    xs: Observable<KeyupEvent.IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.document$),\n        tap(([event, document]) => {\n            const elems = document.getElementsByTagName(event.tagName);\n            const match = elems[event.index];\n            if (match) {\n                (match as HTMLInputElement).value = event.value;\n            }\n        })\n    );\n}\n\nexport function setElementValue(event: KeyupEvent.IncomingPayload) {\n    return [EffectNames.SetElementValue, event];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/set-element-value.effect.ts","import { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as FormToggleEvent from \"../messages/FormToggleEvent\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { EffectNames } from \"../effects\";\n\nexport function setElementToggleValueEffect(\n    xs: Observable<FormToggleEvent.IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.document$),\n        tap(([event, document]) => {\n            const elems = document.getElementsByTagName(event.tagName);\n            const match = <HTMLInputElement>elems[event.index];\n            if (match) {\n                if (event.type === \"radio\") {\n                    match.checked = true;\n                }\n                if (event.type === \"checkbox\") {\n                    match.checked = event.checked;\n                }\n                if (event.tagName === \"SELECT\") {\n                    match.value = event.value;\n                }\n            }\n        })\n    );\n}\n\nexport function setElementToggleValue(event: FormToggleEvent.IncomingPayload) {\n    return [EffectNames.SetElementToggleValue, event];\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/set-element-toggle-value.effect.ts","import { EffectNames } from \"../effects\";\nimport { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\n\nexport function browserReload() {\n    return [EffectNames.BrowserReload];\n}\n\nexport function preBrowserReload() {\n    return [EffectNames.PreBrowserReload];\n}\n\nexport function browserReloadEffect(xs: Observable<any>, inputs: Inputs) {\n    return xs.pipe(\n        withLatestFrom(inputs.window$),\n        tap(([, window]) => window.location.reload(true))\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/browser-reload.effect.ts","import { OutgoingSocketEvents } from \"../socket-messages\";\nimport { Inputs } from \"../index\";\nimport { Observable } from \"rxjs/Observable\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { simulateClick } from \"../effects/simulate-click.effect\";\n\nexport interface ElementData {\n    tagName: string;\n    index: number;\n}\n\nexport interface IncomingPayload extends ElementData {\n    pathname: string;\n}\n\nexport function outgoing(\n    data: ElementData\n): [OutgoingSocketEvents.Click, ElementData] {\n    return [OutgoingSocketEvents.Click, data];\n}\n\nexport function incomingHandler$(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(\n            inputs.option$.pipe(pluck(\"ghostMode\", \"clicks\")),\n            inputs.window$.pipe(pluck(\"location\", \"pathname\"))\n        ),\n        filter(([event, canClick, pathname]) => {\n            return canClick && event.pathname === pathname;\n        }),\n        map(([event]) => {\n            return simulateClick(event);\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/ClickEvent.ts","import { OutgoingSocketEvents } from \"../socket-messages\";\nimport * as ClickEvent from \"./ClickEvent\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { setElementValue } from \"../effects/set-element-value.effect\";\n\nexport interface Payload {\n    value: any;\n    tagName: string;\n    index: number;\n}\n\nexport type OutgoingPayload = Payload;\n\nexport interface IncomingPayload extends OutgoingPayload {\n    pathname: string;\n}\n\nexport function outgoing(\n    element: ClickEvent.ElementData,\n    value: any\n): [OutgoingSocketEvents.Keyup, OutgoingPayload] {\n    return [\n        OutgoingSocketEvents.Keyup,\n        {\n            ...element,\n            value\n        }\n    ];\n}\n\nexport function incomingKeyupHandler(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(\n            inputs.option$.pipe(pluck(\"ghostMode\", \"forms\", \"inputs\")),\n            inputs.window$.pipe(pluck(\"location\", \"pathname\"))\n        ),\n        filter(([event, canKeyup, pathname]) => {\n            return canKeyup && event.pathname === pathname;\n        }),\n        map(([event]) => setElementValue(event))\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/KeyupEvent.ts","var apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/timers-browserify/main.js\n// module id = 93\n// module chunks = 0","import { OutgoingSocketEvents } from \"../socket-messages\";\nimport * as ClickEvent from \"./ClickEvent\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { setElementToggleValue } from \"../effects/set-element-toggle-value.effect\";\n\nexport interface Payload {\n    tagName: string;\n    index: number;\n    value: any;\n    type: any;\n    checked: any;\n}\n\nexport type OutgoingPayload = Payload;\n\nexport interface IncomingPayload extends OutgoingPayload {\n    pathname: string;\n}\n\nexport function outgoing(\n    element: ClickEvent.ElementData,\n    props: { value: string; type: string; checked: boolean }\n): [OutgoingSocketEvents.InputToggle, OutgoingPayload] {\n    return [\n        OutgoingSocketEvents.InputToggle,\n        {\n            ...element,\n            ...props\n        }\n    ];\n}\n\nexport function incomingInputsToggles(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(\n            inputs.option$.pipe(pluck(\"ghostMode\", \"forms\", \"toggles\")),\n            inputs.window$.pipe(pluck(\"location\", \"pathname\"))\n        ),\n        filter(([, toggles]) => toggles === true),\n        map(([event]) => setElementToggleValue(event))\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/FormToggleEvent.ts","///<reference path=\"types.ts\"/>\nimport { Observable } from \"rxjs/Observable\";\nimport { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { zip } from \"rxjs/observable/zip\";\nimport { initDocument, initOptions, initSocket, initWindow } from \"./socket\";\nimport { initNotify } from \"./notify\";\nimport { domHandlers$ } from \"./dom-effects\";\nimport { SocketEvent, socketHandlers$ } from \"./socket-messages\";\nimport { merge } from \"rxjs/observable/merge\";\nimport { initLogger, logHandler$ } from \"./log\";\nimport { effectOutputHandlers$ } from \"./effects\";\nimport { Nanologger } from \"../vendor/logger\";\nimport { scrollRestoreHandlers$ } from \"./scroll-restore\";\nimport { initListeners } from \"./listeners\";\nimport { groupBy } from \"rxjs/operators/groupBy\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { share } from \"rxjs/operators/share\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { of } from \"rxjs/observable/of\";\n\nexport interface Inputs {\n    window$: Observable<Window>;\n    document$: Observable<Document>;\n    socket$: Observable<SocketEvent>;\n    option$: BehaviorSubject<IBrowserSyncOptions>;\n    navigator$: Observable<Navigator>;\n    notifyElement$: BehaviorSubject<HTMLElement>;\n    logInstance$: Observable<Nanologger>;\n    io$: BehaviorSubject<any>;\n    outgoing$: Observable<any>;\n}\n\nconst window$ = initWindow();\nconst document$ = initDocument();\nconst { socket$, io$ } = initSocket();\nconst option$ = initOptions();\nconst navigator$ = of(navigator);\nconst notifyElement$ = initNotify(option$.getValue());\nconst logInstance$ = initLogger(option$.getValue());\nconst outgoing$ = initListeners(window, document, socket$, option$);\n\nconst inputs: Inputs = {\n    window$,\n    document$,\n    socket$,\n    option$,\n    navigator$,\n    notifyElement$,\n    logInstance$,\n    io$,\n    outgoing$\n};\n\nfunction getStream(name: string, inputs) {\n    return function(handlers$, inputStream$) {\n        return inputStream$.pipe(\n            groupBy(([keyName]) => {\n                return keyName;\n            }),\n            withLatestFrom(handlers$),\n            filter(([x, handlers]) => {\n                return typeof handlers[x.key] === \"function\";\n            }),\n            mergeMap(([x, handlers]) => {\n                return handlers[x.key](x.pipe(pluck(String(1))), inputs);\n            }),\n            share()\n        );\n    };\n}\n\nconst combinedEffectHandler$ = zip(\n    effectOutputHandlers$,\n    scrollRestoreHandlers$,\n    (...args) => {\n        return args.reduce((acc, item) => ({ ...acc, ...item }), {});\n    }\n);\n\nconst output$ = getStream(\"[socket]\", inputs)(\n    socketHandlers$,\n    merge(inputs.socket$, outgoing$)\n);\n\nconst effect$ = getStream(\"[effect]\", inputs)(combinedEffectHandler$, output$);\nconst dom$ = getStream(\"[dom-effect]\", inputs)(domHandlers$, effect$);\n\nconst merged$ = merge(output$, effect$, dom$);\n\nconst log$ = getStream(\"[log]\", inputs)(logHandler$, merged$);\n\nlog$.subscribe();\n\n// resume$.next(true);\n\n// var socket = require(\"./socket\");\n// var shims = require(\"./client-shims\");\n// var notify = require(\"./notify\");\n// // var codeSync = require(\"./code-sync\");\n// const { BrowserSync } = require(\"./browser-sync\");\n// var ghostMode = require(\"./ghostmode\");\n// var events = require(\"./events\");\n// var utils = require(\"./browser.utils\");\n//\n// const mitt = require(\"mitt\").default;\n//\n// var shouldReload = false;\n// var initialised = false;\n//\n// /**\n//  * @param options\n//  */\n// function init(options: bs.InitOptions) {\n//     if (shouldReload && options.reloadOnRestart) {\n//         utils.reloadBrowser();\n//     }\n//\n//     var BS = window.___browserSync___ || {};\n//     var emitter = mitt();\n//\n//     if (!BS.client) {\n//         BS.client = true;\n//\n//         var browserSync = new BrowserSync({ options, emitter, socket });\n//\n//         // codeSync.init(browserSync);\n//\n//         // // Always init on page load\n//         // ghostMode.init(browserSync);\n//         //\n//         // notify.init(browserSync);\n//         //\n//         // if (options.notify) {\n//         //     notify.flash(\"Connected to BrowserSync\");\n//         // }\n//     }\n//\n//     // if (!initialised) {\n//     //     socket.on(\"disconnect\", function() {\n//     //         if (options.notify) {\n//     //             notify.flash(\"Disconnected from BrowserSync\");\n//     //         }\n//     //         shouldReload = true;\n//     //     });\n//     //     initialised = true;\n//     // }\n// }\n//\n// /**\n//  * Handle individual socket connections\n//  */\n// socket.on(\"connection\", init);\n\n\n\n// WEBPACK FOOTER //\n// ./lib/index.ts","\"use strict\";\nvar zip_1 = require('../operators/zip');\nexports.zip = zip_1.zipStatic;\n//# sourceMappingURL=zip.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/zip.js\n// module id = 97\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar ArrayObservable_1 = require('../observable/ArrayObservable');\nvar isArray_1 = require('../util/isArray');\nvar Subscriber_1 = require('../Subscriber');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar iterator_1 = require('../symbol/iterator');\n/* tslint:enable:max-line-length */\n/**\n * @param observables\n * @return {Observable<R>}\n * @method zip\n * @owner Observable\n */\nfunction zip() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    return function zipOperatorFunction(source) {\n        return source.lift.call(zipStatic.apply(void 0, [source].concat(observables)));\n    };\n}\nexports.zip = zip;\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are calculated from the values, in order, of each\n * of its input Observables.\n *\n * If the latest parameter is a function, this function is used to compute the created value from the input values.\n * Otherwise, an array of the input values is returned.\n *\n * @example <caption>Combine age and name from different sources</caption>\n *\n * let age$ = Observable.of<number>(27, 25, 29);\n * let name$ = Observable.of<string>('Foo', 'Bar', 'Beer');\n * let isDev$ = Observable.of<boolean>(true, true, false);\n *\n * Observable\n *     .zip(age$,\n *          name$,\n *          isDev$,\n *          (age: number, name: string, isDev: boolean) => ({ age, name, isDev }))\n *     .subscribe(x => console.log(x));\n *\n * // outputs\n * // { age: 27, name: 'Foo', isDev: true }\n * // { age: 25, name: 'Bar', isDev: true }\n * // { age: 29, name: 'Beer', isDev: false }\n *\n * @param observables\n * @return {Observable<R>}\n * @static true\n * @name zip\n * @owner Observable\n */\nfunction zipStatic() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var project = observables[observables.length - 1];\n    if (typeof project === 'function') {\n        observables.pop();\n    }\n    return new ArrayObservable_1.ArrayObservable(observables).lift(new ZipOperator(project));\n}\nexports.zipStatic = zipStatic;\nvar ZipOperator = (function () {\n    function ZipOperator(project) {\n        this.project = project;\n    }\n    ZipOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ZipSubscriber(subscriber, this.project));\n    };\n    return ZipOperator;\n}());\nexports.ZipOperator = ZipOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ZipSubscriber = (function (_super) {\n    __extends(ZipSubscriber, _super);\n    function ZipSubscriber(destination, project, values) {\n        if (values === void 0) { values = Object.create(null); }\n        _super.call(this, destination);\n        this.iterators = [];\n        this.active = 0;\n        this.project = (typeof project === 'function') ? project : null;\n        this.values = values;\n    }\n    ZipSubscriber.prototype._next = function (value) {\n        var iterators = this.iterators;\n        if (isArray_1.isArray(value)) {\n            iterators.push(new StaticArrayIterator(value));\n        }\n        else if (typeof value[iterator_1.iterator] === 'function') {\n            iterators.push(new StaticIterator(value[iterator_1.iterator]()));\n        }\n        else {\n            iterators.push(new ZipBufferIterator(this.destination, this, value));\n        }\n    };\n    ZipSubscriber.prototype._complete = function () {\n        var iterators = this.iterators;\n        var len = iterators.length;\n        if (len === 0) {\n            this.destination.complete();\n            return;\n        }\n        this.active = len;\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            if (iterator.stillUnsubscribed) {\n                this.add(iterator.subscribe(iterator, i));\n            }\n            else {\n                this.active--; // not an observable\n            }\n        }\n    };\n    ZipSubscriber.prototype.notifyInactive = function () {\n        this.active--;\n        if (this.active === 0) {\n            this.destination.complete();\n        }\n    };\n    ZipSubscriber.prototype.checkIterators = function () {\n        var iterators = this.iterators;\n        var len = iterators.length;\n        var destination = this.destination;\n        // abort if not all of them have values\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) {\n                return;\n            }\n        }\n        var shouldComplete = false;\n        var args = [];\n        for (var i = 0; i < len; i++) {\n            var iterator = iterators[i];\n            var result = iterator.next();\n            // check to see if it's completed now that you've gotten\n            // the next value.\n            if (iterator.hasCompleted()) {\n                shouldComplete = true;\n            }\n            if (result.done) {\n                destination.complete();\n                return;\n            }\n            args.push(result.value);\n        }\n        if (this.project) {\n            this._tryProject(args);\n        }\n        else {\n            destination.next(args);\n        }\n        if (shouldComplete) {\n            destination.complete();\n        }\n    };\n    ZipSubscriber.prototype._tryProject = function (args) {\n        var result;\n        try {\n            result = this.project.apply(this, args);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return ZipSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ZipSubscriber = ZipSubscriber;\nvar StaticIterator = (function () {\n    function StaticIterator(iterator) {\n        this.iterator = iterator;\n        this.nextResult = iterator.next();\n    }\n    StaticIterator.prototype.hasValue = function () {\n        return true;\n    };\n    StaticIterator.prototype.next = function () {\n        var result = this.nextResult;\n        this.nextResult = this.iterator.next();\n        return result;\n    };\n    StaticIterator.prototype.hasCompleted = function () {\n        var nextResult = this.nextResult;\n        return nextResult && nextResult.done;\n    };\n    return StaticIterator;\n}());\nvar StaticArrayIterator = (function () {\n    function StaticArrayIterator(array) {\n        this.array = array;\n        this.index = 0;\n        this.length = 0;\n        this.length = array.length;\n    }\n    StaticArrayIterator.prototype[iterator_1.iterator] = function () {\n        return this;\n    };\n    StaticArrayIterator.prototype.next = function (value) {\n        var i = this.index++;\n        var array = this.array;\n        return i < this.length ? { value: array[i], done: false } : { value: null, done: true };\n    };\n    StaticArrayIterator.prototype.hasValue = function () {\n        return this.array.length > this.index;\n    };\n    StaticArrayIterator.prototype.hasCompleted = function () {\n        return this.array.length === this.index;\n    };\n    return StaticArrayIterator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ZipBufferIterator = (function (_super) {\n    __extends(ZipBufferIterator, _super);\n    function ZipBufferIterator(destination, parent, observable) {\n        _super.call(this, destination);\n        this.parent = parent;\n        this.observable = observable;\n        this.stillUnsubscribed = true;\n        this.buffer = [];\n        this.isComplete = false;\n    }\n    ZipBufferIterator.prototype[iterator_1.iterator] = function () {\n        return this;\n    };\n    // NOTE: there is actually a name collision here with Subscriber.next and Iterator.next\n    //    this is legit because `next()` will never be called by a subscription in this case.\n    ZipBufferIterator.prototype.next = function () {\n        var buffer = this.buffer;\n        if (buffer.length === 0 && this.isComplete) {\n            return { value: null, done: true };\n        }\n        else {\n            return { value: buffer.shift(), done: false };\n        }\n    };\n    ZipBufferIterator.prototype.hasValue = function () {\n        return this.buffer.length > 0;\n    };\n    ZipBufferIterator.prototype.hasCompleted = function () {\n        return this.buffer.length === 0 && this.isComplete;\n    };\n    ZipBufferIterator.prototype.notifyComplete = function () {\n        if (this.buffer.length > 0) {\n            this.isComplete = true;\n            this.parent.notifyInactive();\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    ZipBufferIterator.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.buffer.push(innerValue);\n        this.parent.checkIterators();\n    };\n    ZipBufferIterator.prototype.subscribe = function (value, index) {\n        return subscribeToResult_1.subscribeToResult(this, this.observable, this, index);\n    };\n    return ZipBufferIterator;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=zip.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/zip.js\n// module id = 98\n// module chunks = 0","\"use strict\";\nvar Subscriber_1 = require('../Subscriber');\nvar rxSubscriber_1 = require('../symbol/rxSubscriber');\nvar Observer_1 = require('../Observer');\nfunction toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {\n            return nextOrObserver[rxSubscriber_1.rxSubscriber]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber_1.Subscriber(Observer_1.empty);\n    }\n    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/toSubscriber.js\n// module id = 99\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n    __extends(UnsubscriptionError, _super);\n    function UnsubscriptionError(errors) {\n        _super.call(this);\n        this.errors = errors;\n        var err = Error.call(this, errors ?\n            errors.length + \" errors occurred during unsubscription:\\n  \" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n  ') : '');\n        this.name = err.name = 'UnsubscriptionError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/UnsubscriptionError.js\n// module id = 100\n// module chunks = 0","\"use strict\";\nvar noop_1 = require('./noop');\n/* tslint:enable:max-line-length */\nfunction pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i - 0] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexports.pipe = pipe;\n/* @internal */\nfunction pipeFromArray(fns) {\n    if (!fns) {\n        return noop_1.noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\nexports.pipeFromArray = pipeFromArray;\n//# sourceMappingURL=pipe.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/pipe.js\n// module id = 101\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerSubscriber = (function (_super) {\n    __extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        _super.call(this);\n        this.parent = parent;\n        this.outerValue = outerValue;\n        this.outerIndex = outerIndex;\n        this.index = 0;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber_1.Subscriber));\nexports.InnerSubscriber = InnerSubscriber;\n//# sourceMappingURL=InnerSubscriber.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/InnerSubscriber.js\n// module id = 102\n// module chunks = 0","import socket = require(\"socket.io-client\");\nimport { Observable } from \"rxjs/Observable\";\nimport { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { of } from \"rxjs/observable/of\";\nimport { share } from \"rxjs/operators/share\";\n\n/**\n * Alias for socket.emit\n * @param name\n * @param data\n */\n// export function emit(name, data) {\n//     if (io && io.emit) {\n//         // send relative path of where the event is sent\n//         data.url = window.location.pathname;\n//         io.emit(name, data);\n//     }\n// }\n//\n// /**\n//  * Alias for socket.on\n//  * @param name\n//  * @param func\n//  */\n// export function on(name, func) {\n//     io.on(name, func);\n// }\n\nexport function initWindow() {\n    return of(window);\n}\n\nexport function initDocument() {\n    return of(document);\n}\n\nexport function initNavigator() {\n    return of(navigator);\n}\n\nexport function initOptions() {\n    return new BehaviorSubject(window.___browserSync___.options);\n}\n\nexport function initSocket() {\n    /**\n     * @type {{emit: emit, on: on}}\n     */\n\n    const socketConfig = window.___browserSync___.socketConfig;\n    const socketUrl = window.___browserSync___.socketUrl;\n    const io = socket(socketUrl, socketConfig);\n    const onevent = io.onevent;\n\n    const socket$ = Observable.create(obs => {\n        io.onevent = function(packet) {\n            onevent.call(this, packet);\n            obs.next(packet.data);\n        };\n    }).pipe(share());\n\n    const io$ = new BehaviorSubject(io);\n\n    /**\n     * *****BACK-COMPAT*******\n     * Scripts that come after Browsersync may rely on the previous window.___browserSync___.socket\n     */\n    window.___browserSync___.socket = io;\n\n    return { socket$, io$ };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/socket.ts","\n/**\n * Module dependencies.\n */\n\nvar url = require('./url');\nvar parser = require('socket.io-parser');\nvar Manager = require('./manager');\nvar debug = require('debug')('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n *   `io('http://localhost/a');`\n *   `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup (uri, opts) {\n  if (typeof uri === 'object') {\n    opts = uri;\n    uri = undefined;\n  }\n\n  opts = opts || {};\n\n  var parsed = url(uri);\n  var source = parsed.source;\n  var id = parsed.id;\n  var path = parsed.path;\n  var sameNamespace = cache[id] && path in cache[id].nsps;\n  var newConnection = opts.forceNew || opts['force new connection'] ||\n                      false === opts.multiplex || sameNamespace;\n\n  var io;\n\n  if (newConnection) {\n    debug('ignoring socket cache for %s', source);\n    io = Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      debug('new io instance for %s', source);\n      cache[id] = Manager(source, opts);\n    }\n    io = cache[id];\n  }\n  if (parsed.query && !opts.query) {\n    opts.query = parsed.query;\n  }\n  return io.socket(parsed.path, opts);\n}\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = require('./manager');\nexports.Socket = require('./socket');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-client/lib/index.js\n// module id = 104\n// module chunks = 0","\n/**\n * Module dependencies.\n */\n\nvar parseuri = require('parseuri');\nvar debug = require('debug')('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n *                 Defaults to window.location.\n * @api public\n */\n\nfunction url (uri, loc) {\n  var obj = uri;\n\n  // default to window.location\n  loc = loc || global.location;\n  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n  // relative path support\n  if ('string' === typeof uri) {\n    if ('/' === uri.charAt(0)) {\n      if ('/' === uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      debug('protocol-less url %s', uri);\n      if ('undefined' !== typeof loc) {\n        uri = loc.protocol + '//' + uri;\n      } else {\n        uri = 'https://' + uri;\n      }\n    }\n\n    // parse\n    debug('parse %s', uri);\n    obj = parseuri(uri);\n  }\n\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = '80';\n    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = '443';\n    }\n  }\n\n  obj.path = obj.path || '/';\n\n  var ipv6 = obj.host.indexOf(':') !== -1;\n  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\n  // define unique id\n  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n  // define href\n  obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));\n\n  return obj;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-client/lib/url.js\n// module id = 105\n// module chunks = 0","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug['default'] = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  exports.names = [];\n  exports.skips = [];\n\n  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/debug/src/debug.js\n// module id = 106\n// module chunks = 0","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return;\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name;\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/ms/index.js\n// module id = 107\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/has-binary2/node_modules/isarray/index.js\n// module id = 108\n// module chunks = 0","/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = require('isarray');\nvar isBuf = require('./is-buffer');\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof global.Blob === 'function' || toString.call(global.Blob) === '[object BlobConstructor]';\nvar withNativeFile = typeof global.File === 'function' || toString.call(global.File) === '[object FileConstructor]';\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet) {\n  var buffers = [];\n  var packetData = packet.data;\n  var pack = packet;\n  pack.data = _deconstructPacket(packetData, buffers);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {packet: pack, buffers: buffers};\n};\n\nfunction _deconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (isBuf(data)) {\n    var placeholder = { _placeholder: true, num: buffers.length };\n    buffers.push(data);\n    return placeholder;\n  } else if (isArray(data)) {\n    var newData = new Array(data.length);\n    for (var i = 0; i < data.length; i++) {\n      newData[i] = _deconstructPacket(data[i], buffers);\n    }\n    return newData;\n  } else if (typeof data === 'object' && !(data instanceof Date)) {\n    var newData = {};\n    for (var key in data) {\n      newData[key] = _deconstructPacket(data[key], buffers);\n    }\n    return newData;\n  }\n  return data;\n}\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n  packet.data = _reconstructPacket(packet.data, buffers);\n  packet.attachments = undefined; // no longer useful\n  return packet;\n};\n\nfunction _reconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (data && data._placeholder) {\n    return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n  } else if (isArray(data)) {\n    for (var i = 0; i < data.length; i++) {\n      data[i] = _reconstructPacket(data[i], buffers);\n    }\n  } else if (typeof data === 'object') {\n    for (var key in data) {\n      data[key] = _reconstructPacket(data[key], buffers);\n    }\n  }\n\n  return data;\n}\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n  function _removeBlobs(obj, curKey, containingObject) {\n    if (!obj) return obj;\n\n    // convert any blob\n    if ((withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File)) {\n      pendingBlobs++;\n\n      // async filereader\n      var fileReader = new FileReader();\n      fileReader.onload = function() { // this.result == arraybuffer\n        if (containingObject) {\n          containingObject[curKey] = this.result;\n        }\n        else {\n          bloblessData = this.result;\n        }\n\n        // if nothing pending its callback time\n        if(! --pendingBlobs) {\n          callback(bloblessData);\n        }\n      };\n\n      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n    } else if (isArray(obj)) { // handle array\n      for (var i = 0; i < obj.length; i++) {\n        _removeBlobs(obj[i], i, obj);\n      }\n    } else if (typeof obj === 'object' && !isBuf(obj)) { // and object\n      for (var key in obj) {\n        _removeBlobs(obj[key], key, obj);\n      }\n    }\n  }\n\n  var pendingBlobs = 0;\n  var bloblessData = data;\n  _removeBlobs(bloblessData);\n  if (!pendingBlobs) {\n    callback(bloblessData);\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-parser/binary.js\n// module id = 109\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/socket.io-parser/node_modules/isarray/index.js\n// module id = 110\n// module chunks = 0","\nmodule.exports = require('./socket');\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = require('engine.io-parser');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/index.js\n// module id = 111\n// module chunks = 0","/**\n * Module dependencies.\n */\n\nvar transports = require('./transports/index');\nvar Emitter = require('component-emitter');\nvar debug = require('debug')('engine.io-client:socket');\nvar index = require('indexof');\nvar parser = require('engine.io-parser');\nvar parseuri = require('parseuri');\nvar parseqs = require('parseqs');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket (uri, opts) {\n  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n  opts = opts || {};\n\n  if (uri && 'object' === typeof uri) {\n    opts = uri;\n    uri = null;\n  }\n\n  if (uri) {\n    uri = parseuri(uri);\n    opts.hostname = uri.host;\n    opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';\n    opts.port = uri.port;\n    if (uri.query) opts.query = uri.query;\n  } else if (opts.host) {\n    opts.hostname = parseuri(opts.host).host;\n  }\n\n  this.secure = null != opts.secure ? opts.secure\n    : (global.location && 'https:' === location.protocol);\n\n  if (opts.hostname && !opts.port) {\n    // if no port is specified manually, use the protocol default\n    opts.port = this.secure ? '443' : '80';\n  }\n\n  this.agent = opts.agent || false;\n  this.hostname = opts.hostname ||\n    (global.location ? location.hostname : 'localhost');\n  this.port = opts.port || (global.location && location.port\n      ? location.port\n      : (this.secure ? 443 : 80));\n  this.query = opts.query || {};\n  if ('string' === typeof this.query) this.query = parseqs.decode(this.query);\n  this.upgrade = false !== opts.upgrade;\n  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n  this.forceJSONP = !!opts.forceJSONP;\n  this.jsonp = false !== opts.jsonp;\n  this.forceBase64 = !!opts.forceBase64;\n  this.enablesXDR = !!opts.enablesXDR;\n  this.timestampParam = opts.timestampParam || 't';\n  this.timestampRequests = opts.timestampRequests;\n  this.transports = opts.transports || ['polling', 'websocket'];\n  this.transportOptions = opts.transportOptions || {};\n  this.readyState = '';\n  this.writeBuffer = [];\n  this.prevBufferLen = 0;\n  this.policyPort = opts.policyPort || 843;\n  this.rememberUpgrade = opts.rememberUpgrade || false;\n  this.binaryType = null;\n  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\n  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n    this.perMessageDeflate.threshold = 1024;\n  }\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx || null;\n  this.key = opts.key || null;\n  this.passphrase = opts.passphrase || null;\n  this.cert = opts.cert || null;\n  this.ca = opts.ca || null;\n  this.ciphers = opts.ciphers || null;\n  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? true : opts.rejectUnauthorized;\n  this.forceNode = !!opts.forceNode;\n\n  // other options for Node.js client\n  var freeGlobal = typeof global === 'object' && global;\n  if (freeGlobal.global === freeGlobal) {\n    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n      this.extraHeaders = opts.extraHeaders;\n    }\n\n    if (opts.localAddress) {\n      this.localAddress = opts.localAddress;\n    }\n  }\n\n  // set on handshake\n  this.id = null;\n  this.upgrades = null;\n  this.pingInterval = null;\n  this.pingTimeout = null;\n\n  // set on heartbeat\n  this.pingIntervalTimer = null;\n  this.pingTimeoutTimer = null;\n\n  this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = require('./transport');\nSocket.transports = require('./transports/index');\nSocket.parser = require('engine.io-parser');\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n  debug('creating transport \"%s\"', name);\n  var query = clone(this.query);\n\n  // append engine.io protocol identifier\n  query.EIO = parser.protocol;\n\n  // transport name\n  query.transport = name;\n\n  // per-transport options\n  var options = this.transportOptions[name] || {};\n\n  // session id if we already have one\n  if (this.id) query.sid = this.id;\n\n  var transport = new transports[name]({\n    query: query,\n    socket: this,\n    agent: options.agent || this.agent,\n    hostname: options.hostname || this.hostname,\n    port: options.port || this.port,\n    secure: options.secure || this.secure,\n    path: options.path || this.path,\n    forceJSONP: options.forceJSONP || this.forceJSONP,\n    jsonp: options.jsonp || this.jsonp,\n    forceBase64: options.forceBase64 || this.forceBase64,\n    enablesXDR: options.enablesXDR || this.enablesXDR,\n    timestampRequests: options.timestampRequests || this.timestampRequests,\n    timestampParam: options.timestampParam || this.timestampParam,\n    policyPort: options.policyPort || this.policyPort,\n    pfx: options.pfx || this.pfx,\n    key: options.key || this.key,\n    passphrase: options.passphrase || this.passphrase,\n    cert: options.cert || this.cert,\n    ca: options.ca || this.ca,\n    ciphers: options.ciphers || this.ciphers,\n    rejectUnauthorized: options.rejectUnauthorized || this.rejectUnauthorized,\n    perMessageDeflate: options.perMessageDeflate || this.perMessageDeflate,\n    extraHeaders: options.extraHeaders || this.extraHeaders,\n    forceNode: options.forceNode || this.forceNode,\n    localAddress: options.localAddress || this.localAddress,\n    requestTimeout: options.requestTimeout || this.requestTimeout,\n    protocols: options.protocols || void (0)\n  });\n\n  return transport;\n};\n\nfunction clone (obj) {\n  var o = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      o[i] = obj[i];\n    }\n  }\n  return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n  var transport;\n  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {\n    transport = 'websocket';\n  } else if (0 === this.transports.length) {\n    // Emit error on next tick so it can be listened to\n    var self = this;\n    setTimeout(function () {\n      self.emit('error', 'No transports available');\n    }, 0);\n    return;\n  } else {\n    transport = this.transports[0];\n  }\n  this.readyState = 'opening';\n\n  // Retry with the next transport if the transport is disabled (jsonp: false)\n  try {\n    transport = this.createTransport(transport);\n  } catch (e) {\n    this.transports.shift();\n    this.open();\n    return;\n  }\n\n  transport.open();\n  this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function (transport) {\n  debug('setting transport %s', transport.name);\n  var self = this;\n\n  if (this.transport) {\n    debug('clearing existing transport %s', this.transport.name);\n    this.transport.removeAllListeners();\n  }\n\n  // set up transport\n  this.transport = transport;\n\n  // set up transport listeners\n  transport\n  .on('drain', function () {\n    self.onDrain();\n  })\n  .on('packet', function (packet) {\n    self.onPacket(packet);\n  })\n  .on('error', function (e) {\n    self.onError(e);\n  })\n  .on('close', function () {\n    self.onClose('transport close');\n  });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n  debug('probing transport \"%s\"', name);\n  var transport = this.createTransport(name, { probe: 1 });\n  var failed = false;\n  var self = this;\n\n  Socket.priorWebsocketSuccess = false;\n\n  function onTransportOpen () {\n    if (self.onlyBinaryUpgrades) {\n      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n      failed = failed || upgradeLosesBinary;\n    }\n    if (failed) return;\n\n    debug('probe transport \"%s\" opened', name);\n    transport.send([{ type: 'ping', data: 'probe' }]);\n    transport.once('packet', function (msg) {\n      if (failed) return;\n      if ('pong' === msg.type && 'probe' === msg.data) {\n        debug('probe transport \"%s\" pong', name);\n        self.upgrading = true;\n        self.emit('upgrading', transport);\n        if (!transport) return;\n        Socket.priorWebsocketSuccess = 'websocket' === transport.name;\n\n        debug('pausing current transport \"%s\"', self.transport.name);\n        self.transport.pause(function () {\n          if (failed) return;\n          if ('closed' === self.readyState) return;\n          debug('changing transport and sending upgrade packet');\n\n          cleanup();\n\n          self.setTransport(transport);\n          transport.send([{ type: 'upgrade' }]);\n          self.emit('upgrade', transport);\n          transport = null;\n          self.upgrading = false;\n          self.flush();\n        });\n      } else {\n        debug('probe transport \"%s\" failed', name);\n        var err = new Error('probe error');\n        err.transport = transport.name;\n        self.emit('upgradeError', err);\n      }\n    });\n  }\n\n  function freezeTransport () {\n    if (failed) return;\n\n    // Any callback called by transport should be ignored since now\n    failed = true;\n\n    cleanup();\n\n    transport.close();\n    transport = null;\n  }\n\n  // Handle any error that happens while probing\n  function onerror (err) {\n    var error = new Error('probe error: ' + err);\n    error.transport = transport.name;\n\n    freezeTransport();\n\n    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n    self.emit('upgradeError', error);\n  }\n\n  function onTransportClose () {\n    onerror('transport closed');\n  }\n\n  // When the socket is closed while we're probing\n  function onclose () {\n    onerror('socket closed');\n  }\n\n  // When the socket is upgraded while we're probing\n  function onupgrade (to) {\n    if (transport && to.name !== transport.name) {\n      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n      freezeTransport();\n    }\n  }\n\n  // Remove all listeners on the transport and on self\n  function cleanup () {\n    transport.removeListener('open', onTransportOpen);\n    transport.removeListener('error', onerror);\n    transport.removeListener('close', onTransportClose);\n    self.removeListener('close', onclose);\n    self.removeListener('upgrading', onupgrade);\n  }\n\n  transport.once('open', onTransportOpen);\n  transport.once('error', onerror);\n  transport.once('close', onTransportClose);\n\n  this.once('close', onclose);\n  this.once('upgrading', onupgrade);\n\n  transport.open();\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n  debug('socket open');\n  this.readyState = 'open';\n  Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;\n  this.emit('open');\n  this.flush();\n\n  // we check for `readyState` in case an `open`\n  // listener already closed the socket\n  if ('open' === this.readyState && this.upgrade && this.transport.pause) {\n    debug('starting upgrade probes');\n    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n      this.probe(this.upgrades[i]);\n    }\n  }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n  if ('opening' === this.readyState || 'open' === this.readyState ||\n      'closing' === this.readyState) {\n    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n    this.emit('packet', packet);\n\n    // Socket is live - any packet counts\n    this.emit('heartbeat');\n\n    switch (packet.type) {\n      case 'open':\n        this.onHandshake(JSON.parse(packet.data));\n        break;\n\n      case 'pong':\n        this.setPing();\n        this.emit('pong');\n        break;\n\n      case 'error':\n        var err = new Error('server error');\n        err.code = packet.data;\n        this.onError(err);\n        break;\n\n      case 'message':\n        this.emit('data', packet.data);\n        this.emit('message', packet.data);\n        break;\n    }\n  } else {\n    debug('packet received with socket readyState \"%s\"', this.readyState);\n  }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n  this.emit('handshake', data);\n  this.id = data.sid;\n  this.transport.query.sid = data.sid;\n  this.upgrades = this.filterUpgrades(data.upgrades);\n  this.pingInterval = data.pingInterval;\n  this.pingTimeout = data.pingTimeout;\n  this.onOpen();\n  // In case open handler closes socket\n  if ('closed' === this.readyState) return;\n  this.setPing();\n\n  // Prolong liveness of socket on heartbeat\n  this.removeListener('heartbeat', this.onHeartbeat);\n  this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n  clearTimeout(this.pingTimeoutTimer);\n  var self = this;\n  self.pingTimeoutTimer = setTimeout(function () {\n    if ('closed' === self.readyState) return;\n    self.onClose('ping timeout');\n  }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n  var self = this;\n  clearTimeout(self.pingIntervalTimer);\n  self.pingIntervalTimer = setTimeout(function () {\n    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n    self.ping();\n    self.onHeartbeat(self.pingTimeout);\n  }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api private\n*/\n\nSocket.prototype.ping = function () {\n  var self = this;\n  this.sendPacket('ping', function () {\n    self.emit('ping');\n  });\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function () {\n  this.writeBuffer.splice(0, this.prevBufferLen);\n\n  // setting prevBufferLen = 0 is very important\n  // for example, when upgrading, upgrade packet is sent over,\n  // and a nonzero prevBufferLen could cause problems on `drain`\n  this.prevBufferLen = 0;\n\n  if (0 === this.writeBuffer.length) {\n    this.emit('drain');\n  } else {\n    this.flush();\n  }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n  if ('closed' !== this.readyState && this.transport.writable &&\n    !this.upgrading && this.writeBuffer.length) {\n    debug('flushing %d packets in socket', this.writeBuffer.length);\n    this.transport.send(this.writeBuffer);\n    // keep track of current length of writeBuffer\n    // splice writeBuffer and callbackBuffer on `drain`\n    this.prevBufferLen = this.writeBuffer.length;\n    this.emit('flush');\n  }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @param {Object} options.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, options, fn) {\n  this.sendPacket('message', msg, options, fn);\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Object} options.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, options, fn) {\n  if ('function' === typeof data) {\n    fn = data;\n    data = undefined;\n  }\n\n  if ('function' === typeof options) {\n    fn = options;\n    options = null;\n  }\n\n  if ('closing' === this.readyState || 'closed' === this.readyState) {\n    return;\n  }\n\n  options = options || {};\n  options.compress = false !== options.compress;\n\n  var packet = {\n    type: type,\n    data: data,\n    options: options\n  };\n  this.emit('packetCreate', packet);\n  this.writeBuffer.push(packet);\n  if (fn) this.once('flush', fn);\n  this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.readyState = 'closing';\n\n    var self = this;\n\n    if (this.writeBuffer.length) {\n      this.once('drain', function () {\n        if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      });\n    } else if (this.upgrading) {\n      waitForUpgrade();\n    } else {\n      close();\n    }\n  }\n\n  function close () {\n    self.onClose('forced close');\n    debug('socket closing - telling transport to close');\n    self.transport.close();\n  }\n\n  function cleanupAndClose () {\n    self.removeListener('upgrade', cleanupAndClose);\n    self.removeListener('upgradeError', cleanupAndClose);\n    close();\n  }\n\n  function waitForUpgrade () {\n    // wait for upgrade to finish since we can't send packets while pausing a transport\n    self.once('upgrade', cleanupAndClose);\n    self.once('upgradeError', cleanupAndClose);\n  }\n\n  return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n  debug('socket error %j', err);\n  Socket.priorWebsocketSuccess = false;\n  this.emit('error', err);\n  this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n  if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {\n    debug('socket close with reason: \"%s\"', reason);\n    var self = this;\n\n    // clear timers\n    clearTimeout(this.pingIntervalTimer);\n    clearTimeout(this.pingTimeoutTimer);\n\n    // stop event from firing again for transport\n    this.transport.removeAllListeners('close');\n\n    // ensure transport won't stay open\n    this.transport.close();\n\n    // ignore further transport communication\n    this.transport.removeAllListeners();\n\n    // set ready state\n    this.readyState = 'closed';\n\n    // clear session id\n    this.id = null;\n\n    // emit close event\n    this.emit('close', reason, desc);\n\n    // clean buffers after, so users can still\n    // grab the buffers on `close` event\n    self.writeBuffer = [];\n    self.prevBufferLen = 0;\n  }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n  var filteredUpgrades = [];\n  for (var i = 0, j = upgrades.length; i < j; i++) {\n    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n  }\n  return filteredUpgrades;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/socket.js\n// module id = 112\n// module chunks = 0","\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/has-cors/index.js\n// module id = 113\n// module chunks = 0","/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar Polling = require('./polling');\nvar Emitter = require('component-emitter');\nvar inherit = require('component-inherit');\nvar debug = require('debug')('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty () {}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR (opts) {\n  Polling.call(this, opts);\n  this.requestTimeout = opts.requestTimeout;\n  this.extraHeaders = opts.extraHeaders;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    this.xd = opts.hostname !== global.location.hostname ||\n      port !== opts.port;\n    this.xs = opts.secure !== isSSL;\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function (opts) {\n  opts = opts || {};\n  opts.uri = this.uri();\n  opts.xd = this.xd;\n  opts.xs = this.xs;\n  opts.agent = this.agent || false;\n  opts.supportsBinary = this.supportsBinary;\n  opts.enablesXDR = this.enablesXDR;\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  opts.requestTimeout = this.requestTimeout;\n\n  // other options for Node.js client\n  opts.extraHeaders = this.extraHeaders;\n\n  return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function (data, fn) {\n  var isBinary = typeof data !== 'string' && data !== undefined;\n  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n  var self = this;\n  req.on('success', fn);\n  req.on('error', function (err) {\n    self.onError('xhr post error', err);\n  });\n  this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function () {\n  debug('xhr poll');\n  var req = this.request();\n  var self = this;\n  req.on('data', function (data) {\n    self.onData(data);\n  });\n  req.on('error', function (err) {\n    self.onError('xhr poll error', err);\n  });\n  this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request (opts) {\n  this.method = opts.method || 'GET';\n  this.uri = opts.uri;\n  this.xd = !!opts.xd;\n  this.xs = !!opts.xs;\n  this.async = false !== opts.async;\n  this.data = undefined !== opts.data ? opts.data : null;\n  this.agent = opts.agent;\n  this.isBinary = opts.isBinary;\n  this.supportsBinary = opts.supportsBinary;\n  this.enablesXDR = opts.enablesXDR;\n  this.requestTimeout = opts.requestTimeout;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n\n  this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function () {\n  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  var xhr = this.xhr = new XMLHttpRequest(opts);\n  var self = this;\n\n  try {\n    debug('xhr open %s: %s', this.method, this.uri);\n    xhr.open(this.method, this.uri, this.async);\n    try {\n      if (this.extraHeaders) {\n        xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n        for (var i in this.extraHeaders) {\n          if (this.extraHeaders.hasOwnProperty(i)) {\n            xhr.setRequestHeader(i, this.extraHeaders[i]);\n          }\n        }\n      }\n    } catch (e) {}\n\n    if ('POST' === this.method) {\n      try {\n        if (this.isBinary) {\n          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n        } else {\n          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n        }\n      } catch (e) {}\n    }\n\n    try {\n      xhr.setRequestHeader('Accept', '*/*');\n    } catch (e) {}\n\n    // ie6 check\n    if ('withCredentials' in xhr) {\n      xhr.withCredentials = true;\n    }\n\n    if (this.requestTimeout) {\n      xhr.timeout = this.requestTimeout;\n    }\n\n    if (this.hasXDR()) {\n      xhr.onload = function () {\n        self.onLoad();\n      };\n      xhr.onerror = function () {\n        self.onError(xhr.responseText);\n      };\n    } else {\n      xhr.onreadystatechange = function () {\n        if (xhr.readyState === 2) {\n          var contentType;\n          try {\n            contentType = xhr.getResponseHeader('Content-Type');\n          } catch (e) {}\n          if (contentType === 'application/octet-stream') {\n            xhr.responseType = 'arraybuffer';\n          }\n        }\n        if (4 !== xhr.readyState) return;\n        if (200 === xhr.status || 1223 === xhr.status) {\n          self.onLoad();\n        } else {\n          // make sure the `error` event handler that's user-set\n          // does not throw in the same tick and gets caught here\n          setTimeout(function () {\n            self.onError(xhr.status);\n          }, 0);\n        }\n      };\n    }\n\n    debug('xhr data %s', this.data);\n    xhr.send(this.data);\n  } catch (e) {\n    // Need to defer since .create() is called directly fhrom the constructor\n    // and thus the 'error' event can only be only bound *after* this exception\n    // occurs.  Therefore, also, we cannot throw here at all.\n    setTimeout(function () {\n      self.onError(e);\n    }, 0);\n    return;\n  }\n\n  if (global.document) {\n    this.index = Request.requestsCount++;\n    Request.requests[this.index] = this;\n  }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function () {\n  this.emit('success');\n  this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function (data) {\n  this.emit('data', data);\n  this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function (err) {\n  this.emit('error', err);\n  this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function (fromError) {\n  if ('undefined' === typeof this.xhr || null === this.xhr) {\n    return;\n  }\n  // xmlhttprequest\n  if (this.hasXDR()) {\n    this.xhr.onload = this.xhr.onerror = empty;\n  } else {\n    this.xhr.onreadystatechange = empty;\n  }\n\n  if (fromError) {\n    try {\n      this.xhr.abort();\n    } catch (e) {}\n  }\n\n  if (global.document) {\n    delete Request.requests[this.index];\n  }\n\n  this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function () {\n  var data;\n  try {\n    var contentType;\n    try {\n      contentType = this.xhr.getResponseHeader('Content-Type');\n    } catch (e) {}\n    if (contentType === 'application/octet-stream') {\n      data = this.xhr.response || this.xhr.responseText;\n    } else {\n      data = this.xhr.responseText;\n    }\n  } catch (e) {\n    this.onError(e);\n  }\n  if (null != data) {\n    this.onData(data);\n  }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function () {\n  return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function () {\n  this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nRequest.requestsCount = 0;\nRequest.requests = {};\n\nif (global.document) {\n  if (global.attachEvent) {\n    global.attachEvent('onunload', unloadHandler);\n  } else if (global.addEventListener) {\n    global.addEventListener('beforeunload', unloadHandler, false);\n  }\n}\n\nfunction unloadHandler () {\n  for (var i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transports/polling-xhr.js\n// module id = 114\n// module chunks = 0","\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n  var arr = [];\n  var has = Object.prototype.hasOwnProperty;\n\n  for (var i in obj) {\n    if (has.call(obj, i)) {\n      arr.push(i);\n    }\n  }\n  return arr;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-parser/lib/keys.js\n// module id = 115\n// module chunks = 0","/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n  var bytes = arraybuffer.byteLength;\n  start = start || 0;\n  end = end || bytes;\n\n  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n  if (start < 0) { start += bytes; }\n  if (end < 0) { end += bytes; }\n  if (end > bytes) { end = bytes; }\n\n  if (start >= bytes || start >= end || bytes === 0) {\n    return new ArrayBuffer(0);\n  }\n\n  var abv = new Uint8Array(arraybuffer);\n  var result = new Uint8Array(end - start);\n  for (var i = start, ii = 0; i < end; i++, ii++) {\n    result[ii] = abv[i];\n  }\n  return result.buffer;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/arraybuffer.slice/index.js\n// module id = 116\n// module chunks = 0","module.exports = after\n\nfunction after(count, callback, err_cb) {\n    var bail = false\n    err_cb = err_cb || noop\n    proxy.count = count\n\n    return (count === 0) ? callback() : proxy\n\n    function proxy(err, result) {\n        if (proxy.count <= 0) {\n            throw new Error('after called too many times')\n        }\n        --proxy.count\n\n        // after first error, rest are passed to err_cb\n        if (err) {\n            bail = true\n            callback(err)\n            // future error callbacks will go to error handler\n            callback = err_cb\n        } else if (proxy.count === 0 && !bail) {\n            callback(null, result)\n        }\n    }\n}\n\nfunction noop() {}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/after/index.js\n// module id = 117\n// module chunks = 0","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint, strict) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tif (strict) {\n\t\t\t\tthrow Error(\n\t\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t\t' is not a scalar value'\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint, strict) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tif (!checkScalarValue(codePoint, strict)) {\n\t\t\t\tcodePoint = 0xFFFD;\n\t\t\t}\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string, opts) {\n\t\topts = opts || {};\n\t\tvar strict = false !== opts.strict;\n\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint, strict);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol(strict) {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\treturn checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString, opts) {\n\t\topts = opts || {};\n\t\tvar strict = false !== opts.strict;\n\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol(strict)) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-parser/lib/utf8.js\n// module id = 118\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 119\n// module chunks = 0","/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/base64-arraybuffer/lib/base64-arraybuffer.js\n// module id = 120\n// module chunks = 0","/**\n * Create a blob builder even when vendor prefixes exist\n */\n\nvar BlobBuilder = global.BlobBuilder\n  || global.WebKitBlobBuilder\n  || global.MSBlobBuilder\n  || global.MozBlobBuilder;\n\n/**\n * Check if Blob constructor is supported\n */\n\nvar blobSupported = (function() {\n  try {\n    var a = new Blob(['hi']);\n    return a.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if Blob constructor supports ArrayBufferViews\n * Fails in Safari 6, so we need to map to ArrayBuffers there.\n */\n\nvar blobSupportsArrayBufferView = blobSupported && (function() {\n  try {\n    var b = new Blob([new Uint8Array([1,2])]);\n    return b.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if BlobBuilder is supported\n */\n\nvar blobBuilderSupported = BlobBuilder\n  && BlobBuilder.prototype.append\n  && BlobBuilder.prototype.getBlob;\n\n/**\n * Helper function that maps ArrayBufferViews to ArrayBuffers\n * Used by BlobBuilder constructor and old browsers that didn't\n * support it in the Blob constructor.\n */\n\nfunction mapArrayBufferViews(ary) {\n  for (var i = 0; i < ary.length; i++) {\n    var chunk = ary[i];\n    if (chunk.buffer instanceof ArrayBuffer) {\n      var buf = chunk.buffer;\n\n      // if this is a subarray, make a copy so we only\n      // include the subarray region from the underlying buffer\n      if (chunk.byteLength !== buf.byteLength) {\n        var copy = new Uint8Array(chunk.byteLength);\n        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\n        buf = copy.buffer;\n      }\n\n      ary[i] = buf;\n    }\n  }\n}\n\nfunction BlobBuilderConstructor(ary, options) {\n  options = options || {};\n\n  var bb = new BlobBuilder();\n  mapArrayBufferViews(ary);\n\n  for (var i = 0; i < ary.length; i++) {\n    bb.append(ary[i]);\n  }\n\n  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n};\n\nfunction BlobConstructor(ary, options) {\n  mapArrayBufferViews(ary);\n  return new Blob(ary, options || {});\n};\n\nmodule.exports = (function() {\n  if (blobSupported) {\n    return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;\n  } else if (blobBuilderSupported) {\n    return BlobBuilderConstructor;\n  } else {\n    return undefined;\n  }\n})();\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/blob/index.js\n// module id = 121\n// module chunks = 0","\n/**\n * Module requirements.\n */\n\nvar Polling = require('./polling');\nvar inherit = require('component-inherit');\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n  Polling.call(this, opts);\n\n  this.query = this.query || {};\n\n  // define global callbacks array if not present\n  // we do this here (lazily) to avoid unneeded global pollution\n  if (!callbacks) {\n    // we need to consider multiple engines in the same page\n    if (!global.___eio) global.___eio = [];\n    callbacks = global.___eio;\n  }\n\n  // callback identifier\n  this.index = callbacks.length;\n\n  // add callback to jsonp global\n  var self = this;\n  callbacks.push(function (msg) {\n    self.onData(msg);\n  });\n\n  // append to query string\n  this.query.j = this.index;\n\n  // prevent spurious errors from being emitted when the window is unloaded\n  if (global.document && global.addEventListener) {\n    global.addEventListener('beforeunload', function () {\n      if (self.script) self.script.onerror = empty;\n    }, false);\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  if (this.form) {\n    this.form.parentNode.removeChild(this.form);\n    this.form = null;\n    this.iframe = null;\n  }\n\n  Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n  var self = this;\n  var script = document.createElement('script');\n\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  script.async = true;\n  script.src = this.uri();\n  script.onerror = function (e) {\n    self.onError('jsonp poll error', e);\n  };\n\n  var insertAt = document.getElementsByTagName('script')[0];\n  if (insertAt) {\n    insertAt.parentNode.insertBefore(script, insertAt);\n  } else {\n    (document.head || document.body).appendChild(script);\n  }\n  this.script = script;\n\n  var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);\n\n  if (isUAgecko) {\n    setTimeout(function () {\n      var iframe = document.createElement('iframe');\n      document.body.appendChild(iframe);\n      document.body.removeChild(iframe);\n    }, 100);\n  }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n  var self = this;\n\n  if (!this.form) {\n    var form = document.createElement('form');\n    var area = document.createElement('textarea');\n    var id = this.iframeId = 'eio_iframe_' + this.index;\n    var iframe;\n\n    form.className = 'socketio';\n    form.style.position = 'absolute';\n    form.style.top = '-1000px';\n    form.style.left = '-1000px';\n    form.target = id;\n    form.method = 'POST';\n    form.setAttribute('accept-charset', 'utf-8');\n    area.name = 'd';\n    form.appendChild(area);\n    document.body.appendChild(form);\n\n    this.form = form;\n    this.area = area;\n  }\n\n  this.form.action = this.uri();\n\n  function complete () {\n    initIframe();\n    fn();\n  }\n\n  function initIframe () {\n    if (self.iframe) {\n      try {\n        self.form.removeChild(self.iframe);\n      } catch (e) {\n        self.onError('jsonp polling iframe removal error', e);\n      }\n    }\n\n    try {\n      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n      var html = '<iframe src=\"javascript:0\" name=\"' + self.iframeId + '\">';\n      iframe = document.createElement(html);\n    } catch (e) {\n      iframe = document.createElement('iframe');\n      iframe.name = self.iframeId;\n      iframe.src = 'javascript:0';\n    }\n\n    iframe.id = self.iframeId;\n\n    self.form.appendChild(iframe);\n    self.iframe = iframe;\n  }\n\n  initIframe();\n\n  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n  data = data.replace(rEscapedNewline, '\\\\\\n');\n  this.area.value = data.replace(rNewline, '\\\\n');\n\n  try {\n    this.form.submit();\n  } catch (e) {}\n\n  if (this.iframe.attachEvent) {\n    this.iframe.onreadystatechange = function () {\n      if (self.iframe.readyState === 'complete') {\n        complete();\n      }\n    };\n  } else {\n    this.iframe.onload = complete;\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transports/polling-jsonp.js\n// module id = 122\n// module chunks = 0","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parser = require('engine.io-parser');\nvar parseqs = require('parseqs');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:websocket');\nvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\nvar NodeWebSocket;\nif (typeof window === 'undefined') {\n  try {\n    NodeWebSocket = require('ws');\n  } catch (e) { }\n}\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocket = BrowserWebSocket;\nif (!WebSocket && typeof window === 'undefined') {\n  WebSocket = NodeWebSocket;\n}\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (forceBase64) {\n    this.supportsBinary = false;\n  }\n  this.perMessageDeflate = opts.perMessageDeflate;\n  this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;\n  this.protocols = opts.protocols;\n  if (!this.usingBrowserWebSocket) {\n    WebSocket = NodeWebSocket;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function () {\n  if (!this.check()) {\n    // let probe timeout\n    return;\n  }\n\n  var uri = this.uri();\n  var protocols = this.protocols;\n  var opts = {\n    agent: this.agent,\n    perMessageDeflate: this.perMessageDeflate\n  };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  if (this.extraHeaders) {\n    opts.headers = this.extraHeaders;\n  }\n  if (this.localAddress) {\n    opts.localAddress = this.localAddress;\n  }\n\n  try {\n    this.ws = this.usingBrowserWebSocket ? (protocols ? new WebSocket(uri, protocols) : new WebSocket(uri)) : new WebSocket(uri, protocols, opts);\n  } catch (err) {\n    return this.emit('error', err);\n  }\n\n  if (this.ws.binaryType === undefined) {\n    this.supportsBinary = false;\n  }\n\n  if (this.ws.supports && this.ws.supports.binary) {\n    this.supportsBinary = true;\n    this.ws.binaryType = 'nodebuffer';\n  } else {\n    this.ws.binaryType = 'arraybuffer';\n  }\n\n  this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function () {\n  var self = this;\n\n  this.ws.onopen = function () {\n    self.onOpen();\n  };\n  this.ws.onclose = function () {\n    self.onClose();\n  };\n  this.ws.onmessage = function (ev) {\n    self.onData(ev.data);\n  };\n  this.ws.onerror = function (e) {\n    self.onError('websocket error', e);\n  };\n};\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n\n  // encodePacket efficient as it uses WS framing\n  // no need for encodePayload\n  var total = packets.length;\n  for (var i = 0, l = total; i < l; i++) {\n    (function (packet) {\n      parser.encodePacket(packet, self.supportsBinary, function (data) {\n        if (!self.usingBrowserWebSocket) {\n          // always create a new object (GH-437)\n          var opts = {};\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n\n          if (self.perMessageDeflate) {\n            var len = 'string' === typeof data ? global.Buffer.byteLength(data) : data.length;\n            if (len < self.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n\n        // Sometimes the websocket has already been closed but the browser didn't\n        // have a chance of informing us about it yet, in that case send will\n        // throw an error\n        try {\n          if (self.usingBrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            self.ws.send(data);\n          } else {\n            self.ws.send(data, opts);\n          }\n        } catch (e) {\n          debug('websocket closed before onclose event');\n        }\n\n        --total || done();\n      });\n    })(packets[i]);\n  }\n\n  function done () {\n    self.emit('flush');\n\n    // fake drain\n    // defer to next tick to allow Socket to clear writeBuffer\n    setTimeout(function () {\n      self.writable = true;\n      self.emit('drain');\n    }, 0);\n  }\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function () {\n  Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function () {\n  if (typeof this.ws !== 'undefined') {\n    this.ws.close();\n  }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'wss' : 'ws';\n  var port = '';\n\n  // avoid port if default for schema\n  if (this.port && (('wss' === schema && Number(this.port) !== 443) ||\n    ('ws' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // append timestamp to URI\n  if (this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  // communicate binary support capabilities\n  if (!this.supportsBinary) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function () {\n  return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/engine.io-client/lib/transports/websocket.js\n// module id = 123\n// module chunks = 0","module.exports = toArray\n\nfunction toArray(list, index) {\n    var array = []\n\n    index = index || 0\n\n    for (var i = index || 0; i < list.length; i++) {\n        array[i - index] = list[i]\n    }\n\n    return array\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/to-array/index.js\n// module id = 125\n// module chunks = 0","\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/backo2/index.js\n// module id = 126\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('./Subscription');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SubjectSubscription = (function (_super) {\n    __extends(SubjectSubscription, _super);\n    function SubjectSubscription(subject, subscriber) {\n        _super.call(this);\n        this.subject = subject;\n        this.subscriber = subscriber;\n        this.closed = false;\n    }\n    SubjectSubscription.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.closed = true;\n        var subject = this.subject;\n        var observers = subject.observers;\n        this.subject = null;\n        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n            return;\n        }\n        var subscriberIndex = observers.indexOf(this.subscriber);\n        if (subscriberIndex !== -1) {\n            observers.splice(subscriberIndex, 1);\n        }\n    };\n    return SubjectSubscription;\n}(Subscription_1.Subscription));\nexports.SubjectSubscription = SubjectSubscription;\n//# sourceMappingURL=SubjectSubscription.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/SubjectSubscription.js\n// module id = 127\n// module chunks = 0","\"use strict\";\nvar ConnectableObservable_1 = require('../observable/ConnectableObservable');\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the results of invoking a specified selector on items\n * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.\n *\n * <img src=\"./img/multicast.png\" width=\"100%\">\n *\n * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through\n * which the source sequence's elements will be multicast to the selector function\n * or Subject to push source elements into.\n * @param {Function} [selector] - Optional selector function that can use the multicasted source stream\n * as many times as needed, without causing multiple subscriptions to the source stream.\n * Subscribers to the given source will receive all notifications of the source from the\n * time of the subscription forward.\n * @return {Observable} An Observable that emits the results of invoking the selector\n * on the items emitted by a `ConnectableObservable` that shares a single subscription to\n * the underlying stream.\n * @method multicast\n * @owner Observable\n */\nfunction multicast(subjectOrSubjectFactory, selector) {\n    return function multicastOperatorFunction(source) {\n        var subjectFactory;\n        if (typeof subjectOrSubjectFactory === 'function') {\n            subjectFactory = subjectOrSubjectFactory;\n        }\n        else {\n            subjectFactory = function subjectFactory() {\n                return subjectOrSubjectFactory;\n            };\n        }\n        if (typeof selector === 'function') {\n            return source.lift(new MulticastOperator(subjectFactory, selector));\n        }\n        var connectable = Object.create(source, ConnectableObservable_1.connectableObservableDescriptor);\n        connectable.source = source;\n        connectable.subjectFactory = subjectFactory;\n        return connectable;\n    };\n}\nexports.multicast = multicast;\nvar MulticastOperator = (function () {\n    function MulticastOperator(subjectFactory, selector) {\n        this.subjectFactory = subjectFactory;\n        this.selector = selector;\n    }\n    MulticastOperator.prototype.call = function (subscriber, source) {\n        var selector = this.selector;\n        var subject = this.subjectFactory();\n        var subscription = selector(subject).subscribe(subscriber);\n        subscription.add(source.subscribe(subject));\n        return subscription;\n    };\n    return MulticastOperator;\n}());\nexports.MulticastOperator = MulticastOperator;\n//# sourceMappingURL=multicast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/multicast.js\n// module id = 128\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('../Subject');\nvar Observable_1 = require('../Observable');\nvar Subscriber_1 = require('../Subscriber');\nvar Subscription_1 = require('../Subscription');\nvar refCount_1 = require('../operators/refCount');\n/**\n * @class ConnectableObservable<T>\n */\nvar ConnectableObservable = (function (_super) {\n    __extends(ConnectableObservable, _super);\n    function ConnectableObservable(source, subjectFactory) {\n        _super.call(this);\n        this.source = source;\n        this.subjectFactory = subjectFactory;\n        this._refCount = 0;\n        this._isComplete = false;\n    }\n    ConnectableObservable.prototype._subscribe = function (subscriber) {\n        return this.getSubject().subscribe(subscriber);\n    };\n    ConnectableObservable.prototype.getSubject = function () {\n        var subject = this._subject;\n        if (!subject || subject.isStopped) {\n            this._subject = this.subjectFactory();\n        }\n        return this._subject;\n    };\n    ConnectableObservable.prototype.connect = function () {\n        var connection = this._connection;\n        if (!connection) {\n            this._isComplete = false;\n            connection = this._connection = new Subscription_1.Subscription();\n            connection.add(this.source\n                .subscribe(new ConnectableSubscriber(this.getSubject(), this)));\n            if (connection.closed) {\n                this._connection = null;\n                connection = Subscription_1.Subscription.EMPTY;\n            }\n            else {\n                this._connection = connection;\n            }\n        }\n        return connection;\n    };\n    ConnectableObservable.prototype.refCount = function () {\n        return refCount_1.refCount()(this);\n    };\n    return ConnectableObservable;\n}(Observable_1.Observable));\nexports.ConnectableObservable = ConnectableObservable;\nvar connectableProto = ConnectableObservable.prototype;\nexports.connectableObservableDescriptor = {\n    operator: { value: null },\n    _refCount: { value: 0, writable: true },\n    _subject: { value: null, writable: true },\n    _connection: { value: null, writable: true },\n    _subscribe: { value: connectableProto._subscribe },\n    _isComplete: { value: connectableProto._isComplete, writable: true },\n    getSubject: { value: connectableProto.getSubject },\n    connect: { value: connectableProto.connect },\n    refCount: { value: connectableProto.refCount }\n};\nvar ConnectableSubscriber = (function (_super) {\n    __extends(ConnectableSubscriber, _super);\n    function ConnectableSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    ConnectableSubscriber.prototype._error = function (err) {\n        this._unsubscribe();\n        _super.prototype._error.call(this, err);\n    };\n    ConnectableSubscriber.prototype._complete = function () {\n        this.connectable._isComplete = true;\n        this._unsubscribe();\n        _super.prototype._complete.call(this);\n    };\n    ConnectableSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (connectable) {\n            this.connectable = null;\n            var connection = connectable._connection;\n            connectable._refCount = 0;\n            connectable._subject = null;\n            connectable._connection = null;\n            if (connection) {\n                connection.unsubscribe();\n            }\n        }\n    };\n    return ConnectableSubscriber;\n}(Subject_1.SubjectSubscriber));\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ConnectableObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/ConnectableObservable.js\n// module id = 129\n// module chunks = 0","import { BehaviorSubject } from \"rxjs/BehaviorSubject\";\n\nconst styles = {\n    display: \"none\",\n    padding: \"15px\",\n    fontFamily: \"sans-serif\",\n    position: \"fixed\",\n    fontSize: \"0.9em\",\n    zIndex: 9999,\n    right: 0,\n    top: 0,\n    borderBottomLeftRadius: \"5px\",\n    backgroundColor: \"#1B2032\",\n    margin: 0,\n    color: \"white\",\n    textAlign: \"center\",\n    pointerEvents: \"none\"\n};\n\n/**\n * @param {IBrowserSyncOptions} options\n * @returns {BehaviorSubject<any>}\n */\nexport function initNotify(options) {\n    let cssStyles = styles;\n    let elem;\n\n    if (options.notify.styles) {\n        if (\n            Object.prototype.toString.call(options.notify.styles) ===\n            \"[object Array]\"\n        ) {\n            // handle original array behavior, replace all styles with a joined copy\n            cssStyles = options.notify.styles.join(\";\");\n        } else {\n            for (var key in options.notify.styles) {\n                if (options.notify.styles.hasOwnProperty(key)) {\n                    cssStyles[key] = options.notify.styles[key];\n                }\n            }\n        }\n    }\n\n    elem = document.createElement(\"DIV\");\n    elem.id = \"__bs_notify__\";\n\n    if (typeof cssStyles === \"string\") {\n        elem.style.cssText = cssStyles;\n    } else {\n        for (var rule in cssStyles) {\n            elem.style[rule] = cssStyles[rule];\n        }\n    }\n\n    return new BehaviorSubject(elem);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/notify.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isNumeric_1 = require('../util/isNumeric');\nvar Observable_1 = require('../Observable');\nvar async_1 = require('../scheduler/async');\nvar isScheduler_1 = require('../util/isScheduler');\nvar isDate_1 = require('../util/isDate');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar TimerObservable = (function (_super) {\n    __extends(TimerObservable, _super);\n    function TimerObservable(dueTime, period, scheduler) {\n        if (dueTime === void 0) { dueTime = 0; }\n        _super.call(this);\n        this.period = -1;\n        this.dueTime = 0;\n        if (isNumeric_1.isNumeric(period)) {\n            this.period = Number(period) < 1 && 1 || Number(period);\n        }\n        else if (isScheduler_1.isScheduler(period)) {\n            scheduler = period;\n        }\n        if (!isScheduler_1.isScheduler(scheduler)) {\n            scheduler = async_1.async;\n        }\n        this.scheduler = scheduler;\n        this.dueTime = isDate_1.isDate(dueTime) ?\n            (+dueTime - this.scheduler.now()) :\n            dueTime;\n    }\n    /**\n     * Creates an Observable that starts emitting after an `initialDelay` and\n     * emits ever increasing numbers after each `period` of time thereafter.\n     *\n     * <span class=\"informal\">Its like {@link interval}, but you can specify when\n     * should the emissions start.</span>\n     *\n     * <img src=\"./img/timer.png\" width=\"100%\">\n     *\n     * `timer` returns an Observable that emits an infinite sequence of ascending\n     * integers, with a constant interval of time, `period` of your choosing\n     * between those emissions. The first emission happens after the specified\n     * `initialDelay`. The initial delay may be a {@link Date}. By default, this\n     * operator uses the `async` IScheduler to provide a notion of time, but you\n     * may pass any IScheduler to it. If `period` is not specified, the output\n     * Observable emits only one value, `0`. Otherwise, it emits an infinite\n     * sequence.\n     *\n     * @example <caption>Emits ascending numbers, one every second (1000ms), starting after 3 seconds</caption>\n     * var numbers = Rx.Observable.timer(3000, 1000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @example <caption>Emits one number after five seconds</caption>\n     * var numbers = Rx.Observable.timer(5000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @see {@link interval}\n     * @see {@link delay}\n     *\n     * @param {number|Date} initialDelay The initial delay time to wait before\n     * emitting the first value of `0`.\n     * @param {number} [period] The period of time between emissions of the\n     * subsequent numbers.\n     * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling\n     * the emission of values, and providing a notion of \"time\".\n     * @return {Observable} An Observable that emits a `0` after the\n     * `initialDelay` and ever increasing numbers after each `period` of time\n     * thereafter.\n     * @static true\n     * @name timer\n     * @owner Observable\n     */\n    TimerObservable.create = function (initialDelay, period, scheduler) {\n        if (initialDelay === void 0) { initialDelay = 0; }\n        return new TimerObservable(initialDelay, period, scheduler);\n    };\n    TimerObservable.dispatch = function (state) {\n        var index = state.index, period = state.period, subscriber = state.subscriber;\n        var action = this;\n        subscriber.next(index);\n        if (subscriber.closed) {\n            return;\n        }\n        else if (period === -1) {\n            return subscriber.complete();\n        }\n        state.index = index + 1;\n        action.schedule(state, period);\n    };\n    TimerObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, period = _a.period, dueTime = _a.dueTime, scheduler = _a.scheduler;\n        return scheduler.schedule(TimerObservable.dispatch, dueTime, {\n            index: index, period: period, subscriber: subscriber\n        });\n    };\n    return TimerObservable;\n}(Observable_1.Observable));\nexports.TimerObservable = TimerObservable;\n//# sourceMappingURL=TimerObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/TimerObservable.js\n// module id = 131\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('../Subscription');\n/**\n * A unit of work to be executed in a {@link Scheduler}. An action is typically\n * created from within a Scheduler and an RxJS user does not need to concern\n * themselves about creating and manipulating an Action.\n *\n * ```ts\n * class Action<T> extends Subscription {\n *   new (scheduler: Scheduler, work: (state?: T) => void);\n *   schedule(state?: T, delay: number = 0): Subscription;\n * }\n * ```\n *\n * @class Action<T>\n */\nvar Action = (function (_super) {\n    __extends(Action, _super);\n    function Action(scheduler, work) {\n        _super.call(this);\n    }\n    /**\n     * Schedules this action on its parent Scheduler for execution. May be passed\n     * some context object, `state`. May happen at some point in the future,\n     * according to the `delay` parameter, if specified.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler.\n     * @return {void}\n     */\n    Action.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        return this;\n    };\n    return Action;\n}(Subscription_1.Subscription));\nexports.Action = Action;\n//# sourceMappingURL=Action.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/Action.js\n// module id = 132\n// module chunks = 0","\"use strict\";\n/**\n * An execution context and a data structure to order tasks and schedule their\n * execution. Provides a notion of (potentially virtual) time, through the\n * `now()` getter method.\n *\n * Each unit of work in a Scheduler is called an {@link Action}.\n *\n * ```ts\n * class Scheduler {\n *   now(): number;\n *   schedule(work, delay?, state?): Subscription;\n * }\n * ```\n *\n * @class Scheduler\n */\nvar Scheduler = (function () {\n    function Scheduler(SchedulerAction, now) {\n        if (now === void 0) { now = Scheduler.now; }\n        this.SchedulerAction = SchedulerAction;\n        this.now = now;\n    }\n    /**\n     * Schedules a function, `work`, for execution. May happen at some point in\n     * the future, according to the `delay` parameter, if specified. May be passed\n     * some context object, `state`, which will be passed to the `work` function.\n     *\n     * The given arguments will be processed an stored as an Action object in a\n     * queue of actions.\n     *\n     * @param {function(state: ?T): ?Subscription} work A function representing a\n     * task, or some unit of work to be executed by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler itself.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @return {Subscription} A subscription in order to be able to unsubscribe\n     * the scheduled work.\n     */\n    Scheduler.prototype.schedule = function (work, delay, state) {\n        if (delay === void 0) { delay = 0; }\n        return new this.SchedulerAction(this, work).schedule(state, delay);\n    };\n    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };\n    return Scheduler;\n}());\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=Scheduler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Scheduler.js\n// module id = 133\n// module chunks = 0","\"use strict\";\nfunction isDate(value) {\n    return value instanceof Date && !isNaN(+value);\n}\nexports.isDate = isDate;\n//# sourceMappingURL=isDate.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/isDate.js\n// module id = 134\n// module chunks = 0","const emojis = {\n    trace: '🔍',\n    debug: '🐛',\n    info: '✨',\n    warn: '⚠️',\n    error: '🚨',\n    fatal: '💀'\n};\n\nconst levels = {\n    trace: 10,\n    debug: 20,\n    info: 30,\n    warn: 40,\n    error: 50,\n    fatal: 60\n};\n\nconst defaultColors = {\n    foreground: '#d3c0c8',\n    background: '#2d2d2d',\n    black: '#2d2d2d',\n    red: '#f2777a',\n    green: '#99cc99',\n    yellow: '#ffcc66',\n    blue: '#6699cc',\n    magenta: '#cc99cc',\n    cyan: '#66cccc',\n    white: '#d3d0c8',\n    brightBlack: '#747369'\n};\n\nexport class Nanologger {\n    public _name: string;\n    public _colors: { [index: string]: string };\n    public logLevel: string;\n    public _logLevel: string;\n\n    constructor(public name: string, public opts) {\n        this._name = name || '';\n        this._colors = {\n            ...defaultColors,\n            ...(opts.colors || {})\n        }\n        try {\n            this.logLevel = window.localStorage.getItem('logLevel') || 'info'\n        } catch (e) {\n            this.logLevel = 'info'\n        }\n\n        this._logLevel = levels[this.logLevel]\n    }\n\n    public trace() {\n        var args = ['trace']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    public debug() {\n        var args = ['debug']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    public info() {\n        var args = ['info']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    public warn() {\n        var args = ['warn']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    public error() {\n        var args = ['error']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    public fatal() {\n        var args = ['fatal']\n        for (var i = 0, len = arguments.length; i < len; i++) args.push(arguments[i])\n        this._print.apply(this, args)\n    }\n\n    private _print(level) {\n        if (levels[level] < this._logLevel) return\n\n        // var time = getTimeStamp()\n        var emoji = emojis[level]\n        var name = this._name || 'unknown'\n\n        var msgColor = (level === 'error' || level.fatal)\n            ? this._colors.red\n            : level === 'warn'\n                ? this._colors.yellow\n                : this._colors.green\n\n        var objs = []\n        var args = [null]\n        var msg = emoji + ' %c%s';\n\n        // args.push(color(this._colors.brightBlack), time)\n        args.push(color(this._colors.magenta), name)\n\n        for (var i = 1, len = arguments.length; i < len; i++) {\n            var arg = arguments[i]\n            if (typeof arg === 'string') {\n                if (i === 1) {\n                    // first string argument is in color\n                    msg += ' %c%s'\n                    args.push(color(msgColor))\n                    args.push(arg)\n                } else if (/ms$/.test(arg)) {\n                    // arguments finishing with 'ms', grey out\n                    msg += ' %c%s'\n                    args.push(color(this._colors.brightBlack))\n                    args.push(arg)\n                } else {\n                    // normal colors\n                    msg += ' %c%s'\n                    args.push(color(this._colors.white))\n                    args.push(arg)\n                }\n            } else if (typeof arg === 'number') {\n                msg += ' %c%d'\n                args.push(color(this._colors.magenta))\n                args.push(arg)\n            } else {\n                objs.push(arg)\n            }\n        }\n\n        args[0] = msg\n        objs.forEach(function (obj) {\n            args.push(obj)\n        })\n\n        // In IE/Edge console functions don't inherit from Function.prototype\n        // so this is necessary to get all the args applied.\n        Function.prototype.apply.apply(console.log, [console, args])\n    }\n}\n\nfunction color(color) {\n    return 'color: ' + color + ';'\n}\n\nfunction getTimeStamp() {\n    var date = new Date()\n    var hours = pad(date.getHours().toString())\n    var minutes = pad(date.getMinutes().toString())\n    var seconds = pad(date.getSeconds().toString())\n    return hours + ':' + minutes + ':' + seconds\n}\n\nfunction pad(str) {\n    return str.length !== 2 ? 0 + str : str\n}\n\n\n\n// WEBPACK FOOTER //\n// ./vendor/logger.ts","/**\n *\n * With thanks to https://github.com/livereload/livereload-js\n * :) :) :)\n *\n */\nimport {getLocation, pathFromUrl, pathsMatch, pickBestMatch, splitUrl, updateSearch, array} from \"../lib/utils\";\nimport {empty} from \"rxjs/observable/empty\";\nimport {Observable} from \"rxjs/Observable\";\nimport {merge} from \"rxjs/observable/merge\";\nimport {timer} from \"rxjs/observable/timer\";\nimport {from} from \"rxjs/observable/from\";\nimport {filter} from \"rxjs/operators/filter\";\nimport {map} from \"rxjs/operators/map\";\nimport {mergeMap} from \"rxjs/operators/mergeMap\";\nimport {take} from \"rxjs/operators/take\";\nimport {tap} from \"rxjs/operators/tap\";\nimport {mapTo} from \"rxjs/operators/mapTo\";\nimport {propSet} from \"../lib/dom-effects/prop-set.dom-effect\";\nimport {styleSet} from \"../lib/dom-effects/style-set.dom-effect\";\nimport {linkReplace} from \"../lib/dom-effects/link-replace.dom-effect\";\n\nvar hiddenElem;\n\ndeclare global {\n    interface HTMLLinkElement {\n        __LiveReload_pendingRemoval: boolean\n    }\n}\n\nconst IMAGE_STYLES = [\n    { selector: 'background', styleNames: ['backgroundImage'] },\n    { selector: 'border', styleNames: ['borderImage', 'webkitBorderImage', 'MozBorderImage'] }\n];\n\nconst attrs = {\n    link: \"href\",\n    img: \"src\",\n    script: \"src\"\n};\n\nexport interface ReloadOptions {\n    stylesheetReloadTimeout?: number;\n    serverURL?: string;\n    overrideURL?: string;\n    liveCSS?: boolean;\n    liveImg?: boolean;\n    tagNames: {[index: string]: string}\n}\n\nexport function reload(document: Document, navigator: Navigator) {\n    return function(data, options: ReloadOptions): Observable<any> {\n        const {path} = data;\n\n        if (options.liveCSS) {\n            if (path.match(/\\.css$/i)) {\n                return reloadStylesheet(path, document, navigator);\n            }\n        }\n\n        if (options.liveImg) {\n            if (path.match(/\\.(jpe?g|png|gif)$/i)) {\n                return reloadImages(path, document);\n            }\n        }\n\n        /**\n         * LEGACY\n         */\n        const domData = getElems(data.ext, options, document);\n        const elems   = getMatches(domData.elems, data.basename, domData.attr);\n\n        for (var i = 0, n = elems.length; i < n; i += 1) {\n            swapFile(elems[i], domData, options, document, navigator);\n        }\n\n        return empty();\n    }\n\n    function getMatches(elems, url, attr) {\n\n        if (url[0] === \"*\") {\n            return elems;\n        }\n\n        var matches = [];\n        var urlMatcher = new RegExp(\"(^|/)\" + url);\n\n        for (var i = 0, len = elems.length; i < len; i += 1) {\n            if (urlMatcher.test(elems[i][attr])) {\n                matches.push(elems[i]);\n            }\n        }\n\n        return matches;\n    }\n\n    function getElems(fileExtension, options: ReloadOptions, document: Document) {\n        const tagName = options.tagNames[fileExtension];\n        const attr    = attrs[tagName];\n        return {\n            attr,\n            tagName,\n            elems: document.getElementsByTagName(tagName)\n        };\n    }\n\n\n    function reloadImages(path, document): Observable<any> {\n\n        const expando = generateUniqueString(Date.now());\n\n        return merge(\n            from([].slice.call(document.images))\n                .pipe(\n                    filter((img: HTMLImageElement) => pathsMatch(path, pathFromUrl(img.src)))\n                    , map((img: HTMLImageElement) => {\n                        const payload = {\n                            target: img,\n                            prop: 'src',\n                            value: generateCacheBustUrl(img.src, expando),\n                            pathname: getLocation(img.src).pathname\n                        };\n                        return propSet(payload);\n                    })\n                ),\n            from(IMAGE_STYLES)\n                .pipe(\n                    mergeMap(({ selector, styleNames }) => {\n                        return from(document.querySelectorAll(`[style*=${selector}]`)).pipe(\n                            mergeMap((img: HTMLImageElement) => {\n                                return reloadStyleImages(img.style, styleNames, path, expando);\n                            })\n                        )\n\n                    })\n                )\n        );\n\n        // if (document.styleSheets) {\n        //     return [].slice.call(document.styleSheets)\n        //         .map((styleSheet) => {\n        //             return reloadStylesheetImages(styleSheet, path, expando);\n        //         });\n        // }\n    }\n\n\n    function reloadStylesheetImages(styleSheet, path, expando) {\n        let rules;\n        try {\n            rules = styleSheet != null ? styleSheet.cssRules : undefined;\n        } catch (e) {}\n        //\n        if (!rules) { return; }\n\n        [].slice.call(rules).forEach(rule => {\n            switch (rule.type) {\n                case CSSRule.IMPORT_RULE:\n                    reloadStylesheetImages(rule.styleSheet, path, expando);\n                    break;\n                case CSSRule.STYLE_RULE:\n                    [].slice.call(IMAGE_STYLES).forEach(({ styleNames }) => {\n                        reloadStyleImages((rule as any).style, styleNames, path, expando);\n                    })\n                    break;\n                case CSSRule.MEDIA_RULE:\n                    reloadStylesheetImages(rule, path, expando);\n                    break;\n            }\n        })\n    }\n\n    function reloadStyleImages(style, styleNames: string[], path, expando): Observable<any> {\n        return from(styleNames).pipe(\n            filter(styleName => typeof style[styleName] === 'string')\n            , map((styleName: string) => {\n                let pathName;\n                const value = style[styleName];\n                const newValue = value.replace(new RegExp(`\\\\burl\\\\s*\\\\(([^)]*)\\\\)`), (match, src) => {\n                    let _src = src;\n                    if (src[0] === '\"' && src[src.length-1] === '\"') {\n                        _src = src.slice(1, -1);\n                    }\n                    pathName = getLocation(_src).pathname;\n                    if (pathsMatch(path, pathFromUrl(_src))) {\n                        return `url(${generateCacheBustUrl(_src, expando)})`;\n                    } else {\n                        return match;\n                    }\n                });\n\n                return [\n                    style,\n                    styleName,\n                    value,\n                    newValue,\n                    pathName\n                ];\n            })\n            , filter(([style, styleName, value, newValue]) => newValue !== value)\n            , map(([style, styleName, value, newValue, pathName]) => styleSet({style, styleName, value, newValue, pathName}))\n        )\n    }\n\n    function swapFile(elem, domData, options, document, navigator) {\n\n        const attr = domData.attr;\n        const currentValue = elem[attr];\n        const timeStamp    = new Date().getTime();\n        const key          = \"browsersync-legacy\";\n        const suffix       = key + \"=\" + timeStamp;\n        const anchor       = getLocation(currentValue);\n        const search       = updateSearch(anchor.search, key, suffix);\n\n        switch (domData.tagName) {\n            case 'link': {\n                // this.logger.trace(`replacing LINK ${attr}`);\n                reloadStylesheet(currentValue, document, navigator);\n                break;\n            }\n            case 'img': {\n                reloadImages(currentValue, document);\n                break;\n            }\n            default: {\n                if (options.timestamps === false) {\n                    elem[attr] = anchor.href;\n                } else {\n                    elem[attr] = anchor.href.split(\"?\")[0] + search;\n                }\n\n                // this.logger.info(`reloading ${elem[attr]}`);\n\n                setTimeout(function () {\n                    if (!hiddenElem) {\n                        hiddenElem = document.createElement(\"DIV\");\n                        document.body.appendChild(hiddenElem);\n                    } else {\n                        hiddenElem.style.display = \"none\";\n                        hiddenElem.style.display = \"block\";\n                    }\n                }, 200);\n            }\n        }\n\n        return {\n            elem: elem,\n            timeStamp: timeStamp\n        };\n    }\n\n    function reattachStylesheetLink(link, document: Document, navigator: Navigator): Observable<any> {\n        // ignore LINKs that will be removed by LR soon\n        let clone;\n\n        if (link.__LiveReload_pendingRemoval) {\n            return empty();\n        }\n        link.__LiveReload_pendingRemoval = true;\n\n        if (link.tagName === 'STYLE') {\n            // prefixfree\n            clone = document.createElement('link');\n            clone.rel      = 'stylesheet';\n            clone.media    = link.media;\n            clone.disabled = link.disabled;\n        } else {\n            clone = link.cloneNode(false);\n        }\n\n        const prevHref = link.href;\n        const nextHref = generateCacheBustUrl(linkHref(link));\n        clone.href = nextHref;\n\n        const {pathname} = getLocation(nextHref);\n        const basename = pathname.split('/').slice(-1)[0];\n\n        // insert the new LINK before the old one\n        const parent = link.parentNode;\n        if (parent.lastChild === link) {\n            parent.appendChild(clone);\n        } else {\n            parent.insertBefore(clone, link.nextSibling);\n        }\n\n        let additionalWaitingTime;\n        if (/AppleWebKit/.test(navigator.userAgent)) {\n            additionalWaitingTime = 5;\n        } else {\n            additionalWaitingTime = 200;\n        }\n\n        return Observable.create(obs => clone.onload = () => obs.next(true))\n            .pipe(\n                take(1)\n                , mergeMap(() => {\n                    return timer(additionalWaitingTime)\n                        .pipe(\n                            tap(() => {\n                                if (link && !link.parentNode) {\n                                    return;\n                                }\n                                link.parentNode.removeChild(link);\n                                clone.onreadystatechange = null;\n                            })\n                            , mapTo(linkReplace({target: clone, nextHref, prevHref, pathname, basename}))\n                        )\n                })\n            )\n    }\n\n    function reattachImportedRule({ rule, index, link }, document: Document): Observable<any> {\n        const parent  = rule.parentStyleSheet;\n        const href    = generateCacheBustUrl(rule.href);\n        const media   = rule.media.length ? [].join.call(rule.media, ', ') : '';\n        const newRule = `@import url(\"${href}\") ${media};`;\n\n        // used to detect if reattachImportedRule has been called again on the same rule\n        rule.__LiveReload_newHref = href;\n\n        // WORKAROUND FOR WEBKIT BUG: WebKit resets all styles if we add @import'ed\n        // stylesheet that hasn't been cached yet. Workaround is to pre-cache the\n        // stylesheet by temporarily adding it as a LINK tag.\n        const tempLink = document.createElement(\"link\");\n        tempLink.rel = 'stylesheet';\n        tempLink.href = href;\n        tempLink.__LiveReload_pendingRemoval = true;  // exclude from path matching\n\n        if (link.parentNode) {\n            link.parentNode.insertBefore(tempLink, link);\n        }\n\n        return timer(200)\n            .pipe(\n                tap(() => {\n                    if (tempLink.parentNode) { tempLink.parentNode.removeChild(tempLink); }\n\n                    // if another reattachImportedRule call is in progress, abandon this one\n                    if (rule.__LiveReload_newHref !== href) { return; }\n\n                    parent.insertRule(newRule, index);\n                    parent.deleteRule(index+1);\n\n                    // save the new rule, so that we can detect another reattachImportedRule call\n                    rule = parent.cssRules[index];\n                    rule.__LiveReload_newHref = href;\n                })\n                , mergeMap(() => {\n                    return timer(200).pipe(\n                        tap(() => {\n                            // if another reattachImportedRule call is in progress, abandon this one\n                            if (rule.__LiveReload_newHref !== href) { return; }\n                            parent.insertRule(newRule, index);\n                            return parent.deleteRule(index+1);\n                        })\n                    )\n                })\n            );\n    }\n\n    function generateCacheBustUrl(url, expando = generateUniqueString(Date.now())) {\n        let hash, oldParams;\n\n        ({ url, hash, params: oldParams } = splitUrl(url));\n\n        // if (this.options.overrideURL) {\n        //     if (url.indexOf(this.options.serverURL) < 0) {\n        //         const originalUrl = url;\n        //         url = this.options.serverURL + this.options.overrideURL + \"?url=\" + encodeURIComponent(url);\n        //         this.logger.debug(`overriding source URL ${originalUrl} with ${url}`);\n        //     }\n        // }\n\n        let params = oldParams.replace(/(\\?|&)browsersync=(\\d+)/, (match, sep) => `${sep}${expando}`);\n        if (params === oldParams) {\n            if (oldParams.length === 0) {\n                params = `?${expando}`;\n            } else {\n                params = `${oldParams}&${expando}`;\n            }\n        }\n\n        return url + params + hash;\n    }\n\n\n    function reloadStylesheet(path: string, document: Document, navigator): Observable<any> {\n        // has to be a real array, because DOMNodeList will be modified\n        const links = array(document.getElementsByTagName('link'))\n            .filter(link => {\n                return link.rel.match(/^stylesheet$/i)\n                    && !link.__LiveReload_pendingRemoval;\n            });\n\n        /**\n         * Find imported style sheets in <style> tags\n         * @type {any[]}\n         */\n        const styleImported = array(document.getElementsByTagName('style'))\n            .filter(style => Boolean(style.sheet))\n            .reduce((acc, style) => {\n                return acc.concat(collectImportedStylesheets(style, style.sheet));\n            }, []);\n\n        /**\n         * Find imported style sheets in <link> tags\n         * @type {any[]}\n         */\n        const linksImported = links\n            .reduce((acc, link) => {\n                return acc.concat(collectImportedStylesheets(link, link.sheet));\n            }, []);\n\n        /**\n         * Combine all links + sheets\n         */\n        const allRules = links.concat(styleImported, linksImported);\n\n        /**\n         * Which href best matches the incoming href?\n         */\n        const match = pickBestMatch(path, allRules, l => pathFromUrl(linkHref(l)));\n\n        if (match) {\n            if (match.object && match.object.rule) {\n                return reattachImportedRule(match.object, document);\n            }\n            return reattachStylesheetLink(match.object, document, navigator);\n        }\n\n        return empty();\n    }\n\n\n    function collectImportedStylesheets(link, styleSheet) {\n        // in WebKit, styleSheet.cssRules is null for inaccessible stylesheets;\n        // Firefox/Opera may throw exceptions\n        const output = [];\n        collect(link, makeRules(styleSheet));\n        return output;\n\n        function makeRules(styleSheet) {\n            let rules;\n            try {\n                rules = styleSheet != null ? styleSheet.cssRules : undefined;\n            } catch (e) {}\n            return rules;\n        }\n        function collect(link, rules) {\n            if (rules && rules.length) {\n                for (let index = 0; index < rules.length; index++) {\n                    const rule = rules[index];\n                    switch (rule.type) {\n                        case CSSRule.CHARSET_RULE:\n                            break;\n                        case CSSRule.IMPORT_RULE:\n                            output.push({ link, rule, index, href: rule.href });\n                            collect(link, makeRules(rule.styleSheet));\n                            break;\n                        default:\n                            break;  // import rules can only be preceded by charset rules\n                    }\n                }\n            }\n        }\n    }\n\n    function linkHref(link) {\n        // prefixfree uses data-href when it turns LINK into STYLE\n        return link.href || link.getAttribute('data-href');\n    }\n\n    function generateUniqueString(value) {\n        return `browsersync=${value}`;\n    }\n}\n\n\n\n\n// WEBPACK FOOTER //\n// ./vendor/Reloader.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isArray_1 = require('../util/isArray');\nvar isArrayLike_1 = require('../util/isArrayLike');\nvar isPromise_1 = require('../util/isPromise');\nvar PromiseObservable_1 = require('./PromiseObservable');\nvar IteratorObservable_1 = require('./IteratorObservable');\nvar ArrayObservable_1 = require('./ArrayObservable');\nvar ArrayLikeObservable_1 = require('./ArrayLikeObservable');\nvar iterator_1 = require('../symbol/iterator');\nvar Observable_1 = require('../Observable');\nvar observeOn_1 = require('../operators/observeOn');\nvar observable_1 = require('../symbol/observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromObservable = (function (_super) {\n    __extends(FromObservable, _super);\n    function FromObservable(ish, scheduler) {\n        _super.call(this, null);\n        this.ish = ish;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable from an Array, an array-like object, a Promise, an\n     * iterable object, or an Observable-like object.\n     *\n     * <span class=\"informal\">Converts almost anything to an Observable.</span>\n     *\n     * <img src=\"./img/from.png\" width=\"100%\">\n     *\n     * Convert various other objects and data types into Observables. `from`\n     * converts a Promise or an array-like or an\n     * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)\n     * object into an Observable that emits the items in that promise or array or\n     * iterable. A String, in this context, is treated as an array of characters.\n     * Observable-like objects (contains a function named with the ES2015 Symbol\n     * for Observable) can also be converted through this operator.\n     *\n     * @example <caption>Converts an array to an Observable</caption>\n     * var array = [10, 20, 30];\n     * var result = Rx.Observable.from(array);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 10 20 30\n     *\n     * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>\n     * function* generateDoubles(seed) {\n     *   var i = seed;\n     *   while (true) {\n     *     yield i;\n     *     i = 2 * i; // double it\n     *   }\n     * }\n     *\n     * var iterator = generateDoubles(3);\n     * var result = Rx.Observable.from(iterator).take(10);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 3 6 12 24 48 96 192 384 768 1536\n     *\n     * @see {@link create}\n     * @see {@link fromEvent}\n     * @see {@link fromEventPattern}\n     * @see {@link fromPromise}\n     *\n     * @param {ObservableInput<T>} ish A subscribable object, a Promise, an\n     * Observable-like, an Array, an iterable or an array-like object to be\n     * converted.\n     * @param {Scheduler} [scheduler] The scheduler on which to schedule the\n     * emissions of values.\n     * @return {Observable<T>} The Observable whose values are originally from the\n     * input object that was converted.\n     * @static true\n     * @name from\n     * @owner Observable\n     */\n    FromObservable.create = function (ish, scheduler) {\n        if (ish != null) {\n            if (typeof ish[observable_1.observable] === 'function') {\n                if (ish instanceof Observable_1.Observable && !scheduler) {\n                    return ish;\n                }\n                return new FromObservable(ish, scheduler);\n            }\n            else if (isArray_1.isArray(ish)) {\n                return new ArrayObservable_1.ArrayObservable(ish, scheduler);\n            }\n            else if (isPromise_1.isPromise(ish)) {\n                return new PromiseObservable_1.PromiseObservable(ish, scheduler);\n            }\n            else if (typeof ish[iterator_1.iterator] === 'function' || typeof ish === 'string') {\n                return new IteratorObservable_1.IteratorObservable(ish, scheduler);\n            }\n            else if (isArrayLike_1.isArrayLike(ish)) {\n                return new ArrayLikeObservable_1.ArrayLikeObservable(ish, scheduler);\n            }\n        }\n        throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable');\n    };\n    FromObservable.prototype._subscribe = function (subscriber) {\n        var ish = this.ish;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            return ish[observable_1.observable]().subscribe(subscriber);\n        }\n        else {\n            return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0));\n        }\n    };\n    return FromObservable;\n}(Observable_1.Observable));\nexports.FromObservable = FromObservable;\n//# sourceMappingURL=FromObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/FromObservable.js\n// module id = 137\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar PromiseObservable = (function (_super) {\n    __extends(PromiseObservable, _super);\n    function PromiseObservable(promise, scheduler) {\n        _super.call(this);\n        this.promise = promise;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Converts a Promise to an Observable.\n     *\n     * <span class=\"informal\">Returns an Observable that just emits the Promise's\n     * resolved value, then completes.</span>\n     *\n     * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an\n     * Observable. If the Promise resolves with a value, the output Observable\n     * emits that resolved value as a `next`, and then completes. If the Promise\n     * is rejected, then the output Observable emits the corresponding Error.\n     *\n     * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>\n     * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link bindCallback}\n     * @see {@link from}\n     *\n     * @param {PromiseLike<T>} promise The promise to be converted.\n     * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling\n     * the delivery of the resolved value (or the rejection).\n     * @return {Observable<T>} An Observable which wraps the Promise.\n     * @static true\n     * @name fromPromise\n     * @owner Observable\n     */\n    PromiseObservable.create = function (promise, scheduler) {\n        return new PromiseObservable(promise, scheduler);\n    };\n    PromiseObservable.prototype._subscribe = function (subscriber) {\n        var _this = this;\n        var promise = this.promise;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    subscriber.next(this.value);\n                    subscriber.complete();\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.next(value);\n                        subscriber.complete();\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.error(err);\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n        else {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n    };\n    return PromiseObservable;\n}(Observable_1.Observable));\nexports.PromiseObservable = PromiseObservable;\nfunction dispatchNext(arg) {\n    var value = arg.value, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.next(value);\n        subscriber.complete();\n    }\n}\nfunction dispatchError(arg) {\n    var err = arg.err, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.error(err);\n    }\n}\n//# sourceMappingURL=PromiseObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/PromiseObservable.js\n// module id = 138\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IteratorObservable = (function (_super) {\n    __extends(IteratorObservable, _super);\n    function IteratorObservable(iterator, scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n        if (iterator == null) {\n            throw new Error('iterator cannot be null.');\n        }\n        this.iterator = getIterator(iterator);\n    }\n    IteratorObservable.create = function (iterator, scheduler) {\n        return new IteratorObservable(iterator, scheduler);\n    };\n    IteratorObservable.dispatch = function (state) {\n        var index = state.index, hasError = state.hasError, iterator = state.iterator, subscriber = state.subscriber;\n        if (hasError) {\n            subscriber.error(state.error);\n            return;\n        }\n        var result = iterator.next();\n        if (result.done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(result.value);\n        state.index = index + 1;\n        if (subscriber.closed) {\n            if (typeof iterator.return === 'function') {\n                iterator.return();\n            }\n            return;\n        }\n        this.schedule(state);\n    };\n    IteratorObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, iterator = _a.iterator, scheduler = _a.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(IteratorObservable.dispatch, 0, {\n                index: index, iterator: iterator, subscriber: subscriber\n            });\n        }\n        else {\n            do {\n                var result = iterator.next();\n                if (result.done) {\n                    subscriber.complete();\n                    break;\n                }\n                else {\n                    subscriber.next(result.value);\n                }\n                if (subscriber.closed) {\n                    if (typeof iterator.return === 'function') {\n                        iterator.return();\n                    }\n                    break;\n                }\n            } while (true);\n        }\n    };\n    return IteratorObservable;\n}(Observable_1.Observable));\nexports.IteratorObservable = IteratorObservable;\nvar StringIterator = (function () {\n    function StringIterator(str, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = str.length; }\n        this.str = str;\n        this.idx = idx;\n        this.len = len;\n    }\n    StringIterator.prototype[iterator_1.iterator] = function () { return (this); };\n    StringIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.str.charAt(this.idx++)\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return StringIterator;\n}());\nvar ArrayIterator = (function () {\n    function ArrayIterator(arr, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = toLength(arr); }\n        this.arr = arr;\n        this.idx = idx;\n        this.len = len;\n    }\n    ArrayIterator.prototype[iterator_1.iterator] = function () { return this; };\n    ArrayIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.arr[this.idx++]\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return ArrayIterator;\n}());\nfunction getIterator(obj) {\n    var i = obj[iterator_1.iterator];\n    if (!i && typeof obj === 'string') {\n        return new StringIterator(obj);\n    }\n    if (!i && obj.length !== undefined) {\n        return new ArrayIterator(obj);\n    }\n    if (!i) {\n        throw new TypeError('object is not iterable');\n    }\n    return obj[iterator_1.iterator]();\n}\nvar maxSafeInteger = Math.pow(2, 53) - 1;\nfunction toLength(o) {\n    var len = +o.length;\n    if (isNaN(len)) {\n        return 0;\n    }\n    if (len === 0 || !numberIsFinite(len)) {\n        return len;\n    }\n    len = sign(len) * Math.floor(Math.abs(len));\n    if (len <= 0) {\n        return 0;\n    }\n    if (len > maxSafeInteger) {\n        return maxSafeInteger;\n    }\n    return len;\n}\nfunction numberIsFinite(value) {\n    return typeof value === 'number' && root_1.root.isFinite(value);\n}\nfunction sign(value) {\n    var valueAsNumber = +value;\n    if (valueAsNumber === 0) {\n        return valueAsNumber;\n    }\n    if (isNaN(valueAsNumber)) {\n        return valueAsNumber;\n    }\n    return valueAsNumber < 0 ? -1 : 1;\n}\n//# sourceMappingURL=IteratorObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/IteratorObservable.js\n// module id = 139\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayLikeObservable = (function (_super) {\n    __extends(ArrayLikeObservable, _super);\n    function ArrayLikeObservable(arrayLike, scheduler) {\n        _super.call(this);\n        this.arrayLike = arrayLike;\n        this.scheduler = scheduler;\n        if (!scheduler && arrayLike.length === 1) {\n            this._isScalar = true;\n            this.value = arrayLike[0];\n        }\n    }\n    ArrayLikeObservable.create = function (arrayLike, scheduler) {\n        var length = arrayLike.length;\n        if (length === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else if (length === 1) {\n            return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler);\n        }\n        else {\n            return new ArrayLikeObservable(arrayLike, scheduler);\n        }\n    };\n    ArrayLikeObservable.dispatch = function (state) {\n        var arrayLike = state.arrayLike, index = state.index, length = state.length, subscriber = state.subscriber;\n        if (subscriber.closed) {\n            return;\n        }\n        if (index >= length) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(arrayLike[index]);\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    ArrayLikeObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, arrayLike = _a.arrayLike, scheduler = _a.scheduler;\n        var length = arrayLike.length;\n        if (scheduler) {\n            return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {\n                arrayLike: arrayLike, index: index, length: length, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < length && !subscriber.closed; i++) {\n                subscriber.next(arrayLike[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayLikeObservable;\n}(Observable_1.Observable));\nexports.ArrayLikeObservable = ArrayLikeObservable;\n//# sourceMappingURL=ArrayLikeObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/ArrayLikeObservable.js\n// module id = 140\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar Notification_1 = require('../Notification');\n/**\n *\n * Re-emits all notifications from source Observable with specified scheduler.\n *\n * <span class=\"informal\">Ensure a specific scheduler is used, from outside of an Observable.</span>\n *\n * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule\n * notifications emitted by the source Observable. It might be useful, if you do not have control over\n * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.\n *\n * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,\n * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal\n * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits\n * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.\n * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split\n * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source\n * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a\n * little bit more, to ensure that they are emitted at expected moments.\n *\n * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications\n * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`\n * will delay all notifications - including error notifications - while `delay` will pass through error\n * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator\n * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used\n * for notification emissions in general.\n *\n * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>\n * const intervals = Rx.Observable.interval(10); // Intervals are scheduled\n *                                               // with async scheduler by default...\n *\n * intervals\n * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame\n * .subscribe(val => {                           // scheduler to ensure smooth animation.\n *   someDiv.style.height = val + 'px';\n * });\n *\n * @see {@link delay}\n *\n * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.\n * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.\n * @return {Observable<T>} Observable that emits the same notifications as the source Observable,\n * but with provided scheduler.\n *\n * @method observeOn\n * @owner Observable\n */\nfunction observeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function observeOnOperatorFunction(source) {\n        return source.lift(new ObserveOnOperator(scheduler, delay));\n    };\n}\nexports.observeOn = observeOn;\nvar ObserveOnOperator = (function () {\n    function ObserveOnOperator(scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));\n    };\n    return ObserveOnOperator;\n}());\nexports.ObserveOnOperator = ObserveOnOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ObserveOnSubscriber = (function (_super) {\n    __extends(ObserveOnSubscriber, _super);\n    function ObserveOnSubscriber(destination, scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        _super.call(this, destination);\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnSubscriber.dispatch = function (arg) {\n        var notification = arg.notification, destination = arg.destination;\n        notification.observe(destination);\n        this.unsubscribe();\n    };\n    ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {\n        this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));\n    };\n    ObserveOnSubscriber.prototype._next = function (value) {\n        this.scheduleMessage(Notification_1.Notification.createNext(value));\n    };\n    ObserveOnSubscriber.prototype._error = function (err) {\n        this.scheduleMessage(Notification_1.Notification.createError(err));\n    };\n    ObserveOnSubscriber.prototype._complete = function () {\n        this.scheduleMessage(Notification_1.Notification.createComplete());\n    };\n    return ObserveOnSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ObserveOnSubscriber = ObserveOnSubscriber;\nvar ObserveOnMessage = (function () {\n    function ObserveOnMessage(notification, destination) {\n        this.notification = notification;\n        this.destination = destination;\n    }\n    return ObserveOnMessage;\n}());\nexports.ObserveOnMessage = ObserveOnMessage;\n//# sourceMappingURL=observeOn.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/observeOn.js\n// module id = 141\n// module chunks = 0","\"use strict\";\nvar Observable_1 = require('./Observable');\n/**\n * Represents a push-based event or value that an {@link Observable} can emit.\n * This class is particularly useful for operators that manage notifications,\n * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and\n * others. Besides wrapping the actual delivered value, it also annotates it\n * with metadata of, for instance, what type of push message it is (`next`,\n * `error`, or `complete`).\n *\n * @see {@link materialize}\n * @see {@link dematerialize}\n * @see {@link observeOn}\n *\n * @class Notification<T>\n */\nvar Notification = (function () {\n    function Notification(kind, value, error) {\n        this.kind = kind;\n        this.value = value;\n        this.error = error;\n        this.hasValue = kind === 'N';\n    }\n    /**\n     * Delivers to the given `observer` the value wrapped by this Notification.\n     * @param {Observer} observer\n     * @return\n     */\n    Notification.prototype.observe = function (observer) {\n        switch (this.kind) {\n            case 'N':\n                return observer.next && observer.next(this.value);\n            case 'E':\n                return observer.error && observer.error(this.error);\n            case 'C':\n                return observer.complete && observer.complete();\n        }\n    };\n    /**\n     * Given some {@link Observer} callbacks, deliver the value represented by the\n     * current Notification to the correctly corresponding callback.\n     * @param {function(value: T): void} next An Observer `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.do = function (next, error, complete) {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return next && next(this.value);\n            case 'E':\n                return error && error(this.error);\n            case 'C':\n                return complete && complete();\n        }\n    };\n    /**\n     * Takes an Observer or its individual callback functions, and calls `observe`\n     * or `do` methods accordingly.\n     * @param {Observer|function(value: T): void} nextOrObserver An Observer or\n     * the `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.accept = function (nextOrObserver, error, complete) {\n        if (nextOrObserver && typeof nextOrObserver.next === 'function') {\n            return this.observe(nextOrObserver);\n        }\n        else {\n            return this.do(nextOrObserver, error, complete);\n        }\n    };\n    /**\n     * Returns a simple Observable that just delivers the notification represented\n     * by this Notification instance.\n     * @return {any}\n     */\n    Notification.prototype.toObservable = function () {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return Observable_1.Observable.of(this.value);\n            case 'E':\n                return Observable_1.Observable.throw(this.error);\n            case 'C':\n                return Observable_1.Observable.empty();\n        }\n        throw new Error('unexpected notification kind value');\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `next` from a\n     * given value.\n     * @param {T} value The `next` value.\n     * @return {Notification<T>} The \"next\" Notification representing the\n     * argument.\n     */\n    Notification.createNext = function (value) {\n        if (typeof value !== 'undefined') {\n            return new Notification('N', value);\n        }\n        return Notification.undefinedValueNotification;\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `error` from a\n     * given error.\n     * @param {any} [err] The `error` error.\n     * @return {Notification<T>} The \"error\" Notification representing the\n     * argument.\n     */\n    Notification.createError = function (err) {\n        return new Notification('E', undefined, err);\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `complete`.\n     * @return {Notification<any>} The valueless \"complete\" Notification.\n     */\n    Notification.createComplete = function () {\n        return Notification.completeNotification;\n    };\n    Notification.completeNotification = new Notification('C');\n    Notification.undefinedValueNotification = new Notification('N', undefined);\n    return Notification;\n}());\nexports.Notification = Notification;\n//# sourceMappingURL=Notification.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/Notification.js\n// module id = 142\n// module chunks = 0","\"use strict\";\nvar mergeAll_1 = require('./mergeAll');\n/**\n * Converts a higher-order Observable into a first-order Observable by\n * concatenating the inner Observables in order.\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables by putting one\n * inner Observable after the other.</span>\n *\n * <img src=\"./img/concatAll.png\" width=\"100%\">\n *\n * Joins every Observable emitted by the source (a higher-order Observable), in\n * a serial fashion. It subscribes to each inner Observable only after the\n * previous inner Observable has completed, and merges all of their values into\n * the returned observable.\n *\n * __Warning:__ If the source Observable emits Observables quickly and\n * endlessly, and the inner Observables it emits generally complete slower than\n * the source emits, you can run into memory issues as the incoming Observables\n * collect in an unbounded buffer.\n *\n * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));\n * var firstOrder = higherOrder.concatAll();\n * firstOrder.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link combineAll}\n * @see {@link concat}\n * @see {@link concatMap}\n * @see {@link concatMapTo}\n * @see {@link exhaust}\n * @see {@link mergeAll}\n * @see {@link switch}\n * @see {@link zipAll}\n *\n * @return {Observable} An Observable emitting values from all the inner\n * Observables concatenated.\n * @method concatAll\n * @owner Observable\n */\nfunction concatAll() {\n    return mergeAll_1.mergeAll(1);\n}\nexports.concatAll = concatAll;\n//# sourceMappingURL=concatAll.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/concatAll.js\n// module id = 143\n// module chunks = 0","\"use strict\";\nfunction identity(x) {\n    return x;\n}\nexports.identity = identity;\n//# sourceMappingURL=identity.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/identity.js\n// module id = 144\n// module chunks = 0","\"use strict\";\nvar ArrayObservable_1 = require('../observable/ArrayObservable');\nvar ScalarObservable_1 = require('../observable/ScalarObservable');\nvar EmptyObservable_1 = require('../observable/EmptyObservable');\nvar concat_1 = require('../observable/concat');\nvar isScheduler_1 = require('../util/isScheduler');\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the items you specify as arguments before it begins to emit\n * items emitted by the source Observable.\n *\n * <img src=\"./img/startWith.png\" width=\"100%\">\n *\n * @param {...T} values - Items you want the modified Observable to emit first.\n * @param {Scheduler} [scheduler] - A {@link IScheduler} to use for scheduling\n * the emissions of the `next` notifications.\n * @return {Observable} An Observable that emits the items in the specified Iterable and then emits the items\n * emitted by the source Observable.\n * @method startWith\n * @owner Observable\n */\nfunction startWith() {\n    var array = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        array[_i - 0] = arguments[_i];\n    }\n    return function (source) {\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len === 1) {\n            return concat_1.concat(new ScalarObservable_1.ScalarObservable(array[0], scheduler), source);\n        }\n        else if (len > 1) {\n            return concat_1.concat(new ArrayObservable_1.ArrayObservable(array, scheduler), source);\n        }\n        else {\n            return concat_1.concat(new EmptyObservable_1.EmptyObservable(scheduler), source);\n        }\n    };\n}\nexports.startWith = startWith;\n//# sourceMappingURL=startWith.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/startWith.js\n// module id = 145\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar ArgumentOutOfRangeError_1 = require('../util/ArgumentOutOfRangeError');\nvar EmptyObservable_1 = require('../observable/EmptyObservable');\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return function (source) {\n        if (count === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else {\n            return source.lift(new TakeOperator(count));\n        }\n    };\n}\nexports.take = take;\nvar TakeOperator = (function () {\n    function TakeOperator(total) {\n        this.total = total;\n        if (this.total < 0) {\n            throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;\n        }\n    }\n    TakeOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new TakeSubscriber(subscriber, this.total));\n    };\n    return TakeOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar TakeSubscriber = (function (_super) {\n    __extends(TakeSubscriber, _super);\n    function TakeSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    TakeSubscriber.prototype._next = function (value) {\n        var total = this.total;\n        var count = ++this.count;\n        if (count <= total) {\n            this.destination.next(value);\n            if (count === total) {\n                this.destination.complete();\n                this.unsubscribe();\n            }\n        }\n    };\n    return TakeSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=take.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/take.js\n// module id = 146\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an element was queried at a certain index of an\n * Observable, but no such index or position exists in that sequence.\n *\n * @see {@link elementAt}\n * @see {@link take}\n * @see {@link takeLast}\n *\n * @class ArgumentOutOfRangeError\n */\nvar ArgumentOutOfRangeError = (function (_super) {\n    __extends(ArgumentOutOfRangeError, _super);\n    function ArgumentOutOfRangeError() {\n        var err = _super.call(this, 'argument out of range');\n        this.name = err.name = 'ArgumentOutOfRangeError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ArgumentOutOfRangeError;\n}(Error));\nexports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;\n//# sourceMappingURL=ArgumentOutOfRangeError.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/ArgumentOutOfRangeError.js\n// module id = 147\n// module chunks = 0","import { IncomingPayload } from \"../messages/ScrollEvent\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { Observable } from \"rxjs/Observable\";\nimport { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { partition } from \"rxjs/operators/partition\";\nimport { merge } from \"rxjs/observable/merge\";\nimport { getDocumentScrollSpace } from \"../browser.utils\";\nimport { tap } from \"rxjs/operators/tap\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { map } from \"rxjs/operators/map\";\n\ntype Tuple = [IncomingPayload, Window, Document, boolean];\n\nexport function setScrollEffect(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    {\n        /**\n         * Group the incoming event with window, document & scrollProportionally argument\n         */\n        const tupleStream$: Observable<Tuple> = xs.pipe(\n            withLatestFrom<IncomingPayload, Window, Document, boolean>(\n                inputs.window$,\n                inputs.document$,\n                inputs.option$.pipe(pluck(\"scrollProportionally\"))\n            )\n        );\n\n        /**\n         * Split the stream between document scrolls and element scrolls\n         */\n        const [document$, element$] = partition(([event]: Tuple) => {\n            return event.tagName === \"document\";\n        })(tupleStream$);\n\n        /**\n         * Further split the element scroll between those matching in `scrollElementMapping`\n         * and regular element scrolls\n         */\n        const [mapped$, nonMapped$] = partition(([event]: Tuple) => {\n            return event.mappingIndex > -1;\n        })(element$);\n\n        return merge(\n            /**\n             * Main window scroll\n             */\n            document$.pipe(\n                tap((incoming: Tuple) => {\n                    const [\n                        event,\n                        window,\n                        document,\n                        scrollProportionally\n                    ] = incoming;\n                    const scrollSpace = getDocumentScrollSpace(document);\n\n                    if (scrollProportionally) {\n                        return window.scrollTo(\n                            0,\n                            scrollSpace.y * event.position.proportional\n                        ); // % of y axis of scroll to px\n                    }\n                    return window.scrollTo(0, event.position.raw.y);\n                })\n            ),\n            /**\n             * Regular, non-mapped Element scrolls\n             */\n            nonMapped$.pipe(\n                tap((incoming: Tuple) => {\n                    const [\n                        event,\n                        window,\n                        document,\n                        scrollProportionally\n                    ] = incoming;\n\n                    const matchingElements = document.getElementsByTagName(\n                        event.tagName\n                    );\n                    if (matchingElements && matchingElements.length) {\n                        const match = matchingElements[event.index];\n                        if (match) {\n                            return scrollElement(\n                                match,\n                                scrollProportionally,\n                                event\n                            );\n                        }\n                    }\n                })\n            ),\n            /**\n             * Element scrolls given in 'scrollElementMapping'\n             */\n            mapped$.pipe(\n                withLatestFrom(\n                    inputs.option$.pipe(pluck(\"scrollElementMapping\"))\n                ),\n                /**\n                 * Filter the elements in the option `scrollElementMapping` so\n                 * that it does not contain the element that triggered the event\n                 */\n                map(([incoming, scrollElementMapping]: [Tuple, string[]]) => {\n                    const [event] = incoming;\n                    return [\n                        incoming,\n                        scrollElementMapping.filter(\n                            (item, index) => index !== event.mappingIndex\n                        )\n                    ];\n                }),\n                /**\n                 * Now perform the scroll on all other matching elements\n                 */\n                tap(([incoming, scrollElementMapping]: [Tuple, string[]]) => {\n                    const [\n                        event,\n                        window,\n                        document,\n                        scrollProportionally\n                    ] = incoming;\n                    scrollElementMapping\n                        .map(selector => document.querySelector(selector))\n                        .forEach(element => {\n                            scrollElement(element, scrollProportionally, event);\n                        });\n                })\n            )\n        ).pipe(ignoreElements());\n    }\n}\n\nfunction scrollElement(element, scrollProportionally, event: IncomingPayload) {\n    if (scrollProportionally) {\n        return element.scrollTo(\n            0,\n            element.scrollHeight * event.position.proportional\n        ); // % of y axis of scroll to px\n    }\n    return element.scrollTo(0, event.position.raw.y);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/effects/set-scroll.ts","\"use strict\";\nvar not_1 = require('../util/not');\nvar filter_1 = require('./filter');\n/**\n * Splits the source Observable into two, one with values that satisfy a\n * predicate, and another with values that don't satisfy the predicate.\n *\n * <span class=\"informal\">It's like {@link filter}, but returns two Observables:\n * one like the output of {@link filter}, and the other with values that did not\n * pass the condition.</span>\n *\n * <img src=\"./img/partition.png\" width=\"100%\">\n *\n * `partition` outputs an array with two Observables that partition the values\n * from the source Observable through the given `predicate` function. The first\n * Observable in that array emits source values for which the predicate argument\n * returns true. The second Observable emits source values for which the\n * predicate returns false. The first behaves like {@link filter} and the second\n * behaves like {@link filter} with the predicate negated.\n *\n * @example <caption>Partition click events into those on DIV elements and those elsewhere</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var parts = clicks.partition(ev => ev.target.tagName === 'DIV');\n * var clicksOnDivs = parts[0];\n * var clicksElsewhere = parts[1];\n * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));\n * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));\n *\n * @see {@link filter}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted on the first Observable in the returned array, if\n * `false` the value is emitted on the second Observable in the array. The\n * `index` parameter is the number `i` for the i-th source emission that has\n * happened since the subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {[Observable<T>, Observable<T>]} An array with two Observables: one\n * with values that passed the predicate, and another with values that did not\n * pass the predicate.\n * @method partition\n * @owner Observable\n */\nfunction partition(predicate, thisArg) {\n    return function (source) { return [\n        filter_1.filter(predicate, thisArg)(source),\n        filter_1.filter(not_1.not(predicate, thisArg))(source)\n    ]; };\n}\nexports.partition = partition;\n//# sourceMappingURL=partition.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/partition.js\n// module id = 149\n// module chunks = 0","\"use strict\";\nfunction not(pred, thisArg) {\n    function notPred() {\n        return !(notPred.pred.apply(notPred.thisArg, arguments));\n    }\n    notPred.pred = pred;\n    notPred.thisArg = thisArg;\n    return notPred;\n}\nexports.not = not;\n//# sourceMappingURL=not.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/not.js\n// module id = 150\n// module chunks = 0","import { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as Log from \"../log\";\n\nexport interface IncomingPayload {\n    message: string;\n    timeout: number;\n    override?: boolean;\n}\n\nexport function incomingBrowserNotify(xs: Observable<IncomingPayload>) {\n    return xs.pipe(map(event => Log.overlayInfo(event.message, event.timeout)));\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/BrowserNotify.ts","import { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { browserSetLocation } from \"../effects/browser-set-location.effect\";\n\nexport interface IncomingPayload {\n    url?: string;\n    path?: number;\n}\n\nexport function incomingBrowserLocation(\n    xs: Observable<IncomingPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.option$.pipe(pluck(\"ghostMode\", \"location\"))),\n        filter(([, canSyncLocation]) => canSyncLocation === true),\n        map(([event]) => browserSetLocation(event))\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/BrowserLocation.ts","\"use strict\";\nvar SubscribeOnObservable_1 = require('../observable/SubscribeOnObservable');\n/**\n * Asynchronously subscribes Observers to this Observable on the specified IScheduler.\n *\n * <img src=\"./img/subscribeOn.png\" width=\"100%\">\n *\n * @param {Scheduler} scheduler - The IScheduler to perform subscription actions on.\n * @return {Observable<T>} The source Observable modified so that its subscriptions happen on the specified IScheduler.\n .\n * @method subscribeOn\n * @owner Observable\n */\nfunction subscribeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function subscribeOnOperatorFunction(source) {\n        return source.lift(new SubscribeOnOperator(scheduler, delay));\n    };\n}\nexports.subscribeOn = subscribeOn;\nvar SubscribeOnOperator = (function () {\n    function SubscribeOnOperator(scheduler, delay) {\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    SubscribeOnOperator.prototype.call = function (subscriber, source) {\n        return new SubscribeOnObservable_1.SubscribeOnObservable(source, this.delay, this.scheduler).subscribe(subscriber);\n    };\n    return SubscribeOnOperator;\n}());\n//# sourceMappingURL=subscribeOn.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/subscribeOn.js\n// module id = 153\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar asap_1 = require('../scheduler/asap');\nvar isNumeric_1 = require('../util/isNumeric');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar SubscribeOnObservable = (function (_super) {\n    __extends(SubscribeOnObservable, _super);\n    function SubscribeOnObservable(source, delayTime, scheduler) {\n        if (delayTime === void 0) { delayTime = 0; }\n        if (scheduler === void 0) { scheduler = asap_1.asap; }\n        _super.call(this);\n        this.source = source;\n        this.delayTime = delayTime;\n        this.scheduler = scheduler;\n        if (!isNumeric_1.isNumeric(delayTime) || delayTime < 0) {\n            this.delayTime = 0;\n        }\n        if (!scheduler || typeof scheduler.schedule !== 'function') {\n            this.scheduler = asap_1.asap;\n        }\n    }\n    SubscribeOnObservable.create = function (source, delay, scheduler) {\n        if (delay === void 0) { delay = 0; }\n        if (scheduler === void 0) { scheduler = asap_1.asap; }\n        return new SubscribeOnObservable(source, delay, scheduler);\n    };\n    SubscribeOnObservable.dispatch = function (arg) {\n        var source = arg.source, subscriber = arg.subscriber;\n        return this.add(source.subscribe(subscriber));\n    };\n    SubscribeOnObservable.prototype._subscribe = function (subscriber) {\n        var delay = this.delayTime;\n        var source = this.source;\n        var scheduler = this.scheduler;\n        return scheduler.schedule(SubscribeOnObservable.dispatch, delay, {\n            source: source, subscriber: subscriber\n        });\n    };\n    return SubscribeOnObservable;\n}(Observable_1.Observable));\nexports.SubscribeOnObservable = SubscribeOnObservable;\n//# sourceMappingURL=SubscribeOnObservable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/SubscribeOnObservable.js\n// module id = 154\n// module chunks = 0","\"use strict\";\nvar AsapAction_1 = require('./AsapAction');\nvar AsapScheduler_1 = require('./AsapScheduler');\n/**\n *\n * Asap Scheduler\n *\n * <span class=\"informal\">Perform task as fast as it can be performed asynchronously</span>\n *\n * `asap` scheduler behaves the same as {@link async} scheduler when you use it to delay task\n * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing\n * code to end and then it will try to execute given task as fast as possible.\n *\n * `asap` scheduler will do its best to minimize time between end of currently executing code\n * and start of scheduled task. This makes it best candidate for performing so called \"deferring\".\n * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves\n * some (although minimal) unwanted delay.\n *\n * Note that using `asap` scheduler does not necessarily mean that your task will be first to process\n * after currently executing code. In particular, if some task was also scheduled with `asap` before,\n * that task will execute first. That being said, if you need to schedule task asynchronously, but\n * as soon as possible, `asap` scheduler is your best bet.\n *\n * @example <caption>Compare async and asap scheduler</caption>\n *\n * Rx.Scheduler.async.schedule(() => console.log('async')); // scheduling 'async' first...\n * Rx.Scheduler.asap.schedule(() => console.log('asap'));\n *\n * // Logs:\n * // \"asap\"\n * // \"async\"\n * // ... but 'asap' goes first!\n *\n * @static true\n * @name asap\n * @owner Scheduler\n */\nexports.asap = new AsapScheduler_1.AsapScheduler(AsapAction_1.AsapAction);\n//# sourceMappingURL=asap.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/asap.js\n// module id = 155\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Immediate_1 = require('../util/Immediate');\nvar AsyncAction_1 = require('./AsyncAction');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsapAction = (function (_super) {\n    __extends(AsapAction, _super);\n    function AsapAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.work = work;\n    }\n    AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay is greater than 0, request as an async action.\n        if (delay !== null && delay > 0) {\n            return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);\n        }\n        // Push the action to the end of the scheduler queue.\n        scheduler.actions.push(this);\n        // If a microtask has already been scheduled, don't schedule another\n        // one. If a microtask hasn't been scheduled yet, schedule one now. Return\n        // the current scheduled microtask id.\n        return scheduler.scheduled || (scheduler.scheduled = Immediate_1.Immediate.setImmediate(scheduler.flush.bind(scheduler, null)));\n    };\n    AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay exists and is greater than 0, or if the delay is null (the\n        // action wasn't rescheduled) but was originally scheduled as an async\n        // action, then recycle as an async action.\n        if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {\n            return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);\n        }\n        // If the scheduler queue is empty, cancel the requested microtask and\n        // set the scheduled flag to undefined so the next AsapAction will schedule\n        // its own.\n        if (scheduler.actions.length === 0) {\n            Immediate_1.Immediate.clearImmediate(id);\n            scheduler.scheduled = undefined;\n        }\n        // Return undefined so the action knows to request a new async id if it's rescheduled.\n        return undefined;\n    };\n    return AsapAction;\n}(AsyncAction_1.AsyncAction));\nexports.AsapAction = AsapAction;\n//# sourceMappingURL=AsapAction.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/AsapAction.js\n// module id = 156\n// module chunks = 0","/**\nSome credit for this helper goes to http://github.com/YuzuJS/setImmediate\n*/\n\"use strict\";\nvar root_1 = require('./root');\nvar ImmediateDefinition = (function () {\n    function ImmediateDefinition(root) {\n        this.root = root;\n        if (root.setImmediate && typeof root.setImmediate === 'function') {\n            this.setImmediate = root.setImmediate.bind(root);\n            this.clearImmediate = root.clearImmediate.bind(root);\n        }\n        else {\n            this.nextHandle = 1;\n            this.tasksByHandle = {};\n            this.currentlyRunningATask = false;\n            // Don't get fooled by e.g. browserify environments.\n            if (this.canUseProcessNextTick()) {\n                // For Node.js before 0.9\n                this.setImmediate = this.createProcessNextTickSetImmediate();\n            }\n            else if (this.canUsePostMessage()) {\n                // For non-IE10 modern browsers\n                this.setImmediate = this.createPostMessageSetImmediate();\n            }\n            else if (this.canUseMessageChannel()) {\n                // For web workers, where supported\n                this.setImmediate = this.createMessageChannelSetImmediate();\n            }\n            else if (this.canUseReadyStateChange()) {\n                // For IE 6–8\n                this.setImmediate = this.createReadyStateChangeSetImmediate();\n            }\n            else {\n                // For older browsers\n                this.setImmediate = this.createSetTimeoutSetImmediate();\n            }\n            var ci = function clearImmediate(handle) {\n                delete clearImmediate.instance.tasksByHandle[handle];\n            };\n            ci.instance = this;\n            this.clearImmediate = ci;\n        }\n    }\n    ImmediateDefinition.prototype.identify = function (o) {\n        return this.root.Object.prototype.toString.call(o);\n    };\n    ImmediateDefinition.prototype.canUseProcessNextTick = function () {\n        return this.identify(this.root.process) === '[object process]';\n    };\n    ImmediateDefinition.prototype.canUseMessageChannel = function () {\n        return Boolean(this.root.MessageChannel);\n    };\n    ImmediateDefinition.prototype.canUseReadyStateChange = function () {\n        var document = this.root.document;\n        return Boolean(document && 'onreadystatechange' in document.createElement('script'));\n    };\n    ImmediateDefinition.prototype.canUsePostMessage = function () {\n        var root = this.root;\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `root.postMessage` means something completely different and can't be used for this purpose.\n        if (root.postMessage && !root.importScripts) {\n            var postMessageIsAsynchronous_1 = true;\n            var oldOnMessage = root.onmessage;\n            root.onmessage = function () {\n                postMessageIsAsynchronous_1 = false;\n            };\n            root.postMessage('', '*');\n            root.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous_1;\n        }\n        return false;\n    };\n    // This function accepts the same arguments as setImmediate, but\n    // returns a function that requires no arguments.\n    ImmediateDefinition.prototype.partiallyApplied = function (handler) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var fn = function result() {\n            var _a = result, handler = _a.handler, args = _a.args;\n            if (typeof handler === 'function') {\n                handler.apply(undefined, args);\n            }\n            else {\n                (new Function('' + handler))();\n            }\n        };\n        fn.handler = handler;\n        fn.args = args;\n        return fn;\n    };\n    ImmediateDefinition.prototype.addFromSetImmediateArguments = function (args) {\n        this.tasksByHandle[this.nextHandle] = this.partiallyApplied.apply(undefined, args);\n        return this.nextHandle++;\n    };\n    ImmediateDefinition.prototype.createProcessNextTickSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent, handle));\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createPostMessageSetImmediate = function () {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n        var root = this.root;\n        var messagePrefix = 'setImmediate$' + root.Math.random() + '$';\n        var onGlobalMessage = function globalMessageHandler(event) {\n            var instance = globalMessageHandler.instance;\n            if (event.source === root &&\n                typeof event.data === 'string' &&\n                event.data.indexOf(messagePrefix) === 0) {\n                instance.runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n        onGlobalMessage.instance = this;\n        root.addEventListener('message', onGlobalMessage, false);\n        var fn = function setImmediate() {\n            var _a = setImmediate, messagePrefix = _a.messagePrefix, instance = _a.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.postMessage(messagePrefix + handle, '*');\n            return handle;\n        };\n        fn.instance = this;\n        fn.messagePrefix = messagePrefix;\n        return fn;\n    };\n    ImmediateDefinition.prototype.runIfPresent = function (handle) {\n        // From the spec: 'Wait until any invocations of this algorithm started before this one have completed.'\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (this.currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // 'too much recursion' error.\n            this.root.setTimeout(this.partiallyApplied(this.runIfPresent, handle), 0);\n        }\n        else {\n            var task = this.tasksByHandle[handle];\n            if (task) {\n                this.currentlyRunningATask = true;\n                try {\n                    task();\n                }\n                finally {\n                    this.clearImmediate(handle);\n                    this.currentlyRunningATask = false;\n                }\n            }\n        }\n    };\n    ImmediateDefinition.prototype.createMessageChannelSetImmediate = function () {\n        var _this = this;\n        var channel = new this.root.MessageChannel();\n        channel.port1.onmessage = function (event) {\n            var handle = event.data;\n            _this.runIfPresent(handle);\n        };\n        var fn = function setImmediate() {\n            var _a = setImmediate, channel = _a.channel, instance = _a.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            channel.port2.postMessage(handle);\n            return handle;\n        };\n        fn.channel = channel;\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createReadyStateChangeSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var root = instance.root;\n            var doc = root.document;\n            var html = doc.documentElement;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement('script');\n            script.onreadystatechange = function () {\n                instance.runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    ImmediateDefinition.prototype.createSetTimeoutSetImmediate = function () {\n        var fn = function setImmediate() {\n            var instance = setImmediate.instance;\n            var handle = instance.addFromSetImmediateArguments(arguments);\n            instance.root.setTimeout(instance.partiallyApplied(instance.runIfPresent, handle), 0);\n            return handle;\n        };\n        fn.instance = this;\n        return fn;\n    };\n    return ImmediateDefinition;\n}());\nexports.ImmediateDefinition = ImmediateDefinition;\nexports.Immediate = new ImmediateDefinition(root_1.root);\n//# sourceMappingURL=Immediate.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/Immediate.js\n// module id = 157\n// module chunks = 0","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/setimmediate/setImmediate.js\n// module id = 158\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar AsyncScheduler_1 = require('./AsyncScheduler');\nvar AsapScheduler = (function (_super) {\n    __extends(AsapScheduler, _super);\n    function AsapScheduler() {\n        _super.apply(this, arguments);\n    }\n    AsapScheduler.prototype.flush = function (action) {\n        this.active = true;\n        this.scheduled = undefined;\n        var actions = this.actions;\n        var error;\n        var index = -1;\n        var count = actions.length;\n        action = action || actions.shift();\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (++index < count && (action = actions.shift()));\n        this.active = false;\n        if (error) {\n            while (++index < count && (action = actions.shift())) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsapScheduler;\n}(AsyncScheduler_1.AsyncScheduler));\nexports.AsapScheduler = AsapScheduler;\n//# sourceMappingURL=AsapScheduler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/AsapScheduler.js\n// module id = 159\n// module chunks = 0","import { Inputs } from \"../index\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { empty } from \"rxjs/observable/empty\";\nimport { isBlacklisted } from \"../utils\";\nimport { FileReloadEventPayload } from \"../../types/socket\";\nimport { of } from \"rxjs/observable/of\";\nimport { Observable } from \"rxjs/Observable\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { fileReload } from \"../effects/file-reload.effect\";\nimport { reloadBrowserSafe } from \"./BrowserReload\";\n\nexport function incomingFileReload(\n    xs: Observable<FileReloadEventPayload>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.option$),\n        filter(([event, options]) => options.codeSync),\n        mergeMap(([event, options]) => {\n            if (event.url || !options.injectChanges) {\n                return reloadBrowserSafe();\n            }\n            if (event.basename && event.ext && isBlacklisted(event)) {\n                return empty();\n            }\n            return of(fileReload(event));\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/FileReload.ts","import { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { of } from \"rxjs/observable/of\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as Log from \"../log\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { setOptions } from \"../effects/set-options.effect\";\nimport { reloadBrowserSafe } from \"./BrowserReload\";\n\nexport function incomingConnection(\n    xs: Observable<IBrowserSyncOptions>,\n    inputs: Inputs\n) {\n    return xs.pipe(\n        withLatestFrom(inputs.option$.pipe(pluck(\"logPrefix\"))),\n        mergeMap(([x, logPrefix], index) => {\n            if (index === 0) {\n                return of<any>(\n                    setOptions(x),\n                    Log.overlayInfo(`${logPrefix}: connected`)\n                );\n            }\n            return reloadBrowserSafe();\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/Connection.ts","import { ignoreElements } from \"rxjs/operators/ignoreElements\";\nimport { Observable } from \"rxjs/Observable\";\nimport { tap } from \"rxjs/operators/tap\";\n\nexport function incomingDisconnect(xs: Observable<any>) {\n    return xs.pipe(tap(x => console.log(x)), ignoreElements());\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/Disconnect.ts","import { map } from \"rxjs/operators/map\";\nimport { Observable } from \"rxjs/Observable\";\nimport { setOptions } from \"../effects/set-options.effect\";\nimport { tap } from \"rxjs/operators/tap\";\n\nexport interface Payload {\n    options: IBrowserSyncOptions;\n    path: string[];\n    value: any;\n}\n\ntype IncomingPayload = Payload;\n\nexport function incomingOptionsSet(xs: Observable<IncomingPayload>) {\n    return xs.pipe(map(event => setOptions(event.options)));\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/messages/OptionsSet.ts","import { getBrowserScrollPosition } from \"./browser.utils\";\nimport { EffectNames } from \"./effects\";\nimport { Observable } from \"rxjs/Observable\";\nimport { BehaviorSubject } from \"rxjs/BehaviorSubject\";\nimport { Inputs } from \"./index\";\nimport { empty } from \"rxjs/observable/empty\";\nimport { of } from \"rxjs/observable/of\";\nimport * as Log from \"./log\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { take } from \"rxjs/operators/take\";\nimport { mergeMap } from \"rxjs/operators/mergeMap\";\nimport { map } from \"rxjs/operators/map\";\nimport { setWindowName } from \"./dom-effects/set-window-name.dom-effect\";\nimport { setScroll } from \"./dom-effects/set-scroll.dom-effect\";\n\nexport const PREFIX = \"<<BS_START>>\";\nexport const SUFFIX = \"<<BS_START>>\";\nexport const regex = new RegExp(PREFIX + \"(.+?)\" + SUFFIX);\n\nexport function initWindowName(window: Window) {\n    const saved = (() => {\n        /**\n         * On page load, check window.name for an existing\n         * BS json blob & parse it.\n         */\n        try {\n            const json = window.name.match(regex);\n            if (json) {\n                return JSON.parse(json[1]);\n            }\n        } catch (e) {\n            return {};\n        }\n    })();\n\n    /**\n     * Remove any existing BS json from window.name\n     * to ensure we don't interfere with any other\n     * libs who may be using it.\n     */\n    window.name = window.name.replace(regex, \"\");\n\n    /**\n     * If the JSON was parsed correctly, try to\n     * find a scroll property and restore it.\n     */\n    if (saved && saved.bs && saved.bs.hardReload && saved.bs.scroll) {\n        const { x, y } = saved.bs.scroll;\n        return of<any>(\n            setScroll(x, y),\n            Log.consoleDebug(`[ScrollRestore] x = ${x} y = ${y}`)\n        );\n    }\n    return empty();\n}\n\nexport const scrollRestoreHandlers$ = new BehaviorSubject({\n    // [EffectNames.SetOptions]: (xs, inputs: Inputs) => {\n    //     return xs.pipe(\n    //         withLatestFrom(inputs.window$),\n    //         take(1),\n    //         mergeMap(([options, window]) => {\n    //             if (options.scrollRestoreTechnique === \"window.name\") {\n    //                 return initWindowName(window);\n    //             }\n    //             return empty();\n    //         })\n    //     );\n    // },\n    /**\n     * Save the current scroll position\n     * before the browser is reloaded (via window.location.reload(true))\n     * @param xs\n     * @param {Inputs} inputs\n     */\n    [EffectNames.PreBrowserReload]: (xs: Observable<any>, inputs: Inputs) => {\n        return xs.pipe(\n            withLatestFrom(inputs.window$, inputs.document$),\n            map(([, window, document]) => {\n                return [\n                    window.name,\n                    PREFIX,\n                    JSON.stringify({\n                        bs: {\n                            hardReload: true,\n                            scroll: getBrowserScrollPosition(window, document)\n                        }\n                    }),\n                    SUFFIX\n                ].join(\"\");\n            }),\n            map(value => setWindowName(value))\n        );\n    }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./lib/scroll-restore.ts","import { merge } from \"rxjs/observable/merge\";\nimport { getFormInputStream } from \"./listeners/form-inputs.listener\";\nimport { getClickStream } from \"./listeners/clicks.listener\";\nimport { getScrollStream } from \"./listeners/scroll.listener\";\nimport { getFormTogglesStream } from \"./listeners/form-toggles.listener\";\nimport { OutgoingSocketEvent } from \"./socket-messages\";\nimport { Observable } from \"rxjs/Observable\";\nimport { Inputs } from \"./index\";\n\nexport function initListeners(\n    window: Window,\n    document: Document,\n    socket$: Inputs[\"socket$\"],\n    option$: Inputs[\"option$\"]\n): Observable<OutgoingSocketEvent> {\n    const merged$ = merge(\n        getScrollStream(window, document, socket$, option$),\n        getClickStream(document, socket$, option$),\n        getFormInputStream(document, socket$, option$),\n        getFormTogglesStream(document, socket$, option$)\n    );\n\n    return merged$;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/listeners.ts","import { IncomingSocketNames, OutgoingSocketEvent } from \"../socket-messages\";\nimport { getElementData } from \"../browser.utils\";\nimport { Observable } from \"rxjs/Observable\";\nimport { createTimedBooleanSwitch } from \"../utils\";\nimport * as KeyupEvent from \"../messages/KeyupEvent\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { map } from \"rxjs/operators/map\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { skip } from \"rxjs/operators/skip\";\nimport { distinctUntilChanged } from \"rxjs/operators/distinctUntilChanged\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { empty } from \"rxjs/observable/empty\";\nimport { fromEvent } from \"rxjs/observable/fromEvent\";\nimport { Inputs } from \"../index\";\n\nexport function getFormInputStream(\n    document: Document,\n    socket$: Inputs[\"socket$\"],\n    option$: Inputs[\"option$\"]\n): Observable<OutgoingSocketEvent> {\n    const canSync$ = createTimedBooleanSwitch(\n        socket$.pipe(filter(([name]) => name === IncomingSocketNames.Keyup))\n    );\n    return option$.pipe(\n        skip(1), // initial option set before the connection event\n        pluck(\"ghostMode\", \"forms\", \"inputs\"),\n        distinctUntilChanged(),\n        switchMap(formInputs => {\n            if (!formInputs) {\n                return empty();\n            }\n            return fromEvent(document.body, \"keyup\", true).pipe(\n                map((e: Event) => e.target || e.srcElement),\n                filter(\n                    (target: Element) =>\n                        target.tagName === \"INPUT\" ||\n                        target.tagName === \"TEXTAREA\"\n                ),\n                withLatestFrom(canSync$),\n                filter(([, canSync]) => canSync),\n                map(([eventTarget]) => {\n                    const target = getElementData(eventTarget);\n                    const value = eventTarget.value;\n\n                    return KeyupEvent.outgoing(target, value);\n                })\n            );\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/listeners/form-inputs.listener.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar tryCatch_1 = require('../util/tryCatch');\nvar isFunction_1 = require('../util/isFunction');\nvar errorObject_1 = require('../util/errorObject');\nvar Subscription_1 = require('../Subscription');\nvar toString = Object.prototype.toString;\nfunction isNodeStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';\n}\nfunction isJQueryStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';\n}\nfunction isNodeList(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object NodeList]';\n}\nfunction isHTMLCollection(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object HTMLCollection]';\n}\nfunction isEventTarget(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';\n}\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromEventObservable = (function (_super) {\n    __extends(FromEventObservable, _super);\n    function FromEventObservable(sourceObj, eventName, selector, options) {\n        _super.call(this);\n        this.sourceObj = sourceObj;\n        this.eventName = eventName;\n        this.selector = selector;\n        this.options = options;\n    }\n    /* tslint:enable:max-line-length */\n    /**\n     * Creates an Observable that emits events of a specific type coming from the\n     * given event target.\n     *\n     * <span class=\"informal\">Creates an Observable from DOM events, or Node.js\n     * EventEmitter events or others.</span>\n     *\n     * <img src=\"./img/fromEvent.png\" width=\"100%\">\n     *\n     * `fromEvent` accepts as a first argument event target, which is an object with methods\n     * for registering event handler functions. As a second argument it takes string that indicates\n     * type of event we want to listen for. `fromEvent` supports selected types of event targets,\n     * which are described in detail below. If your event target does not match any of the ones listed,\n     * you should use {@link fromEventPattern}, which can be used on arbitrary APIs.\n     * When it comes to APIs supported by `fromEvent`, their methods for adding and removing event\n     * handler functions have different names, but they all accept a string describing event type\n     * and function itself, which will be called whenever said event happens.\n     *\n     * Every time resulting Observable is subscribed, event handler function will be registered\n     * to event target on given event type. When that event fires, value\n     * passed as a first argument to registered function will be emitted by output Observable.\n     * When Observable is unsubscribed, function will be unregistered from event target.\n     *\n     * Note that if event target calls registered function with more than one argument, second\n     * and following arguments will not appear in resulting stream. In order to get access to them,\n     * you can pass to `fromEvent` optional project function, which will be called with all arguments\n     * passed to event handler. Output Observable will then emit value returned by project function,\n     * instead of the usual value.\n     *\n     * Remember that event targets listed below are checked via duck typing. It means that\n     * no matter what kind of object you have and no matter what environment you work in,\n     * you can safely use `fromEvent` on that object if it exposes described methods (provided\n     * of course they behave as was described above). So for example if Node.js library exposes\n     * event target which has the same method names as DOM EventTarget, `fromEvent` is still\n     * a good choice.\n     *\n     * If the API you use is more callback then event handler oriented (subscribed\n     * callback function fires only once and thus there is no need to manually\n     * unregister it), you should use {@link bindCallback} or {@link bindNodeCallback}\n     * instead.\n     *\n     * `fromEvent` supports following types of event targets:\n     *\n     * **DOM EventTarget**\n     *\n     * This is an object with `addEventListener` and `removeEventListener` methods.\n     *\n     * In the browser, `addEventListener` accepts - apart from event type string and event\n     * handler function arguments - optional third parameter, which is either an object or boolean,\n     * both used for additional configuration how and when passed function will be called. When\n     * `fromEvent` is used with event target of that type, you can provide this values\n     * as third parameter as well.\n     *\n     * **Node.js EventEmitter**\n     *\n     * An object with `addListener` and `removeListener` methods.\n     *\n     * **JQuery-style event target**\n     *\n     * An object with `on` and `off` methods\n     *\n     * **DOM NodeList**\n     *\n     * List of DOM Nodes, returned for example by `document.querySelectorAll` or `Node.childNodes`.\n     *\n     * Although this collection is not event target in itself, `fromEvent` will iterate over all Nodes\n     * it contains and install event handler function in every of them. When returned Observable\n     * is unsubscribed, function will be removed from all Nodes.\n     *\n     * **DOM HtmlCollection**\n     *\n     * Just as in case of NodeList it is a collection of DOM nodes. Here as well event handler function is\n     * installed and removed in each of elements.\n     *\n     *\n     * @example <caption>Emits clicks happening on the DOM document</caption>\n     * var clicks = Rx.Observable.fromEvent(document, 'click');\n     * clicks.subscribe(x => console.log(x));\n     *\n     * // Results in:\n     * // MouseEvent object logged to console every time a click\n     * // occurs on the document.\n     *\n     *\n     * @example <caption>Use addEventListener with capture option</caption>\n     * var clicksInDocument = Rx.Observable.fromEvent(document, 'click', true); // note optional configuration parameter\n     *                                                                          // which will be passed to addEventListener\n     * var clicksInDiv = Rx.Observable.fromEvent(someDivInDocument, 'click');\n     *\n     * clicksInDocument.subscribe(() => console.log('document'));\n     * clicksInDiv.subscribe(() => console.log('div'));\n     *\n     * // By default events bubble UP in DOM tree, so normally\n     * // when we would click on div in document\n     * // \"div\" would be logged first and then \"document\".\n     * // Since we specified optional `capture` option, document\n     * // will catch event when it goes DOWN DOM tree, so console\n     * // will log \"document\" and then \"div\".\n     *\n     * @see {@link bindCallback}\n     * @see {@link bindNodeCallback}\n     * @see {@link fromEventPattern}\n     *\n     * @param {EventTargetLike} target The DOM EventTarget, Node.js\n     * EventEmitter, JQuery-like event target, NodeList or HTMLCollection to attach the event handler to.\n     * @param {string} eventName The event name of interest, being emitted by the\n     * `target`.\n     * @param {EventListenerOptions} [options] Options to pass through to addEventListener\n     * @param {SelectorMethodSignature<T>} [selector] An optional function to\n     * post-process results. It takes the arguments from the event handler and\n     * should return a single value.\n     * @return {Observable<T>}\n     * @static true\n     * @name fromEvent\n     * @owner Observable\n     */\n    FromEventObservable.create = function (target, eventName, options, selector) {\n        if (isFunction_1.isFunction(options)) {\n            selector = options;\n            options = undefined;\n        }\n        return new FromEventObservable(target, eventName, selector, options);\n    };\n    FromEventObservable.setupSubscription = function (sourceObj, eventName, handler, subscriber, options) {\n        var unsubscribe;\n        if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {\n            for (var i = 0, len = sourceObj.length; i < len; i++) {\n                FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber, options);\n            }\n        }\n        else if (isEventTarget(sourceObj)) {\n            var source_1 = sourceObj;\n            sourceObj.addEventListener(eventName, handler, options);\n            unsubscribe = function () {\n                return source_1.removeEventListener(eventName, handler);\n            };\n        }\n        else if (isJQueryStyleEventEmitter(sourceObj)) {\n            var source_2 = sourceObj;\n            sourceObj.on(eventName, handler);\n            unsubscribe = function () { return source_2.off(eventName, handler); };\n        }\n        else if (isNodeStyleEventEmitter(sourceObj)) {\n            var source_3 = sourceObj;\n            sourceObj.addListener(eventName, handler);\n            unsubscribe = function () { return source_3.removeListener(eventName, handler); };\n        }\n        else {\n            throw new TypeError('Invalid event target');\n        }\n        subscriber.add(new Subscription_1.Subscription(unsubscribe));\n    };\n    FromEventObservable.prototype._subscribe = function (subscriber) {\n        var sourceObj = this.sourceObj;\n        var eventName = this.eventName;\n        var options = this.options;\n        var selector = this.selector;\n        var handler = selector ? function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            var result = tryCatch_1.tryCatch(selector).apply(void 0, args);\n            if (result === errorObject_1.errorObject) {\n                subscriber.error(errorObject_1.errorObject.e);\n            }\n            else {\n                subscriber.next(result);\n            }\n        } : function (e) { return subscriber.next(e); };\n        FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber, options);\n    };\n    return FromEventObservable;\n}(Observable_1.Observable));\nexports.FromEventObservable = FromEventObservable;\n//# sourceMappingURL=FromEventObservable.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/FromEventObservable.js\n// module id = 167\n// module chunks = 0","import { createTimedBooleanSwitch } from \"../utils\";\nimport { IncomingSocketNames, OutgoingSocketEvent } from \"../socket-messages\";\nimport { getElementData } from \"../browser.utils\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as ClickEvent from \"../messages/ClickEvent\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { skip } from \"rxjs/operators/skip\";\nimport { distinctUntilChanged } from \"rxjs/operators/distinctUntilChanged\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { fromEvent } from \"rxjs/observable/fromEvent\";\nimport { empty } from \"rxjs/observable/empty\";\n\nexport function getClickStream(\n    document: Document,\n    socket$: Inputs[\"socket$\"],\n    option$: Inputs[\"option$\"]\n): Observable<OutgoingSocketEvent> {\n    const canSync$ = createTimedBooleanSwitch(\n        socket$.pipe(filter(([name]) => name === IncomingSocketNames.Click))\n    );\n\n    return option$.pipe(\n        skip(1), // initial option set before the connection event\n        pluck(\"ghostMode\", \"clicks\"),\n        distinctUntilChanged(),\n        switchMap(canClick => {\n            if (!canClick) {\n                return empty();\n            }\n            return fromEvent(document, \"click\", true).pipe(\n                map((e: Event) => e.target),\n                filter((target: any) => {\n                    if (target.tagName === \"LABEL\") {\n                        const id = target.getAttribute(\"for\");\n                        if (id && document.getElementById(id)) {\n                            return false;\n                        }\n                    }\n                    return true;\n                }),\n                withLatestFrom(canSync$),\n                filter(([, canSync]) => canSync),\n                map(([target]): OutgoingSocketEvent => {\n                    return ClickEvent.outgoing(getElementData(target));\n                })\n            );\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/listeners/clicks.listener.ts","import { createTimedBooleanSwitch } from \"../utils\";\nimport { IncomingSocketNames, OutgoingSocketEvent } from \"../socket-messages\";\nimport {\n    getScrollPosition,\n    getScrollPositionForElement\n} from \"../browser.utils\";\nimport { Observable } from \"rxjs/Observable\";\nimport * as ScrollEvent from \"../messages/ScrollEvent\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { map } from \"rxjs/operators/map\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { Inputs } from \"../index\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { distinctUntilChanged } from \"rxjs/operators/distinctUntilChanged\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { empty } from \"rxjs/observable/empty\";\nimport { skip } from \"rxjs/operators/skip\";\nimport { fromEvent } from \"rxjs/observable/fromEvent\";\n\nexport function getScrollStream(\n    window: Window,\n    document: Document,\n    socket$: Inputs[\"socket$\"],\n    option$: Inputs[\"option$\"]\n): Observable<OutgoingSocketEvent> {\n    const canSync$ = createTimedBooleanSwitch(\n        socket$.pipe(filter(([name]) => name === IncomingSocketNames.Scroll))\n    );\n\n    /**\n     * If the option 'scrollElementMapping' is provided\n     * we cache thw\n     * @type {Observable<(Element | null)[]>}\n     */\n    const elemMap$ = option$.pipe(\n        pluck(\"scrollElementMapping\"),\n        map((selectors: string[]) =>\n            selectors.map(selector => document.querySelector(selector))\n        )\n    );\n\n    return option$.pipe(\n        skip(1), // initial option set before the connection event\n        pluck(\"ghostMode\", \"scroll\"),\n        distinctUntilChanged(),\n        switchMap(scroll => {\n            if (!scroll) return empty();\n            return fromEvent(document, \"scroll\", true).pipe(\n                map((e: Event) => e.target),\n                withLatestFrom(canSync$, elemMap$),\n                filter(([, canSync]) => Boolean(canSync)),\n                map(([target, canSync, elemMap]: [any, boolean, any[]]) => {\n                    if (target === document) {\n                        return ScrollEvent.outgoing(\n                            getScrollPosition(window, document),\n                            \"document\",\n                            0\n                        );\n                    }\n\n                    const elems = document.getElementsByTagName(target.tagName);\n                    const index = Array.prototype.indexOf.call(\n                        elems || [],\n                        target\n                    );\n\n                    return ScrollEvent.outgoing(\n                        getScrollPositionForElement(target),\n                        target.tagName,\n                        index,\n                        elemMap.indexOf(target)\n                    );\n                })\n            );\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/listeners/scroll.listener.ts","import { IncomingSocketNames, OutgoingSocketEvent } from \"../socket-messages\";\nimport { getElementData } from \"../browser.utils\";\nimport { Observable } from \"rxjs/Observable\";\nimport { createTimedBooleanSwitch } from \"../utils\";\nimport * as FormToggleEvent from \"../messages/FormToggleEvent\";\nimport { filter } from \"rxjs/operators/filter\";\nimport { skip } from \"rxjs/operators/skip\";\nimport { pluck } from \"rxjs/operators/pluck\";\nimport { distinctUntilChanged } from \"rxjs/operators/distinctUntilChanged\";\nimport { withLatestFrom } from \"rxjs/operators/withLatestFrom\";\nimport { map } from \"rxjs/operators/map\";\nimport { switchMap } from \"rxjs/operators/switchMap\";\nimport { Inputs } from \"../index\";\nimport { empty } from \"rxjs/observable/empty\";\nimport { fromEvent } from \"rxjs/observable/fromEvent\";\n\nexport function getFormTogglesStream(\n    document: Document,\n    socket$: Inputs[\"socket$\"],\n    option$: Inputs[\"option$\"]\n): Observable<OutgoingSocketEvent> {\n    const canSync$ = createTimedBooleanSwitch(\n        socket$.pipe(\n            filter(([name]) => name === IncomingSocketNames.InputToggle)\n        )\n    );\n\n    return option$.pipe(\n        skip(1),\n        pluck(\"ghostMode\", \"forms\", \"toggles\"),\n        distinctUntilChanged(),\n        switchMap(canToggle => {\n            if (!canToggle) {\n                return empty();\n            }\n            return fromEvent(document, \"change\", true).pipe(\n                map((e: Event) => e.target || e.srcElement),\n                filter((elem: HTMLInputElement) => elem.tagName === \"SELECT\"),\n                withLatestFrom(canSync$),\n                filter(([, canSync]) => canSync),\n                map(([elem, canSync]: [HTMLInputElement, boolean]) => {\n                    const data = getElementData(elem);\n\n                    return FormToggleEvent.outgoing(data, {\n                        type: elem.type,\n                        checked: elem.checked,\n                        value: elem.value\n                    });\n                })\n            );\n        })\n    );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/listeners/form-toggles.listener.ts","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar Subscription_1 = require('../Subscription');\nvar Observable_1 = require('../Observable');\nvar Subject_1 = require('../Subject');\nvar Map_1 = require('../util/Map');\nvar FastMap_1 = require('../util/FastMap');\n/* tslint:enable:max-line-length */\n/**\n * Groups the items emitted by an Observable according to a specified criterion,\n * and emits these grouped items as `GroupedObservables`, one\n * {@link GroupedObservable} per group.\n *\n * <img src=\"./img/groupBy.png\" width=\"100%\">\n *\n * @example <caption>Group objects by id and return as array</caption>\n * Observable.of<Obj>({id: 1, name: 'aze1'},\n *                    {id: 2, name: 'sf2'},\n *                    {id: 2, name: 'dg2'},\n *                    {id: 1, name: 'erg1'},\n *                    {id: 1, name: 'df1'},\n *                    {id: 2, name: 'sfqfb2'},\n *                    {id: 3, name: 'qfs3'},\n *                    {id: 2, name: 'qsgqsfg2'}\n *     )\n *     .groupBy(p => p.id)\n *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], []))\n *     .subscribe(p => console.log(p));\n *\n * // displays:\n * // [ { id: 1, name: 'aze1' },\n * //   { id: 1, name: 'erg1' },\n * //   { id: 1, name: 'df1' } ]\n * //\n * // [ { id: 2, name: 'sf2' },\n * //   { id: 2, name: 'dg2' },\n * //   { id: 2, name: 'sfqfb2' },\n * //   { id: 2, name: 'qsgqsfg2' } ]\n * //\n * // [ { id: 3, name: 'qfs3' } ]\n *\n * @example <caption>Pivot data on the id field</caption>\n * Observable.of<Obj>({id: 1, name: 'aze1'},\n *                    {id: 2, name: 'sf2'},\n *                    {id: 2, name: 'dg2'},\n *                    {id: 1, name: 'erg1'},\n *                    {id: 1, name: 'df1'},\n *                    {id: 2, name: 'sfqfb2'},\n *                    {id: 3, name: 'qfs1'},\n *                    {id: 2, name: 'qsgqsfg2'}\n *                   )\n *     .groupBy(p => p.id, p => p.name)\n *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], [\"\" + group$.key]))\n *     .map(arr => ({'id': parseInt(arr[0]), 'values': arr.slice(1)}))\n *     .subscribe(p => console.log(p));\n *\n * // displays:\n * // { id: 1, values: [ 'aze1', 'erg1', 'df1' ] }\n * // { id: 2, values: [ 'sf2', 'dg2', 'sfqfb2', 'qsgqsfg2' ] }\n * // { id: 3, values: [ 'qfs1' ] }\n *\n * @param {function(value: T): K} keySelector A function that extracts the key\n * for each item.\n * @param {function(value: T): R} [elementSelector] A function that extracts the\n * return element for each item.\n * @param {function(grouped: GroupedObservable<K,R>): Observable<any>} [durationSelector]\n * A function that returns an Observable to determine how long each group should\n * exist.\n * @return {Observable<GroupedObservable<K,R>>} An Observable that emits\n * GroupedObservables, each of which corresponds to a unique key value and each\n * of which emits those items from the source Observable that share that key\n * value.\n * @method groupBy\n * @owner Observable\n */\nfunction groupBy(keySelector, elementSelector, durationSelector, subjectSelector) {\n    return function (source) {\n        return source.lift(new GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector));\n    };\n}\nexports.groupBy = groupBy;\nvar GroupByOperator = (function () {\n    function GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector) {\n        this.keySelector = keySelector;\n        this.elementSelector = elementSelector;\n        this.durationSelector = durationSelector;\n        this.subjectSelector = subjectSelector;\n    }\n    GroupByOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector, this.subjectSelector));\n    };\n    return GroupByOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar GroupBySubscriber = (function (_super) {\n    __extends(GroupBySubscriber, _super);\n    function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector, subjectSelector) {\n        _super.call(this, destination);\n        this.keySelector = keySelector;\n        this.elementSelector = elementSelector;\n        this.durationSelector = durationSelector;\n        this.subjectSelector = subjectSelector;\n        this.groups = null;\n        this.attemptedToUnsubscribe = false;\n        this.count = 0;\n    }\n    GroupBySubscriber.prototype._next = function (value) {\n        var key;\n        try {\n            key = this.keySelector(value);\n        }\n        catch (err) {\n            this.error(err);\n            return;\n        }\n        this._group(value, key);\n    };\n    GroupBySubscriber.prototype._group = function (value, key) {\n        var groups = this.groups;\n        if (!groups) {\n            groups = this.groups = typeof key === 'string' ? new FastMap_1.FastMap() : new Map_1.Map();\n        }\n        var group = groups.get(key);\n        var element;\n        if (this.elementSelector) {\n            try {\n                element = this.elementSelector(value);\n            }\n            catch (err) {\n                this.error(err);\n            }\n        }\n        else {\n            element = value;\n        }\n        if (!group) {\n            group = this.subjectSelector ? this.subjectSelector() : new Subject_1.Subject();\n            groups.set(key, group);\n            var groupedObservable = new GroupedObservable(key, group, this);\n            this.destination.next(groupedObservable);\n            if (this.durationSelector) {\n                var duration = void 0;\n                try {\n                    duration = this.durationSelector(new GroupedObservable(key, group));\n                }\n                catch (err) {\n                    this.error(err);\n                    return;\n                }\n                this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this)));\n            }\n        }\n        if (!group.closed) {\n            group.next(element);\n        }\n    };\n    GroupBySubscriber.prototype._error = function (err) {\n        var groups = this.groups;\n        if (groups) {\n            groups.forEach(function (group, key) {\n                group.error(err);\n            });\n            groups.clear();\n        }\n        this.destination.error(err);\n    };\n    GroupBySubscriber.prototype._complete = function () {\n        var groups = this.groups;\n        if (groups) {\n            groups.forEach(function (group, key) {\n                group.complete();\n            });\n            groups.clear();\n        }\n        this.destination.complete();\n    };\n    GroupBySubscriber.prototype.removeGroup = function (key) {\n        this.groups.delete(key);\n    };\n    GroupBySubscriber.prototype.unsubscribe = function () {\n        if (!this.closed) {\n            this.attemptedToUnsubscribe = true;\n            if (this.count === 0) {\n                _super.prototype.unsubscribe.call(this);\n            }\n        }\n    };\n    return GroupBySubscriber;\n}(Subscriber_1.Subscriber));\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar GroupDurationSubscriber = (function (_super) {\n    __extends(GroupDurationSubscriber, _super);\n    function GroupDurationSubscriber(key, group, parent) {\n        _super.call(this, group);\n        this.key = key;\n        this.group = group;\n        this.parent = parent;\n    }\n    GroupDurationSubscriber.prototype._next = function (value) {\n        this.complete();\n    };\n    GroupDurationSubscriber.prototype._unsubscribe = function () {\n        var _a = this, parent = _a.parent, key = _a.key;\n        this.key = this.parent = null;\n        if (parent) {\n            parent.removeGroup(key);\n        }\n    };\n    return GroupDurationSubscriber;\n}(Subscriber_1.Subscriber));\n/**\n * An Observable representing values belonging to the same group represented by\n * a common key. The values emitted by a GroupedObservable come from the source\n * Observable. The common key is available as the field `key` on a\n * GroupedObservable instance.\n *\n * @class GroupedObservable<K, T>\n */\nvar GroupedObservable = (function (_super) {\n    __extends(GroupedObservable, _super);\n    function GroupedObservable(key, groupSubject, refCountSubscription) {\n        _super.call(this);\n        this.key = key;\n        this.groupSubject = groupSubject;\n        this.refCountSubscription = refCountSubscription;\n    }\n    GroupedObservable.prototype._subscribe = function (subscriber) {\n        var subscription = new Subscription_1.Subscription();\n        var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject;\n        if (refCountSubscription && !refCountSubscription.closed) {\n            subscription.add(new InnerRefCountSubscription(refCountSubscription));\n        }\n        subscription.add(groupSubject.subscribe(subscriber));\n        return subscription;\n    };\n    return GroupedObservable;\n}(Observable_1.Observable));\nexports.GroupedObservable = GroupedObservable;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerRefCountSubscription = (function (_super) {\n    __extends(InnerRefCountSubscription, _super);\n    function InnerRefCountSubscription(parent) {\n        _super.call(this);\n        this.parent = parent;\n        parent.count++;\n    }\n    InnerRefCountSubscription.prototype.unsubscribe = function () {\n        var parent = this.parent;\n        if (!parent.closed && !this.closed) {\n            _super.prototype.unsubscribe.call(this);\n            parent.count -= 1;\n            if (parent.count === 0 && parent.attemptedToUnsubscribe) {\n                parent.unsubscribe();\n            }\n        }\n    };\n    return InnerRefCountSubscription;\n}(Subscription_1.Subscription));\n//# sourceMappingURL=groupBy.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operators/groupBy.js\n// module id = 171\n// module chunks = 0","\"use strict\";\nvar root_1 = require('./root');\nvar MapPolyfill_1 = require('./MapPolyfill');\nexports.Map = root_1.root.Map || (function () { return MapPolyfill_1.MapPolyfill; })();\n//# sourceMappingURL=Map.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/Map.js\n// module id = 172\n// module chunks = 0","\"use strict\";\nvar MapPolyfill = (function () {\n    function MapPolyfill() {\n        this.size = 0;\n        this._values = [];\n        this._keys = [];\n    }\n    MapPolyfill.prototype.get = function (key) {\n        var i = this._keys.indexOf(key);\n        return i === -1 ? undefined : this._values[i];\n    };\n    MapPolyfill.prototype.set = function (key, value) {\n        var i = this._keys.indexOf(key);\n        if (i === -1) {\n            this._keys.push(key);\n            this._values.push(value);\n            this.size++;\n        }\n        else {\n            this._values[i] = value;\n        }\n        return this;\n    };\n    MapPolyfill.prototype.delete = function (key) {\n        var i = this._keys.indexOf(key);\n        if (i === -1) {\n            return false;\n        }\n        this._values.splice(i, 1);\n        this._keys.splice(i, 1);\n        this.size--;\n        return true;\n    };\n    MapPolyfill.prototype.clear = function () {\n        this._keys.length = 0;\n        this._values.length = 0;\n        this.size = 0;\n    };\n    MapPolyfill.prototype.forEach = function (cb, thisArg) {\n        for (var i = 0; i < this.size; i++) {\n            cb.call(thisArg, this._values[i], this._keys[i]);\n        }\n    };\n    return MapPolyfill;\n}());\nexports.MapPolyfill = MapPolyfill;\n//# sourceMappingURL=MapPolyfill.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/MapPolyfill.js\n// module id = 173\n// module chunks = 0","\"use strict\";\nvar FastMap = (function () {\n    function FastMap() {\n        this.values = {};\n    }\n    FastMap.prototype.delete = function (key) {\n        this.values[key] = null;\n        return true;\n    };\n    FastMap.prototype.set = function (key, value) {\n        this.values[key] = value;\n        return this;\n    };\n    FastMap.prototype.get = function (key) {\n        return this.values[key];\n    };\n    FastMap.prototype.forEach = function (cb, thisArg) {\n        var values = this.values;\n        for (var key in values) {\n            if (values.hasOwnProperty(key) && values[key] !== null) {\n                cb.call(thisArg, values[key], key);\n            }\n        }\n    };\n    FastMap.prototype.clear = function () {\n        this.values = {};\n    };\n    return FastMap;\n}());\nexports.FastMap = FastMap;\n//# sourceMappingURL=FastMap.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/FastMap.js\n// module id = 174\n// module chunks = 0"],"sourceRoot":""}