Code
/
lmmi_journal_theme
7
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
14 Branches
0 Tags
37 MiB
 
 
 
 
Tree: 1440706ce3
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1440706ce3'
${ noResults }
lmmi_journal_theme/node_modules/browser-sync/client/dist/index.min.js.map

1 lines
1.2 MiB
Raw Blame History Escape

{"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":""}