{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///delegated ./node_modules/rxjs/node_modules/tslib/tslib.es6.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/innerSubscribe.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/Subscriber.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///external \"vendor_51d43e143a4cc0626b2a\"","webpack:///delegated ./node_modules/react/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/scheduler/async.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/Subject.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/map.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./node_modules/rxjs/src/internal/util/root.ts","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/subscribeToResult.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/filter.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/OuterSubscriber.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/ArgumentOutOfRangeError.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/noop.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/mergeMap.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/Subscription.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/from.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/EmptyError.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/isScheduler.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/isArray.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/concat.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/Notification.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./node_modules/rxjs/src/internal/operators/audit.ts","webpack:///./node_modules/rxjs/src/internal/operators/auditTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/buffer.ts","webpack:///./node_modules/rxjs/src/internal/operators/bufferCount.ts","webpack:///./node_modules/rxjs/src/internal/operators/bufferTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/bufferToggle.ts","webpack:///./node_modules/rxjs/src/internal/operators/bufferWhen.ts","webpack:///./node_modules/rxjs/src/internal/operators/catchError.ts","webpack:///./node_modules/rxjs/src/internal/operators/combineAll.ts","webpack:///./node_modules/rxjs/src/internal/operators/combineLatest.ts","webpack:///./node_modules/rxjs/src/internal/operators/concat.ts","webpack:///./node_modules/rxjs/src/internal/operators/concatMap.ts","webpack:///./node_modules/rxjs/src/internal/operators/concatMapTo.ts","webpack:///./node_modules/rxjs/src/internal/operators/count.ts","webpack:///./node_modules/rxjs/src/internal/operators/debounce.ts","webpack:///./node_modules/rxjs/src/internal/operators/debounceTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/defaultIfEmpty.ts","webpack:///./node_modules/rxjs/src/internal/util/isDate.ts","webpack:///./node_modules/rxjs/src/internal/operators/delay.ts","webpack:///./node_modules/rxjs/src/internal/operators/delayWhen.ts","webpack:///./node_modules/rxjs/src/internal/operators/dematerialize.ts","webpack:///./node_modules/rxjs/src/internal/operators/distinct.ts","webpack:///./node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts","webpack:///./node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts","webpack:///./node_modules/rxjs/src/internal/operators/throwIfEmpty.ts","webpack:///./node_modules/rxjs/src/internal/operators/take.ts","webpack:///./node_modules/rxjs/src/internal/operators/elementAt.ts","webpack:///./node_modules/rxjs/src/internal/operators/endWith.ts","webpack:///./node_modules/rxjs/src/internal/operators/every.ts","webpack:///./node_modules/rxjs/src/internal/operators/exhaust.ts","webpack:///./node_modules/rxjs/src/internal/operators/exhaustMap.ts","webpack:///./node_modules/rxjs/src/internal/operators/expand.ts","webpack:///./node_modules/rxjs/src/internal/operators/finalize.ts","webpack:///./node_modules/rxjs/src/internal/operators/find.ts","webpack:///./node_modules/rxjs/src/internal/operators/findIndex.ts","webpack:///./node_modules/rxjs/src/internal/operators/first.ts","webpack:///./node_modules/rxjs/src/internal/operators/ignoreElements.ts","webpack:///./node_modules/rxjs/src/internal/operators/isEmpty.ts","webpack:///./node_modules/rxjs/src/internal/operators/takeLast.ts","webpack:///./node_modules/rxjs/src/internal/operators/last.ts","webpack:///./node_modules/rxjs/src/internal/operators/mapTo.ts","webpack:///./node_modules/rxjs/src/internal/operators/materialize.ts","webpack:///./node_modules/rxjs/src/internal/operators/scan.ts","webpack:///./node_modules/rxjs/src/internal/operators/reduce.ts","webpack:///./node_modules/rxjs/src/internal/operators/max.ts","webpack:///./node_modules/rxjs/src/internal/operators/merge.ts","webpack:///./node_modules/rxjs/src/internal/operators/mergeMapTo.ts","webpack:///./node_modules/rxjs/src/internal/operators/mergeScan.ts","webpack:///./node_modules/rxjs/src/internal/operators/min.ts","webpack:///./node_modules/rxjs/src/internal/operators/multicast.ts","webpack:///./node_modules/rxjs/src/internal/operators/onErrorResumeNext.ts","webpack:///./node_modules/rxjs/src/internal/operators/pairwise.ts","webpack:///./node_modules/rxjs/src/internal/operators/partition.ts","webpack:///./node_modules/rxjs/src/internal/operators/pluck.ts","webpack:///./node_modules/rxjs/src/internal/operators/publish.ts","webpack:///./node_modules/rxjs/src/internal/operators/publishBehavior.ts","webpack:///./node_modules/rxjs/src/internal/operators/publishLast.ts","webpack:///./node_modules/rxjs/src/internal/operators/publishReplay.ts","webpack:///./node_modules/rxjs/src/internal/operators/race.ts","webpack:///./node_modules/rxjs/src/internal/operators/repeat.ts","webpack:///./node_modules/rxjs/src/internal/operators/repeatWhen.ts","webpack:///./node_modules/rxjs/src/internal/operators/retry.ts","webpack:///./node_modules/rxjs/src/internal/operators/retryWhen.ts","webpack:///./node_modules/rxjs/src/internal/operators/sample.ts","webpack:///./node_modules/rxjs/src/internal/operators/sampleTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/sequenceEqual.ts","webpack:///./node_modules/rxjs/src/internal/operators/share.ts","webpack:///./node_modules/rxjs/src/internal/operators/shareReplay.ts","webpack:///./node_modules/rxjs/src/internal/operators/single.ts","webpack:///./node_modules/rxjs/src/internal/operators/skip.ts","webpack:///./node_modules/rxjs/src/internal/operators/skipLast.ts","webpack:///./node_modules/rxjs/src/internal/operators/skipUntil.ts","webpack:///./node_modules/rxjs/src/internal/operators/skipWhile.ts","webpack:///./node_modules/rxjs/src/internal/operators/startWith.ts","webpack:///./node_modules/rxjs/src/internal/operators/switchMap.ts","webpack:///./node_modules/rxjs/src/internal/operators/switchAll.ts","webpack:///./node_modules/rxjs/src/internal/operators/switchMapTo.ts","webpack:///./node_modules/rxjs/src/internal/operators/takeUntil.ts","webpack:///./node_modules/rxjs/src/internal/operators/takeWhile.ts","webpack:///./node_modules/rxjs/src/internal/operators/tap.ts","webpack:///./node_modules/rxjs/src/internal/operators/throttle.ts","webpack:///./node_modules/rxjs/src/internal/operators/throttleTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/timeInterval.ts","webpack:///./node_modules/rxjs/src/internal/operators/timeoutWith.ts","webpack:///./node_modules/rxjs/src/internal/operators/timeout.ts","webpack:///./node_modules/rxjs/src/internal/operators/timestamp.ts","webpack:///./node_modules/rxjs/src/internal/operators/toArray.ts","webpack:///./node_modules/rxjs/src/internal/operators/window.ts","webpack:///./node_modules/rxjs/src/internal/operators/windowCount.ts","webpack:///./node_modules/rxjs/src/internal/operators/windowTime.ts","webpack:///./node_modules/rxjs/src/internal/operators/windowToggle.ts","webpack:///./node_modules/rxjs/src/internal/operators/windowWhen.ts","webpack:///./node_modules/rxjs/src/internal/operators/withLatestFrom.ts","webpack:///./node_modules/rxjs/src/internal/operators/zip.ts","webpack:///./node_modules/rxjs/src/internal/operators/zipAll.ts","webpack:///./node_modules/rxjs/src/operators/index.ts","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/empty.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/identity.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/connected-react-router/esm/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/redux-observable/lib/esm/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/serverOptions.ts","webpack:///./ConstructionAi.WebApp/Client/utils/oauth.ts","webpack:///./ConstructionAi.WebApp/Client/components/PleaseWait.tsx","webpack:///delegated ./node_modules/react-redux/es/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/utils/fetch.ts","webpack:///./ConstructionAi.WebApp/Client/utils/window.ts","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/refCount.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/Observable.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/combineLatest.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/ReplaySubject.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/zip.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/store/plans.ts","webpack:///delegated ./node_modules/react-helmet/lib/Helmet.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/utils/state.ts","webpack:///./ConstructionAi.WebApp/Client/components/Layout.tsx","webpack:///./node_modules/qs/lib/formats.js","webpack:///./ConstructionAi.WebApp/Client/store/user.ts","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/pipe.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/isNumeric.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/webpack/buildin/global.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/redux/es/redux.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/concatAll.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/groupBy.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/mergeAll.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/observeOn.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/operators/subscribeOn.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/routes.tsx","webpack:///delegated ./node_modules/react-router-dom/esm/react-router-dom.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/store/upload.ts","webpack:///./node_modules/qs/lib/index.js","webpack:///./node_modules/qs/lib/utils.js","webpack:///./ConstructionAi.WebApp/Client/version.ts","webpack:///./ConstructionAi.WebApp/Client/components/NotFound.tsx","webpack:///delegated ./node_modules/@stripe/react-stripe-js/dist/react-stripe.umd.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/timer.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/of.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/merge.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/ConnectableObservable.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/not.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/BehaviorSubject.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/AsyncSubject.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/race.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/isFunction.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/defer.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/util/TimeoutError.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/rxjs/_esm5/internal/observable/throwError.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/boot-client.tsx","webpack:///delegated ./node_modules/history/esm/history.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/react-dom/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./node_modules/react-hot-loader/index.js","webpack:///./node_modules/react-hot-loader/dist/react-hot-loader.production.min.js","webpack:///./ConstructionAi.WebApp/Client/configureStore.ts","webpack:///./ConstructionAi.WebApp/Client/store/index.ts","webpack:///./ConstructionAi.WebApp/Client/components/Home.tsx","webpack:///delegated ./node_modules/abort-controller/browser.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///delegated ./node_modules/domain-task/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/utils/messageQueue.ts","webpack:///delegated ./node_modules/@aws-sdk/client-sqs/dist-es/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/components/LoginButton.tsx","webpack:///./node_modules/qs/lib/stringify.js","webpack:///./node_modules/qs/lib/parse.js","webpack:///./ConstructionAi.WebApp/Client/utils/userState.ts","webpack:///./ConstructionAi.WebApp/Client/components/GoogleButton.tsx","webpack:///./ConstructionAi.WebApp/Client/components/GoogleLogo.tsx","webpack:///./ConstructionAi.WebApp/Client/components/ThreeDots.tsx","webpack:///./ConstructionAi.WebApp/Client/components/OAuth2Redirect.tsx","webpack:///./ConstructionAi.WebApp/Client/components/ViewPlan.tsx","webpack:///./ConstructionAi.WebApp/Client/components/CheckoutFormContainer.tsx","webpack:///./ConstructionAi.WebApp/Client/components/CheckoutForm.tsx","webpack:///delegated ./node_modules/classnames/index.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/components/Button.tsx","webpack:///./ConstructionAi.WebApp/Client/components/Checkbox.tsx","webpack:///./ConstructionAi.WebApp/Client/components/Textbox.tsx","webpack:///./ConstructionAi.WebApp/Client/components/TrimbleProjectList.tsx","webpack:///./ConstructionAi.WebApp/Client/components/Picklist.tsx","webpack:///delegated ./node_modules/@stripe/stripe-js/dist/stripe.esm.js from dll-reference vendor_51d43e143a4cc0626b2a","webpack:///./ConstructionAi.WebApp/Client/components/LayeredDetailList.tsx","webpack:///./ConstructionAi.WebApp/Client/components/PlanDetailList.tsx","webpack:///./node_modules/rxjs/src/internal/observable/dom/AjaxObservable.ts","webpack:///./node_modules/rxjs/src/ajax/index.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","vendor_51d43e143a4cc0626b2a","global","__webpack_exports__","_root","__window","window","__self","self","WorkerGlobalScope","audit","durationSelector","source","lift","AuditOperator","this","subscriber","subscribe","audit_AuditSubscriber","_super","AuditSubscriber","destination","_this","tslib_es6from_dll_reference_vendor_51d43e143a4cc0626b2a","_next","hasValue","throttled","duration","err","error","innerSubscription","innerSubscribefrom_dll_reference_vendor_51d43e143a4cc0626b2a","closed","clearThrottle","add","remove","undefined","unsubscribe","next","notifyNext","notifyComplete","auditTime","scheduler","asyncfrom_dll_reference_vendor_51d43e143a4cc0626b2a","buffer_buffer","closingNotifier","BufferOperator","buffer_BufferSubscriber","BufferSubscriber","buffer","push","bufferCount","bufferSize","startBufferEvery","BufferCountOperator","subscriberClass","bufferCount_BufferSkipCountSubscriber","bufferCount_BufferCountSubscriber","BufferCountSubscriber","length","_complete","BufferSkipCountSubscriber","buffers","count","splice","shift","bufferTime","bufferTimeSpan","arguments","isSchedulerfrom_dll_reference_vendor_51d43e143a4cc0626b2a","bufferCreationInterval","maxBufferSize","Number","POSITIVE_INFINITY","BufferTimeOperator","bufferTime_BufferTimeSubscriber","Context","BufferTimeSubscriber","contexts","context","openContext","timespanOnly","timeSpanOnlyState","closeAction","schedule","dispatchBufferTimeSpanOnly","closeState","creationState","dispatchBufferClose","dispatchBufferCreation","filledBufferContext","len","context_1","onBufferFull","_error","context_2","_unsubscribe","closeContext","indexOf","Subscriberfrom_dll_reference_vendor_51d43e143a4cc0626b2a","state","prevContext","arg","bufferToggle","openings","closingSelector","BufferToggleOperator","bufferToggle_BufferToggleSubscriber","BufferToggleSubscriber","subscription","outerValue","innerValue","closeBuffer","openBuffer","innerSub","trySubscribe","Subscriptionfrom_dll_reference_vendor_51d43e143a4cc0626b2a","subscribeToResultfrom_dll_reference_vendor_51d43e143a4cc0626b2a","bufferWhen","BufferWhenOperator","bufferWhen_BufferWhenSubscriber","BufferWhenSubscriber","subscribing","complete","closingSubscription","catchError","selector","operator","CatchOperator","caught","catchError_CatchSubscriber","CatchSubscriber","isStopped","result","err2","_unsubscribeAndRecycle","innerSubscriber","combineAll","project","combineLatestfrom_dll_reference_vendor_51d43e143a4cc0626b2a","combineLatest","_i","observables","pop","isArrayfrom_dll_reference_vendor_51d43e143a4cc0626b2a","slice","fromfrom_dll_reference_vendor_51d43e143a4cc0626b2a","concat","concatfrom_dll_reference_vendor_51d43e143a4cc0626b2a","apply","concatMap","resultSelector","mergeMapfrom_dll_reference_vendor_51d43e143a4cc0626b2a","concatMapTo","innerObservable","count_count","predicate","CountOperator","count_CountSubscriber","CountSubscriber","_tryPredicate","index","debounce","DebounceOperator","debounce_DebounceSubscriber","DebounceSubscriber","_tryNext","emitValue","durationSubscription","debounceTime","dueTime","DebounceTimeOperator","debounceTime_DebounceTimeSubscriber","DebounceTimeSubscriber","lastValue","clearDebounce","debouncedSubscription","dispatchNext","debouncedNext","defaultIfEmpty","defaultValue","DefaultIfEmptyOperator","defaultIfEmpty_DefaultIfEmptySubscriber","DefaultIfEmptySubscriber","isEmpty","isDate","Date","isNaN","delay_delay","delay","delayFor","now","Math","abs","DelayOperator","delay_DelaySubscriber","DelaySubscriber","active","errored","dispatch","queue","time","notification","observe","delay_1","max","_schedule","scheduleNotification","message","DelayMessage","Notificationfrom_dll_reference_vendor_51d43e143a4cc0626b2a","createNext","createComplete","delayWhen","delayDurationSelector","subscriptionDelay","delayWhen_SubscriptionDelayObservable","DelayWhenOperator","delayWhen_DelayWhenSubscriber","DelayWhenSubscriber","completed","delayNotifierSubscriptions","_innerValue","_outerIndex","_innerIndex","removeSubscription","tryComplete","notifyError","delayNotifier","tryDelay","subscriptionIdx","notifierSubscription","OuterSubscriberfrom_dll_reference_vendor_51d43e143a4cc0626b2a","SubscriptionDelayObservable","_subscribe","delayWhen_SubscriptionDelaySubscriber","Observablefrom_dll_reference_vendor_51d43e143a4cc0626b2a","SubscriptionDelaySubscriber","parent","unused","subscribeToSource","sourceSubscribed","dematerialize","DeMaterializeOperator","dematerialize_DeMaterializeSubscriber","DeMaterializeSubscriber","distinct","keySelector","flushes","DistinctOperator","distinct_DistinctSubscriber","DistinctSubscriber","values","Set","clear","_useKeySelector","_finalizeNext","has","distinctUntilChanged","compare","DistinctUntilChangedOperator","distinctUntilChanged_DistinctUntilChangedSubscriber","DistinctUntilChangedSubscriber","hasKey","x","y","distinctUntilKeyChanged","throwIfEmpty","errorFactory","defaultErrorFactory","ThrowIfEmptyOperator","throwIfEmpty_ThrowIfEmptySubscriber","ThrowIfEmptySubscriber","e","take","emptyfrom_dll_reference_vendor_51d43e143a4cc0626b2a","take_TakeOperator","TakeOperator","total","ArgumentOutOfRangeErrorfrom_dll_reference_vendor_51d43e143a4cc0626b2a","take_TakeSubscriber","TakeSubscriber","elementAt","hasDefaultValue","pipe","filterfrom_dll_reference_vendor_51d43e143a4cc0626b2a","v","endWith","offrom_dll_reference_vendor_51d43e143a4cc0626b2a","array","every","thisArg","EveryOperator","observer","every_EverySubscriber","EverySubscriber","everyValueMatch","exhaust","SwitchFirstOperator","exhaust_SwitchFirstSubscriber","SwitchFirstSubscriber","hasCompleted","hasSubscription","exhaustMap","a","mapfrom_dll_reference_vendor_51d43e143a4cc0626b2a","b","ii","ExhaustMapOperator","exhaustMap_ExhaustMapSubscriber","ExhaustMapSubscriber","tryNext","_innerSub","expand","concurrent","ExpandOperator","expand_ExpandSubscriber","ExpandSubscriber","subscribeToProjection","finalize","callback","FinallyOperator","finalize_FinallySubscriber","FinallySubscriber","find","TypeError","FindValueOperator","yieldIndex","find_FindValueSubscriber","FindValueSubscriber","findIndex","first","identityfrom_dll_reference_vendor_51d43e143a4cc0626b2a","EmptyErrorfrom_dll_reference_vendor_51d43e143a4cc0626b2a","ignoreElements","IgnoreElementsOperator","ignoreElements_IgnoreElementsSubscriber","IgnoreElementsSubscriber","IsEmptyOperator","isEmpty_IsEmptySubscriber","IsEmptySubscriber","takeLast","takeLast_TakeLastOperator","TakeLastOperator","takeLast_TakeLastSubscriber","TakeLastSubscriber","ring","Array","idx","last","mapTo","MapToOperator","mapTo_MapToSubscriber","MapToSubscriber","materialize","MaterializeOperator","materialize_MaterializeSubscriber","MaterializeSubscriber","createError","scan","accumulator","seed","hasSeed","ScanOperator","scan_ScanSubscriber","ScanSubscriber","_seed","set","configurable","reduce","pipefrom_dll_reference_vendor_51d43e143a4cc0626b2a","acc","max_max","comparer","merge","mergefrom_dll_reference_vendor_51d43e143a4cc0626b2a","mergeMapTo","mergeScan","MergeScanOperator","mergeScan_MergeScanSubscriber","MergeScanSubscriber","ish","min_min","multicast","subjectOrSubjectFactory","subjectFactory","MulticastOperator","connectable","ConnectableObservablefrom_dll_reference_vendor_51d43e143a4cc0626b2a","subject","onErrorResumeNext","nextSources","OnErrorResumeNextOperator","onErrorResumeNext_OnErrorResumeNextSubscriber","OnErrorResumeNextSubscriber","subscribeToNextSource","pairwise","PairwiseOperator","pairwise_PairwiseSubscriber","PairwiseSubscriber","pair","hasPrev","prev","partition","notfrom_dll_reference_vendor_51d43e143a4cc0626b2a","pluck","properties","Error","props","currentProp","plucker","publish","Subjectfrom_dll_reference_vendor_51d43e143a4cc0626b2a","publishBehavior","BehaviorSubjectfrom_dll_reference_vendor_51d43e143a4cc0626b2a","publishLast","AsyncSubjectfrom_dll_reference_vendor_51d43e143a4cc0626b2a","publishReplay","windowTime","selectorOrScheduler","ReplaySubjectfrom_dll_reference_vendor_51d43e143a4cc0626b2a","race","racefrom_dll_reference_vendor_51d43e143a4cc0626b2a","repeat","RepeatOperator","repeat_RepeatSubscriber","RepeatSubscriber","repeatWhen","notifier","RepeatWhenOperator","repeatWhen_RepeatWhenSubscriber","RepeatWhenSubscriber","sourceIsBeingSubscribedTo","retries","subscribeToRetries","retriesSubscription","notifications","retry","RetryOperator","retry_RetrySubscriber","RetrySubscriber","retryWhen","RetryWhenOperator","retryWhen_RetryWhenSubscriber","RetryWhenSubscriber","errors","sample","sample_SampleOperator","SampleOperator","sampleSubscriber","sample_SampleSubscriber","SampleSubscriber","sampleTime","period","SampleTimeOperator","sampleTime_SampleTimeSubscriber","SampleTimeSubscriber","dispatchNotification","sequenceEqual","compareTo","comparator","SequenceEqualOperator","sequenceEqual_SequenceEqualSubscriber","SequenceEqualSubscriber","_a","_b","_oneComplete","emit","checkValues","areEqual","nextB","completeB","sequenceEqual_SequenceEqualCompareToSubscriber","SequenceEqualCompareToSubscriber","shareSubjectFactory","share","refCountfrom_dll_reference_vendor_51d43e143a4cc0626b2a","shareReplay","configOrBufferSize","config","refCount","_c","useRefCount","hasError","isComplete","single","SingleOperator","single_SingleSubscriber","SingleSubscriber","seenValue","applySingleValue","singleValue","skip","SkipOperator","skip_SkipSubscriber","SkipSubscriber","skipLast","skipLast_SkipLastOperator","SkipLastOperator","_skipCount","skipLast_SkipLastSubscriber","SkipLastSubscriber","_count","skipCount","_ring","currentIndex","oldValue","skipUntil","SkipUntilOperator","skipUntil_SkipUntilSubscriber","SkipUntilSubscriber","skipWhile","SkipWhileOperator","skipWhile_SkipWhileSubscriber","SkipWhileSubscriber","skipping","tryCallPredicate","Boolean","startWith","switchMap","SwitchMapOperator","switchMap_SwitchMapSubscriber","SwitchMapSubscriber","switchAll","switchMapTo","takeUntil","takeUntil_TakeUntilOperator","TakeUntilOperator","takeUntilSubscriber","takeUntil_TakeUntilSubscriber","TakeUntilSubscriber","takeWhile","inclusive","TakeWhileOperator","takeWhile_TakeWhileSubscriber","TakeWhileSubscriber","nextOrComplete","predicateResult","tap","nextOrObserver","DoOperator","tap_TapSubscriber","TapSubscriber","observerOrNext","_tapNext","noopfrom_dll_reference_vendor_51d43e143a4cc0626b2a","_tapError","_tapComplete","isFunctionfrom_dll_reference_vendor_51d43e143a4cc0626b2a","_context","defaultThrottleConfig","leading","trailing","throttle","ThrottleOperator","throttle_ThrottleSubscriber","ThrottleSubscriber","_leading","_trailing","_hasValue","_throttled","send","_sendValue","tryDurationSelector","throttlingDone","throttleTime","ThrottleTimeOperator","throttleTime_ThrottleTimeSubscriber","ThrottleTimeSubscriber","_hasTrailingValue","_trailingValue","throttleTime_dispatchNext","timeInterval","deferfrom_dll_reference_vendor_51d43e143a4cc0626b2a","current","TimeInterval","interval","timeoutWith","due","withObservable","absoluteTimeout","waitFor","TimeoutWithOperator","timeoutWith_TimeoutWithSubscriber","TimeoutWithSubscriber","scheduleTimeout","dispatchTimeout","action","timeout","timestamp","Timestamp","toArrayReducer","arr","item","toArray","window_window","windowBoundaries","window_WindowOperator","WindowOperator","windowSubscriber","window_WindowSubscriber","sourceSubscription","WindowSubscriber","openWindow","prevWindow","newWindow","windowCount","windowSize","startWindowEvery","WindowCountOperator","windowCount_WindowCountSubscriber","WindowCountSubscriber","windows","window_1","windowTime_windowTime","windowTimeSpan","windowCreationInterval","maxWindowSize","isNumericfrom_dll_reference_vendor_51d43e143a4cc0626b2a","WindowTimeOperator","windowTime_WindowTimeSubscriber","windowTime_CountedSubject","CountedSubject","_numberOfNextedValues","WindowTimeSubscriber","dispatchWindowClose","dispatchWindowCreation","dispatchWindowTimeSpanOnly","numberOfNextedValues","closeWindow","window_2","timeSpanState","windowToggle","WindowToggleOperator","windowToggle_WindowToggleSubscriber","WindowToggleSubscriber","context_3","outerIndex","innerIndex","context_4","inner","openSubscription","windowWhen","windowWhen_WindowOperator","windowWhen_WindowSubscriber","_outerValue","unsubscribeClosingNotification","closingNotification","withLatestFrom","args","WithLatestFromOperator","withLatestFrom_WithLatestFromSubscriber","WithLatestFromSubscriber","toRespond","observable","found","_tryProject","zip","zipfrom_dll_reference_vendor_51d43e143a4cc0626b2a","zipAll","concatAllfrom_dll_reference_vendor_51d43e143a4cc0626b2a","groupByfrom_dll_reference_vendor_51d43e143a4cc0626b2a","mergeAllfrom_dll_reference_vendor_51d43e143a4cc0626b2a","observeOnfrom_dll_reference_vendor_51d43e143a4cc0626b2a","subscribeOnfrom_dll_reference_vendor_51d43e143a4cc0626b2a","oauth_1","serverOptions","currencyCode","deploymentType","freeMode","oAuthConfigs","OAuth2Provider","TrimbleConnect","authorizeUri","clientId","provider","redirectUri","publishedDataHost","stripePublicApiKey","uri","setServerOptions","newServerOptions","getServerOptions","qs_1","Rx","operators_1","createAuthorizationUri","scope","Google","tenantDomain","prompt","queryParams","client_id","redirect_uri","response_type","join","access_type","serializedParams","stringify","loginWithOAuth2","options","Observable","cleanup","receivePopupMessage","event","obj","origin","location","data","success","authorizationCode","authorizationUri","popup","open","addEventListener","pollTimer","setInterval","errorMessage","removeEventListener","clearInterval","close","map","__assign","sendResultMessage","params","parse","search","ignoreQueryPrefix","error_description","code","opener","postMessage","React","ThreeDots_1","PleaseWait","createElement","className","children","ThreeDots","color","height","width","abort_controller_1","domain_task_1","rxjs_1","createFetchStream","url","init","controller","windowIfDefined","AbortController","fetchTask","fetch","signal","then","response","ok","json","planData","text","errorString","catch","addTask","abort","PlanActionType","PlanActions","connected_react_router_1","redux_observable_1","routes_1","fetch_1","state_1","initialState","plans","isLoading","isPaying","clearError","actionCreator","CLEAR_ERROR","empty","loadPlan","LOAD_PLAN","withPayload","payForPlan","PAY_FOR_PLAN","paymentError","PAYMENT_ERROR","receivePlan","RECEIVE_PLAN_DATA","setCurrentPlan","SET_CURRENT_PLAN","useCachedPlan","USE_CACHED_PLAN_DATA","viewPlanMatcher","createMatchSelector","viewPlanPath","planEpic","combineEpics","action$","ofType","payload","guid","flatMap","method","headers","Content-Type","body","stripeToken","stripeEmail","email","selectedFolderId","selectedProject","rootFolderId","of","LOCATION_CHANGE","viewPlanMatch","router","store","reducer","incomingAction","type","errorText","currentPlanGuid","withPayloadAndMeta","meta","LoginButton_1","version_1","Layout","href","src","alt","skipUser","__spreadArrays","ConnectedLoginButton","buildVersion","replace","String","percentTwenties","Format","default","formatters","RFC1738","RFC3986","UserActionType","UserActions","userState_1","serverOptions_1","profile","isLoggingIn","loginEnabled","enableLogins","ENABLE_LOGINS","loadUser","LOAD_USER_STATE","loginResult","LOGIN_RESULT","loginStart","LOGIN_START","logout","LOGOUT","logoutActual","LOGOUT_ACTUAL","loadUserStateEpic","savedState","loadUserState","clientToken","loginEpic","selectedLoginOptions","saveUserState","username","console","log","logoutEpic","userEpic","loginError","removeUserState","react_router_dom_1","Home_1","NotFound_1","OAuth2Redirect_1","ViewPlan_1","routes","Switch","Route","exact","path","component","ConnectedHome","OAuth2Redirect","ConnectedViewPlan","NotFound","UploadActionType","UploadActions","messageQueue_1","plans_1","isUploading","cancelUpload","CANCEL","uploadError","UPLOAD_ERROR","uploadFinished","UPLOAD_FINISHED","uploadPlan","UPLOAD_PLAN","uploadStatus","UPLOAD_STATUS","uploadEpic","FormData","append","file","filename","uploadResult","createQueueStream","messageQueue","filter","status","uploadMessage","formats","isArray","hexTable","toString","toUpperCase","arrayToObject","plainObjects","assign","target","keys","combine","compact","prop","refs","j","val","compacted","compactQueue","decode","str","decoder","charset","strWithoutPlus","unescape","decodeURIComponent","encode","defaultEncoder","kind","format","string","escape","$0","parseInt","out","charCodeAt","charAt","isBuffer","constructor","isRegExp","maybeMap","fn","mapped","allowPrototypes","mergeTarget","forEach","targetItem","react_helmet_1","Layout_1","history_1","ReactDOM","react_hot_loader_1","react_redux_1","ajax_1","configureStore_1","RoutesModule","user_1","baseUrl","document","getElementsByTagName","getAttribute","history","createBrowserHistory","basename","initialReduxState","configureStore","hydrate","AppContainer","Provider","ConnectedRouter","getElementById","ajax","responseType","reload","warnAboutHMRDisabled","Children","only","hot","shouldWrapWithAppContainer","areComponentsEqual","setConfig","cold","configureComponent","redux_1","StoreModule","composeEnhancers","__REDUX_DEVTOOLS_EXTENSION_COMPOSE__","compose","epicMiddleware","createEpicMiddleware","createStore","createRootReducer","rootInitialState","applyMiddleware","routerMiddleware","epic$","BehaviorSubject","rootEpic","run","store$","epic","Plans","Upload","User","upload","user","combineReducers","connectRouter","upload_1","PleaseWait_1","connect","buttonHandler","useCallback","filenameElement","click","hiddenFileHandler","files","onClick","renderUploadingProgress","renderError","encType","accept","id","onChange","autoComplete","renderUploadForm","client_sqs_1","queueUrl","receiveCommand","ReceiveMessageCommand","QueueUrl","MaxNumberOfMessages","WaitTimeSeconds","sqs","SQSClient","credentials","accessKeyId","secretAccessKey","region","command","makeReceiveRequest","Messages","from","ReceiptHandle","makeDeleteRequest","DeleteMessageCommand","Body","JSON","GoogleButton_1","loginStartGoogle","loginStartProcore","Procore","loginStartTrimble","loginOptions","Fragment","GoogleButton","size","utils","arrayPrefixGenerators","brackets","prefix","comma","indices","pushToArray","valueOrArray","toISO","toISOString","defaultFormat","defaults","addQueryPrefix","allowDots","charsetSentinel","delimiter","encoder","encodeValuesOnly","formatter","serializeDate","date","skipNulls","strictNullHandling","generateArrayPrefix","sort","objKeys","keyPrefix","opts","normalizeStringifyOptions","arrayFormat","joined","arrayLimit","depth","interpretNumericEntities","parameterLimit","parseArrays","numberStr","fromCharCode","parseArrayValue","split","parseKeys","givenKey","valuesParsed","child","segment","exec","chain","leaf","root","cleanRoot","0","parseObject","normalizeParseOptions","tempObj","cleanStr","limit","Infinity","parts","skipIndex","part","bracketEqualsPos","pos","encodedVal","parseValues","newObj","userStateKey","localStorage","removeItem","userStateJson","getItem","parsedData","setItem","GoogleLogo_1","pixelSize","spanStyle","marginLeft","marginRight","fontFamily","fontSize","lineHeight","marginBottom","style","padding","background","display","GoogleLogo","margin","viewBox","version","xmlns","transform","fill","fillRule","stroke","strokeWidth","cx","cy","attributeName","to","begin","dur","calcMode","repeatCount","useEffect","CheckoutFormContainer_1","LayeredDetailList_1","PlanDetailList_1","countSpots","confidentOnly","spotPages","sum","page","spotsConfident","spotsFound","NoResultsFooter","NavLink","ResultsFooter","available","stripeSubmitCallback","nothing","nameWithoutExtension","LayeredDetailList","renderNothing","renderNothingLoginRequired","tableData","tableCount","PlanDetailList","renderFreeMode","renderFreeModeLoginRequired","free","renderFree","paid","renderPaid","CheckoutFormContainer","costDisplay","isTrimbleEmail","onSubmit","renderUnpaid","react_stripe_js_1","CheckoutForm_1","useState","stripeInstance","setStripeInstance","loadStripe","stripe","Elements","CheckoutForm","classnames","Button_1","Checkbox_1","Textbox_1","TrimbleProjectList_1","useTrimble","setUseTrimble","typedEmail","setTypedEmail","setSelectedProject","_d","waitingForStripe","setWaitingForStripe","_e","internalErrorText","setInternalErrorText","clearErrorCallback","useStripe","stripeElements","useElements","submitCallback","cardElement","getElement","CardElement","createToken","token","createCallback","classes","button","Button","Textbox","label","Checkbox","checked","TrimbleProjectList","onSelection","checkboxHandler","htmlFor","textboxHandler","Picklist_1","projects","setProjects","loadedProjects","_err","Picklist","items","selectedItem","picklistHandler","outputAvailable","layeredPages","pageNumber","dxfOutputFile","pdfOutputFile","needToPay","showDetails","featureCount","featurePages","featureTypes","featuresByPage","featurePage","featuresIdentified","feature","toLocaleLowerCase","tablesFound","crossSectionData","crossSectionsFound","crossSectionCount","spotsByPage","_f","spotPage","spotsUncertain","spotsUnmatched","layers","layerCount","vectors","vectorCount","excelOutputFile","ajaxGet","AjaxObservable_AjaxObservable","ajaxPost","ajaxDelete","ajaxPut","ajaxPatch","ajaxGetJSON","mapResponse","AjaxObservable","urlOrRequest","async","createXHR","crossDomain","XMLHttpRequest","XDomainRequest","getCORSRequest","progId","progIds","ActiveXObject","getXMLHttpRequest","withCredentials","request","AjaxObservable_AjaxSubscriber","post","delete","put","patch","getJSON","AjaxSubscriber","done","getHeader","serializeBody","xhr","AjaxResponse","password","setupEvents","setHeaders","contentType","splitIndex","substring","encodeURIComponent","setRequestHeader","headerName","toLowerCase","progressSubscriber","xhrTimeout","AjaxTimeoutError","ontimeout","xhrProgress_1","xhrError_1","onprogress","AjaxError","onerror","xhrReadyStateChange","xhrLoad","readyState","status_1","responseText","onreadystatechange","onload","originalEvent","parseXhrResponse","AjaxErrorImpl","parseJson","responseXML"],"mappings":"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","file":"main-client.js","sourcesContent":[" \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, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\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\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 74);\n","module.exports = (__webpack_require__(3))(2);","module.exports = (__webpack_require__(3))(56);","module.exports = (__webpack_require__(3))(9);","module.exports = vendor_51d43e143a4cc0626b2a;","module.exports = (__webpack_require__(3))(6);","module.exports = (__webpack_require__(3))(53);","module.exports = (__webpack_require__(3))(17);","module.exports = (__webpack_require__(3))(26);","declare let global: any;\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\ndeclare var WorkerGlobalScope: any;\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.\n\nconst __window = typeof window !== 'undefined' && window;\nconst __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nconst __global = typeof global !== 'undefined' && global;\nconst _root: any = __window || __global || __self;\n\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\nexport { _root as root };","module.exports = (__webpack_require__(3))(148);","module.exports = (__webpack_require__(3))(152);","module.exports = (__webpack_require__(3))(149);","module.exports = (__webpack_require__(3))(276);","module.exports = (__webpack_require__(3))(132);","module.exports = (__webpack_require__(3))(176);","module.exports = (__webpack_require__(3))(10);","module.exports = (__webpack_require__(3))(25);","module.exports = (__webpack_require__(3))(277);","module.exports = (__webpack_require__(3))(21);","module.exports = (__webpack_require__(3))(84);","module.exports = (__webpack_require__(3))(14);","module.exports = (__webpack_require__(3))(282);","module.exports = (__webpack_require__(3))(60);","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { MonoTypeOperatorFunction, SubscribableOrPromise, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Ignores source values for a duration determined by another Observable, then\n * emits the most recent value from the source Observable, then repeats this\n * process.\n *\n * <span class=\"informal\">It's like {@link auditTime}, but the silencing\n * duration is determined by a second Observable.</span>\n *\n * ![](audit.png)\n *\n * `audit` is similar to `throttle`, but emits the last value from the silenced\n * time window, instead of the first value. `audit` emits the most recent value\n * from the source Observable on the output Observable as soon as its internal\n * timer becomes disabled, and ignores source values while the timer is enabled.\n * Initially, the timer is disabled. As soon as the first source value arrives,\n * the timer is enabled by calling the `durationSelector` function with the\n * source value, which returns the \"duration\" Observable. When the duration\n * Observable emits a value or completes, the timer is disabled, then the most\n * recent source value is emitted on the output Observable, and this process\n * repeats for the next source value.\n *\n * ## Example\n *\n * Emit clicks at a rate of at most one click per second\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { audit } from 'rxjs/operators'\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(audit(ev => interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n * @see {@link auditTime}\n * @see {@link debounce}\n * @see {@link delayWhen}\n * @see {@link sample}\n * @see {@link throttle}\n *\n * @param {function(value: T): SubscribableOrPromise} durationSelector A function\n * that receives a value from the source Observable, for computing the silencing\n * duration, returned as an Observable or a Promise.\n * @return {Observable<T>} An Observable that performs rate-limiting of\n * emissions from the source Observable.\n * @method audit\n * @owner Observable\n */\nexport function audit<T>(durationSelector: (value: T) => SubscribableOrPromise<any>): MonoTypeOperatorFunction<T> {\n  return function auditOperatorFunction(source: Observable<T>) {\n    return source.lift(new AuditOperator(durationSelector));\n  };\n}\n\nclass AuditOperator<T> implements Operator<T, T> {\n  constructor(private durationSelector: (value: T) => SubscribableOrPromise<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new AuditSubscriber<T, T>(subscriber, this.durationSelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass AuditSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n\n  private value?: T;\n  private hasValue: boolean = false;\n  private throttled?: Subscription;\n\n  constructor(destination: Subscriber<T>,\n              private durationSelector: (value: T) => SubscribableOrPromise<any>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    this.value = value;\n    this.hasValue = true;\n    if (!this.throttled) {\n      let duration;\n      try {\n        const { durationSelector } = this;\n        duration = durationSelector(value);\n      } catch (err) {\n        return this.destination.error!(err);\n      }\n      const innerSubscription = innerSubscribe(duration, new SimpleInnerSubscriber(this));\n      if (!innerSubscription || innerSubscription.closed) {\n        this.clearThrottle();\n      } else {\n        this.add(this.throttled = innerSubscription);\n      }\n    }\n  }\n\n  clearThrottle() {\n    const { value, hasValue, throttled } = this;\n    if (throttled) {\n      this.remove(throttled);\n      this.throttled = undefined;\n      throttled.unsubscribe();\n    }\n    if (hasValue) {\n      this.value = undefined;\n      this.hasValue = false;\n      this.destination.next!(value);\n    }\n  }\n\n  notifyNext(): void {\n    this.clearThrottle();\n  }\n\n  notifyComplete(): void {\n    this.clearThrottle();\n  }\n}\n","import { async } from '../scheduler/async';\nimport { audit } from './audit';\nimport { timer } from '../observable/timer';\nimport { MonoTypeOperatorFunction, SchedulerLike } from '../types';\n\n/**\n * Ignores source values for `duration` milliseconds, then emits the most recent\n * value from the source Observable, then repeats this process.\n *\n * <span class=\"informal\">When it sees a source value, it ignores that plus\n * the next ones for `duration` milliseconds, and then it emits the most recent\n * value from the source.</span>\n *\n * ![](auditTime.png)\n *\n * `auditTime` is similar to `throttleTime`, but emits the last value from the\n * silenced time window, instead of the first value. `auditTime` emits the most\n * recent value from the source Observable on the output Observable as soon as\n * its internal timer becomes disabled, and ignores source values while the\n * timer is enabled. Initially, the timer is disabled. As soon as the first\n * source value arrives, the timer is enabled. After `duration` milliseconds (or\n * the time unit determined internally by the optional `scheduler`) has passed,\n * the timer is disabled, then the most recent source value is emitted on the\n * output Observable, and this process repeats for the next source value.\n * Optionally takes a {@link SchedulerLike} for managing timers.\n *\n * ## Example\n *\n * Emit clicks at a rate of at most one click per second\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { auditTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(auditTime(1000));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link audit}\n * @see {@link debounceTime}\n * @see {@link delay}\n * @see {@link sampleTime}\n * @see {@link throttleTime}\n *\n * @param {number} duration Time to wait before emitting the most recent source\n * value, measured in milliseconds or the time unit determined internally\n * by the optional `scheduler`.\n * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for\n * managing the timers that handle the rate-limiting behavior.\n * @return {Observable<T>} An Observable that performs rate-limiting of\n * emissions from the source Observable.\n * @method auditTime\n * @owner Observable\n */\nexport function auditTime<T>(duration: number, scheduler: SchedulerLike = async): MonoTypeOperatorFunction<T> {\n  return audit(() => timer(duration, scheduler));\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { OperatorFunction } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Buffers the source Observable values until `closingNotifier` emits.\n *\n * <span class=\"informal\">Collects values from the past as an array, and emits\n * that array only when another Observable emits.</span>\n *\n * ![](buffer.png)\n *\n * Buffers the incoming Observable values until the given `closingNotifier`\n * Observable emits a value, at which point it emits the buffer on the output\n * Observable and starts a new buffer internally, awaiting the next time\n * `closingNotifier` emits.\n *\n * ## Example\n *\n * On every click, emit array of most recent interval events\n *\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { buffer } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const intervalEvents = interval(1000);\n * const buffered = intervalEvents.pipe(buffer(clicks));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link bufferCount}\n * @see {@link bufferTime}\n * @see {@link bufferToggle}\n * @see {@link bufferWhen}\n * @see {@link window}\n *\n * @param {Observable<any>} closingNotifier An Observable that signals the\n * buffer to be emitted on the output Observable.\n * @return {Observable<T[]>} An Observable of buffers, which are arrays of\n * values.\n * @method buffer\n * @owner Observable\n */\nexport function buffer<T>(closingNotifier: Observable<any>): OperatorFunction<T, T[]> {\n  return function bufferOperatorFunction(source: Observable<T>) {\n    return source.lift(new BufferOperator<T>(closingNotifier));\n  };\n}\n\nclass BufferOperator<T> implements Operator<T, T[]> {\n\n  constructor(private closingNotifier: Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T[]>, source: any): any {\n    return source.subscribe(new BufferSubscriber(subscriber, this.closingNotifier));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferSubscriber<T> extends SimpleOuterSubscriber<T, any> {\n  private buffer: T[] = [];\n\n  constructor(destination: Subscriber<T[]>, closingNotifier: Observable<any>) {\n    super(destination);\n    this.add(innerSubscribe(closingNotifier, new SimpleInnerSubscriber(this)));\n  }\n\n  protected _next(value: T) {\n    this.buffer.push(value);\n  }\n\n  notifyNext(): void {\n    const buffer = this.buffer;\n    this.buffer = [];\n    this.destination.next!(buffer);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { OperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Buffers the source Observable values until the size hits the maximum\n * `bufferSize` given.\n *\n * <span class=\"informal\">Collects values from the past as an array, and emits\n * that array only when its size reaches `bufferSize`.</span>\n *\n * ![](bufferCount.png)\n *\n * Buffers a number of values from the source Observable by `bufferSize` then\n * emits the buffer and clears it, and starts a new buffer each\n * `startBufferEvery` values. If `startBufferEvery` is not provided or is\n * `null`, then new buffers are started immediately at the start of the source\n * and when each buffer closes and is emitted.\n *\n * ## Examples\n *\n * Emit the last two click events as an array\n *\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { bufferCount } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const buffered = clicks.pipe(bufferCount(2));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * On every click, emit the last two click events as an array\n *\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { bufferCount } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const buffered = clicks.pipe(bufferCount(2, 1));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link buffer}\n * @see {@link bufferTime}\n * @see {@link bufferToggle}\n * @see {@link bufferWhen}\n * @see {@link pairwise}\n * @see {@link windowCount}\n *\n * @param {number} bufferSize The maximum size of the buffer emitted.\n * @param {number} [startBufferEvery] Interval at which to start a new buffer.\n * For example if `startBufferEvery` is `2`, then a new buffer will be started\n * on every other value from the source. A new buffer is started at the\n * beginning of the source by default.\n * @return {Observable<T[]>} An Observable of arrays of buffered values.\n * @method bufferCount\n * @owner Observable\n */\nexport function bufferCount<T>(bufferSize: number, startBufferEvery: number = null): OperatorFunction<T, T[]> {\n  return function bufferCountOperatorFunction(source: Observable<T>) {\n    return source.lift(new BufferCountOperator<T>(bufferSize, startBufferEvery));\n  };\n}\n\nclass BufferCountOperator<T> implements Operator<T, T[]> {\n  private subscriberClass: any;\n\n  constructor(private bufferSize: number, private startBufferEvery: number) {\n    if (!startBufferEvery || bufferSize === startBufferEvery) {\n      this.subscriberClass = BufferCountSubscriber;\n    } else {\n      this.subscriberClass = BufferSkipCountSubscriber;\n    }\n  }\n\n  call(subscriber: Subscriber<T[]>, source: any): TeardownLogic {\n    return source.subscribe(new this.subscriberClass(subscriber, this.bufferSize, this.startBufferEvery));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferCountSubscriber<T> extends Subscriber<T> {\n  private buffer: T[] = [];\n\n  constructor(destination: Subscriber<T[]>, private bufferSize: number) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const buffer = this.buffer;\n\n    buffer.push(value);\n\n    if (buffer.length == this.bufferSize) {\n      this.destination.next(buffer);\n      this.buffer = [];\n    }\n  }\n\n  protected _complete(): void {\n    const buffer = this.buffer;\n    if (buffer.length > 0) {\n      this.destination.next(buffer);\n    }\n    super._complete();\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferSkipCountSubscriber<T> extends Subscriber<T> {\n  private buffers: Array<T[]> = [];\n  private count: number = 0;\n\n  constructor(destination: Subscriber<T[]>, private bufferSize: number, private startBufferEvery: number) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const { bufferSize, startBufferEvery, buffers, count } = this;\n\n    this.count++;\n    if (count % startBufferEvery === 0) {\n      buffers.push([]);\n    }\n\n    for (let i = buffers.length; i--; ) {\n      const buffer = buffers[i];\n      buffer.push(value);\n      if (buffer.length === bufferSize) {\n        buffers.splice(i, 1);\n        this.destination.next(buffer);\n      }\n    }\n  }\n\n  protected _complete(): void {\n    const { buffers, destination } = this;\n\n    while (buffers.length > 0) {\n      let buffer = buffers.shift();\n      if (buffer.length > 0) {\n        destination.next(buffer);\n      }\n    }\n    super._complete();\n  }\n\n}\n","import { Operator } from '../Operator';\nimport { async } from '../scheduler/async';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { isScheduler } from '../util/isScheduler';\nimport { OperatorFunction, SchedulerAction, SchedulerLike } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;\nexport function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;\nexport function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, maxBufferSize: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;\n/* tslint:enable:max-line-length */\n\n/**\n * Buffers the source Observable values for a specific time period.\n *\n * <span class=\"informal\">Collects values from the past as an array, and emits\n * those arrays periodically in time.</span>\n *\n * ![](bufferTime.png)\n *\n * Buffers values from the source for a specific time duration `bufferTimeSpan`.\n * Unless the optional argument `bufferCreationInterval` is given, it emits and\n * resets the buffer every `bufferTimeSpan` milliseconds. If\n * `bufferCreationInterval` is given, this operator opens the buffer every\n * `bufferCreationInterval` milliseconds and closes (emits and resets) the\n * buffer every `bufferTimeSpan` milliseconds. When the optional argument\n * `maxBufferSize` is specified, the buffer will be closed either after\n * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.\n *\n * ## Examples\n *\n * Every second, emit an array of the recent click events\n *\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { bufferTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const buffered = clicks.pipe(bufferTime(1000));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * Every 5 seconds, emit the click events from the next 2 seconds\n *\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { bufferTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const buffered = clicks.pipe(bufferTime(2000, 5000));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link buffer}\n * @see {@link bufferCount}\n * @see {@link bufferToggle}\n * @see {@link bufferWhen}\n * @see {@link windowTime}\n *\n * @param {number} bufferTimeSpan The amount of time to fill each buffer array.\n * @param {number} [bufferCreationInterval] The interval at which to start new\n * buffers.\n * @param {number} [maxBufferSize] The maximum buffer size.\n * @param {SchedulerLike} [scheduler=async] The scheduler on which to schedule the\n * intervals that determine buffer boundaries.\n * @return {Observable<T[]>} An observable of arrays of buffered values.\n * @method bufferTime\n * @owner Observable\n */\nexport function bufferTime<T>(bufferTimeSpan: number): OperatorFunction<T, T[]> {\n  let length: number = arguments.length;\n\n  let scheduler: SchedulerLike = async;\n  if (isScheduler(arguments[arguments.length - 1])) {\n    scheduler = arguments[arguments.length - 1];\n    length--;\n  }\n\n  let bufferCreationInterval: number = null;\n  if (length >= 2) {\n    bufferCreationInterval = arguments[1];\n  }\n\n  let maxBufferSize: number = Number.POSITIVE_INFINITY;\n  if (length >= 3) {\n    maxBufferSize = arguments[2];\n  }\n\n  return function bufferTimeOperatorFunction(source: Observable<T>) {\n    return source.lift(new BufferTimeOperator<T>(bufferTimeSpan, bufferCreationInterval, maxBufferSize, scheduler));\n  };\n}\n\nclass BufferTimeOperator<T> implements Operator<T, T[]> {\n  constructor(private bufferTimeSpan: number,\n              private bufferCreationInterval: number,\n              private maxBufferSize: number,\n              private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<T[]>, source: any): any {\n    return source.subscribe(new BufferTimeSubscriber(\n      subscriber, this.bufferTimeSpan, this.bufferCreationInterval, this.maxBufferSize, this.scheduler\n    ));\n  }\n}\n\nclass Context<T> {\n  buffer: T[] = [];\n  closeAction: Subscription;\n}\n\ninterface DispatchCreateArg<T> {\n  bufferTimeSpan: number;\n  bufferCreationInterval: number;\n  subscriber: BufferTimeSubscriber<T>;\n  scheduler: SchedulerLike;\n}\n\ninterface DispatchCloseArg<T> {\n  subscriber: BufferTimeSubscriber<T>;\n  context: Context<T>;\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferTimeSubscriber<T> extends Subscriber<T> {\n  private contexts: Array<Context<T>> = [];\n  private timespanOnly: boolean;\n\n  constructor(destination: Subscriber<T[]>,\n              private bufferTimeSpan: number,\n              private bufferCreationInterval: number,\n              private maxBufferSize: number,\n              private scheduler: SchedulerLike) {\n    super(destination);\n    const context = this.openContext();\n    this.timespanOnly = bufferCreationInterval == null || bufferCreationInterval < 0;\n    if (this.timespanOnly) {\n      const timeSpanOnlyState = { subscriber: this, context, bufferTimeSpan };\n      this.add(context.closeAction = scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState));\n    } else {\n      const closeState = { subscriber: this, context };\n      const creationState: DispatchCreateArg<T> = { bufferTimeSpan, bufferCreationInterval, subscriber: this, scheduler };\n      this.add(context.closeAction = scheduler.schedule<DispatchCloseArg<T>>(dispatchBufferClose, bufferTimeSpan, closeState));\n      this.add(scheduler.schedule<DispatchCreateArg<T>>(dispatchBufferCreation, bufferCreationInterval, creationState));\n    }\n  }\n\n  protected _next(value: T) {\n    const contexts = this.contexts;\n    const len = contexts.length;\n    let filledBufferContext: Context<T>;\n    for (let i = 0; i < len; i++) {\n      const context = contexts[i];\n      const buffer = context.buffer;\n      buffer.push(value);\n      if (buffer.length == this.maxBufferSize) {\n        filledBufferContext = context;\n      }\n    }\n\n    if (filledBufferContext) {\n      this.onBufferFull(filledBufferContext);\n    }\n  }\n\n  protected _error(err: any) {\n    this.contexts.length = 0;\n    super._error(err);\n  }\n\n  protected _complete() {\n    const { contexts, destination } = this;\n    while (contexts.length > 0) {\n      const context = contexts.shift();\n      destination.next(context.buffer);\n    }\n    super._complete();\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    this.contexts = null;\n  }\n\n  protected onBufferFull(context: Context<T>) {\n    this.closeContext(context);\n    const closeAction = context.closeAction;\n    closeAction.unsubscribe();\n    this.remove(closeAction);\n\n    if (!this.closed && this.timespanOnly) {\n      context = this.openContext();\n      const bufferTimeSpan = this.bufferTimeSpan;\n      const timeSpanOnlyState = { subscriber: this, context, bufferTimeSpan };\n      this.add(context.closeAction = this.scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState));\n    }\n  }\n\n  openContext(): Context<T> {\n    const context: Context<T> = new Context<T>();\n    this.contexts.push(context);\n    return context;\n  }\n\n  closeContext(context: Context<T>) {\n    this.destination.next(context.buffer);\n    const contexts = this.contexts;\n\n    const spliceIndex = contexts ? contexts.indexOf(context) : -1;\n    if (spliceIndex >= 0) {\n      contexts.splice(contexts.indexOf(context), 1);\n    }\n  }\n}\n\nfunction dispatchBufferTimeSpanOnly(this: SchedulerAction<any>, state: any) {\n  const subscriber: BufferTimeSubscriber<any> = state.subscriber;\n\n  const prevContext = state.context;\n  if (prevContext) {\n    subscriber.closeContext(prevContext);\n  }\n\n  if (!subscriber.closed) {\n    state.context = subscriber.openContext();\n    state.context.closeAction = this.schedule(state, state.bufferTimeSpan);\n  }\n}\n\nfunction dispatchBufferCreation<T>(this: SchedulerAction<DispatchCreateArg<T>>, state: DispatchCreateArg<T>) {\n  const { bufferCreationInterval, bufferTimeSpan, subscriber, scheduler } = state;\n  const context = subscriber.openContext();\n  const action = <SchedulerAction<DispatchCreateArg<T>>>this;\n  if (!subscriber.closed) {\n    subscriber.add(context.closeAction = scheduler.schedule<DispatchCloseArg<T>>(dispatchBufferClose, bufferTimeSpan, { subscriber, context }));\n    action.schedule(state, bufferCreationInterval);\n  }\n}\n\nfunction dispatchBufferClose<T>(arg: DispatchCloseArg<T>) {\n  const { subscriber, context } = arg;\n  subscriber.closeContext(context);\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { OperatorFunction, SubscribableOrPromise } from '../types';\n\n/**\n * Buffers the source Observable values starting from an emission from\n * `openings` and ending when the output of `closingSelector` emits.\n *\n * <span class=\"informal\">Collects values from the past as an array. Starts\n * collecting only when `opening` emits, and calls the `closingSelector`\n * function to get an Observable that tells when to close the buffer.</span>\n *\n * ![](bufferToggle.png)\n *\n * Buffers values from the source by opening the buffer via signals from an\n * Observable provided to `openings`, and closing and sending the buffers when\n * a Subscribable or Promise returned by the `closingSelector` function emits.\n *\n * ## Example\n *\n * Every other second, emit the click events from the next 500ms\n *\n * ```ts\n * import { fromEvent, interval, EMPTY } from 'rxjs';\n * import { bufferToggle } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const openings = interval(1000);\n * const buffered = clicks.pipe(bufferToggle(openings, i =>\n *   i % 2 ? interval(500) : EMPTY\n * ));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link buffer}\n * @see {@link bufferCount}\n * @see {@link bufferTime}\n * @see {@link bufferWhen}\n * @see {@link windowToggle}\n *\n * @param {SubscribableOrPromise<O>} openings A Subscribable or Promise of notifications to start new\n * buffers.\n * @param {function(value: O): SubscribableOrPromise} closingSelector A function that takes\n * the value emitted by the `openings` observable and returns a Subscribable or Promise,\n * which, when it emits, signals that the associated buffer should be emitted\n * and cleared.\n * @return {Observable<T[]>} An observable of arrays of buffered values.\n * @method bufferToggle\n * @owner Observable\n */\nexport function bufferToggle<T, O>(\n  openings: SubscribableOrPromise<O>,\n  closingSelector: (value: O) => SubscribableOrPromise<any>\n): OperatorFunction<T, T[]> {\n  return function bufferToggleOperatorFunction(source: Observable<T>) {\n    return source.lift(new BufferToggleOperator<T, O>(openings, closingSelector));\n  };\n}\n\nclass BufferToggleOperator<T, O> implements Operator<T, T[]> {\n\n  constructor(private openings: SubscribableOrPromise<O>,\n              private closingSelector: (value: O) => SubscribableOrPromise<any>) {\n  }\n\n  call(subscriber: Subscriber<T[]>, source: any): any {\n    return source.subscribe(new BufferToggleSubscriber(subscriber, this.openings, this.closingSelector));\n  }\n}\n\ninterface BufferContext<T> {\n  buffer: T[];\n  subscription: Subscription;\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferToggleSubscriber<T, O> extends OuterSubscriber<T, O> {\n  private contexts: Array<BufferContext<T>> = [];\n\n  constructor(destination: Subscriber<T[]>,\n              openings: SubscribableOrPromise<O>,\n              private closingSelector: (value: O) => SubscribableOrPromise<any> | void) {\n    super(destination);\n    this.add(subscribeToResult(this, openings));\n  }\n\n  protected _next(value: T): void {\n    const contexts = this.contexts;\n    const len = contexts.length;\n    for (let i = 0; i < len; i++) {\n      contexts[i].buffer.push(value);\n    }\n  }\n\n  protected _error(err: any): void {\n    const contexts = this.contexts;\n    while (contexts.length > 0) {\n      const context = contexts.shift()!;\n      context.subscription.unsubscribe();\n      context.buffer = null!;\n      context.subscription = null!;\n    }\n    this.contexts = null!;\n    super._error(err);\n  }\n\n  protected _complete(): void {\n    const contexts = this.contexts;\n    while (contexts.length > 0) {\n      const context = contexts.shift()!;\n      this.destination.next!(context.buffer);\n      context.subscription.unsubscribe();\n      context.buffer = null!;\n      context.subscription = null!;\n    }\n    this.contexts = null!;\n    super._complete();\n  }\n\n  notifyNext(outerValue: any, innerValue: O): void {\n    outerValue ? this.closeBuffer(outerValue) : this.openBuffer(innerValue);\n  }\n\n  notifyComplete(innerSub: InnerSubscriber<T, O>): void {\n    this.closeBuffer((<any> innerSub).context);\n  }\n\n  private openBuffer(value: O): void {\n    try {\n      const closingSelector = this.closingSelector;\n      const closingNotifier = closingSelector.call(this, value);\n      if (closingNotifier) {\n        this.trySubscribe(closingNotifier);\n      }\n    } catch (err) {\n      this._error(err);\n    }\n  }\n\n  private closeBuffer(context: BufferContext<T>): void {\n    const contexts = this.contexts;\n\n    if (contexts && context) {\n      const { buffer, subscription } = context;\n      this.destination.next!(buffer);\n      contexts.splice(contexts.indexOf(context), 1);\n      this.remove(subscription);\n      subscription.unsubscribe();\n    }\n  }\n\n  private trySubscribe(closingNotifier: any): void {\n    const contexts = this.contexts;\n\n    const buffer: Array<T> = [];\n    const subscription = new Subscription();\n    const context = { buffer, subscription };\n    contexts.push(context);\n\n    const innerSubscription = subscribeToResult(this, closingNotifier, context as any);\n\n    if (!innerSubscription || innerSubscription.closed) {\n      this.closeBuffer(context);\n    } else {\n      (innerSubscription as any).context = context;\n\n      this.add(innerSubscription);\n      subscription.add(innerSubscription);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { OperatorFunction } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Buffers the source Observable values, using a factory function of closing\n * Observables to determine when to close, emit, and reset the buffer.\n *\n * <span class=\"informal\">Collects values from the past as an array. When it\n * starts collecting values, it calls a function that returns an Observable that\n * tells when to close the buffer and restart collecting.</span>\n *\n * ![](bufferWhen.png)\n *\n * Opens a buffer immediately, then closes the buffer when the observable\n * returned by calling `closingSelector` function emits a value. When it closes\n * the buffer, it immediately opens a new buffer and repeats the process.\n *\n * ## Example\n *\n * Emit an array of the last clicks every [1-5] random seconds\n *\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { bufferWhen } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const buffered = clicks.pipe(bufferWhen(() =>\n *   interval(1000 + Math.random() * 4000)\n * ));\n * buffered.subscribe(x => console.log(x));\n * ```\n *\n *\n * @see {@link buffer}\n * @see {@link bufferCount}\n * @see {@link bufferTime}\n * @see {@link bufferToggle}\n * @see {@link windowWhen}\n *\n * @param {function(): Observable} closingSelector A function that takes no\n * arguments and returns an Observable that signals buffer closure.\n * @return {Observable<T[]>} An observable of arrays of buffered values.\n * @method bufferWhen\n * @owner Observable\n */\nexport function bufferWhen<T>(closingSelector: () => Observable<any>): OperatorFunction<T, T[]> {\n  return function (source: Observable<T>) {\n    return source.lift(new BufferWhenOperator(closingSelector));\n  };\n}\n\nclass BufferWhenOperator<T> implements Operator<T, T[]> {\n\n  constructor(private closingSelector: () => Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T[]>, source: any): any {\n    return source.subscribe(new BufferWhenSubscriber(subscriber, this.closingSelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass BufferWhenSubscriber<T> extends SimpleOuterSubscriber<T, any> {\n  private buffer?: T[];\n  private subscribing: boolean = false;\n  private closingSubscription?: Subscription;\n\n  constructor(destination: Subscriber<T[]>, private closingSelector: () => Observable<any>) {\n    super(destination);\n    this.openBuffer();\n  }\n\n  protected _next(value: T) {\n    this.buffer!.push(value);\n  }\n\n  protected _complete() {\n    const buffer = this.buffer;\n    if (buffer) {\n      this.destination.next!(buffer);\n    }\n    super._complete();\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    this.buffer = undefined;\n    this.subscribing = false;\n  }\n\n  notifyNext(): void {\n    this.openBuffer();\n  }\n\n  notifyComplete(): void {\n    if (this.subscribing) {\n      this.complete();\n    } else {\n      this.openBuffer();\n    }\n  }\n\n  openBuffer() {\n    let { closingSubscription } = this;\n\n    if (closingSubscription) {\n      this.remove(closingSubscription);\n      closingSubscription.unsubscribe();\n    }\n\n    const buffer = this.buffer;\n    if (this.buffer) {\n      this.destination.next!(buffer);\n    }\n\n    this.buffer = [];\n\n    let closingNotifier;\n    try {\n      const { closingSelector } = this;\n      closingNotifier = closingSelector();\n    } catch (err) {\n      return this.error(err);\n    }\n    closingSubscription = new Subscription();\n    this.closingSubscription = closingSubscription;\n    this.add(closingSubscription);\n    this.subscribing = true;\n    closingSubscription.add(innerSubscribe(closingNotifier, new SimpleInnerSubscriber(this)));\n    this.subscribing = false;\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\n\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function catchError<T, O extends ObservableInput<any>>(selector: (err: any, caught: Observable<T>) => O): OperatorFunction<T, T | ObservedValueOf<O>>;\n/* tslint:enable:max-line-length */\n\n/**\n * Catches errors on the observable to be handled by returning a new observable or throwing an error.\n *\n * ![](catch.png)\n *\n * ## Examples\n * Continues with a different Observable when there's an error\n *\n * ```ts\n * import { of } from 'rxjs';\n * import { map, catchError } from 'rxjs/operators';\n *\n * of(1, 2, 3, 4, 5).pipe(\n *     map(n => {\n *   \t   if (n === 4) {\n * \t       throw 'four!';\n *       }\n *\t     return n;\n *     }),\n *     catchError(err => of('I', 'II', 'III', 'IV', 'V')),\n *   )\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, I, II, III, IV, V\n * ```\n *\n * Retries the caught source Observable again in case of error, similar to retry() operator\n *\n * ```ts\n * import { of } from 'rxjs';\n * import { map, catchError, take } from 'rxjs/operators';\n *\n * of(1, 2, 3, 4, 5).pipe(\n *     map(n => {\n *   \t   if (n === 4) {\n *   \t     throw 'four!';\n *       }\n * \t     return n;\n *     }),\n *     catchError((err, caught) => caught),\n *     take(30),\n *   )\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, 1, 2, 3, ...\n * ```\n *\n * Throws a new error when the source Observable throws an error\n *\n * ```ts\n * import { of } from 'rxjs';\n * import { map, catchError } from 'rxjs/operators';\n *\n * of(1, 2, 3, 4, 5).pipe(\n *     map(n => {\n *       if (n === 4) {\n *         throw 'four!';\n *       }\n *       return n;\n *     }),\n *     catchError(err => {\n *       throw 'error in source. Details: ' + err;\n *     }),\n *   )\n *   .subscribe(\n *     x => console.log(x),\n *     err => console.log(err)\n *   );\n *   // 1, 2, 3, error in source. Details: four!\n * ```\n *\n *  @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which\n *  is the source observable, in case you'd like to \"retry\" that observable by returning it again. Whatever observable\n *  is returned by the `selector` will be used to continue the observable chain.\n * @return {Observable} An observable that originates from either the source or the observable returned by the\n *  catch `selector` function.\n * @name catchError\n */\nexport function catchError<T, O extends ObservableInput<any>>(\n  selector: (err: any, caught: Observable<T>) => O\n): OperatorFunction<T, T | ObservedValueOf<O>> {\n  return function catchErrorOperatorFunction(source: Observable<T>): Observable<T | ObservedValueOf<O>> {\n    const operator = new CatchOperator(selector);\n    const caught = source.lift(operator);\n    return (operator.caught = caught as Observable<T>);\n  };\n}\n\nclass CatchOperator<T, R> implements Operator<T, T | R> {\n  caught: Observable<T>;\n\n  constructor(private selector: (err: any, caught: Observable<T>) => ObservableInput<T | R>) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass CatchSubscriber<T, R> extends SimpleOuterSubscriber<T, T | R> {\n  constructor(destination: Subscriber<any>,\n              private selector: (err: any, caught: Observable<T>) => ObservableInput<T | R>,\n              private caught: Observable<T>) {\n    super(destination);\n  }\n\n  // NOTE: overriding `error` instead of `_error` because we don't want\n  // to have this flag this subscriber as `isStopped`. We can mimic the\n  // behavior of the RetrySubscriber (from the `retry` operator), where\n  // we unsubscribe from our source chain, reset our Subscriber flags,\n  // then subscribe to the selector result.\n  error(err: any) {\n    if (!this.isStopped) {\n      let result: any;\n      try {\n        result = this.selector(err, this.caught);\n      } catch (err2) {\n        super.error(err2);\n        return;\n      }\n      this._unsubscribeAndRecycle();\n      const innerSubscriber = new SimpleInnerSubscriber(this);\n      this.add(innerSubscriber);\n      const innerSubscription = innerSubscribe(result, innerSubscriber);\n      // The returned subscription will usually be the subscriber that was\n      // passed. However, interop subscribers will be wrapped and for\n      // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n      if (innerSubscription !== innerSubscriber) {\n        this.add(innerSubscription);\n      }\n    }\n  }\n}\n","import { CombineLatestOperator } from '../observable/combineLatest';\nimport { Observable } from '../Observable';\nimport { OperatorFunction, ObservableInput } from '../types';\n\nexport function combineAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;\nexport function combineAll<T>(): OperatorFunction<any, T[]>;\nexport function combineAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;\nexport function combineAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;\n/**\n * Flattens an Observable-of-Observables by applying {@link combineLatest} when the Observable-of-Observables completes.\n *\n * ![](combineAll.png)\n *\n * `combineAll` takes an Observable of Observables, and collects all Observables from it. Once the outer Observable completes,\n * it subscribes to all collected Observables and combines their values using the {@link combineLatest}</a> strategy, such that:\n *\n * * Every time an inner Observable emits, the output Observable emits\n * * When the returned observable emits, it emits all of the latest values by:\n *    * If a `project` function is provided, it is called with each recent value from each inner Observable in whatever order they\n *      arrived, and the result of the `project` function is what is emitted by the output Observable.\n *    * If there is no `project` function, an array of all the most recent values is emitted by the output Observable.\n *\n * ---\n *\n * ## Examples\n *\n * ### Map two click events to a finite interval Observable, then apply `combineAll`\n *\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { map, combineAll, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const higherOrder = clicks.pipe(\n *   map(ev =>\n *      interval(Math.random() * 2000).pipe(take(3))\n *   ),\n *   take(2)\n * );\n * const result = higherOrder.pipe(\n *   combineAll()\n * );\n *\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link combineLatest}\n * @see {@link mergeAll}\n *\n * @param {function(...values: Array<any>)} An optional function to map the most recent values from each inner Observable into a new result.\n * Takes each of the most recent values from each collected inner Observable as arguments, in order.\n * @return {Observable<T>}\n * @name combineAll\n */\nexport function combineAll<T, R>(project?: (...values: Array<any>) => R): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift(new CombineLatestOperator(project));\n}\n","\nimport { isArray } from '../util/isArray';\nimport { CombineLatestOperator } from '../observable/combineLatest';\nimport { from } from '../observable/from';\nimport { Observable } from '../Observable';\nimport { ObservableInput, OperatorFunction } from '../types';\n\nconst none = {};\n\n/* tslint:disable:max-line-length */\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, R>(project: (v1: T) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, R>(v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): OperatorFunction<T, R> ;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2>(v2: ObservableInput<T2>): OperatorFunction<T, [T, T2]>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): OperatorFunction<T, [T, T2, T3]>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): OperatorFunction<T, [T, T2, T3, T4]>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): OperatorFunction<T, [T, T2, T3, T4, T5]>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): OperatorFunction<T, [T, T2, T3, T4, T5, T6]> ;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, R>(...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, R>(array: ObservableInput<T>[]): OperatorFunction<T, Array<T>>;\n/** @deprecated Deprecated in favor of static combineLatest. */\nexport function combineLatest<T, TOther, R>(array: ObservableInput<TOther>[], project: (v1: T, ...values: Array<TOther>) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * @deprecated Deprecated in favor of static {@link combineLatest}.\n */\nexport function combineLatest<T, R>(...observables: Array<ObservableInput<any> |\n                                                    Array<ObservableInput<any>> |\n                                                    ((...values: Array<any>) => R)>): OperatorFunction<T, R> {\n  let project: (...values: Array<any>) => R = null;\n  if (typeof observables[observables.length - 1] === 'function') {\n    project = <(...values: Array<any>) => R>observables.pop();\n  }\n\n  // if the first and only other argument besides the resultSelector is an array\n  // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`\n  if (observables.length === 1 && isArray(observables[0])) {\n    observables = (<any>observables[0]).slice();\n  }\n\n  return (source: Observable<T>) => source.lift.call(from([source, ...observables]), new CombineLatestOperator(project));\n}\n","import {  concat as concatStatic } from '../observable/concat';\nimport { Observable } from '../Observable';\nimport { ObservableInput, OperatorFunction, MonoTypeOperatorFunction, SchedulerLike } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T>(scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, T2>(v2: ObservableInput<T2>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T>(...observables: Array<ObservableInput<T> | SchedulerLike>): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static concat. */\nexport function concat<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike>): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * @deprecated Deprecated in favor of static {@link concat}.\n */\nexport function concat<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike>): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift.call(concatStatic(source, ...observables));\n}\n","import { mergeMap } from './mergeMap';\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function concatMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) =>  O): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector no longer supported, use inner map instead */\nexport function concatMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector no longer supported, use inner map instead */\nexport function concatMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) =>  O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, in a serialized fashion waiting for each one to complete before\n * merging the next.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link concatAll}.</span>\n *\n * ![](concatMap.png)\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 new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * ## Example\n * For each click event, tick every second from 0 to 3, with no concurrency\n *\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { concatMap, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   concatMap(ev => interval(1000).pipe(take(4)))\n * );\n * result.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 *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMapTo}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\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 * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional deprecated `resultSelector`) to each item emitted\n * by the source Observable and taking values from each projected inner\n * Observable sequentially.\n * @method concatMap\n * @owner Observable\n */\nexport function concatMap<T, R, O extends ObservableInput<any>>(\n  project: (value: T, index: number) => O,\n  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R\n): OperatorFunction<T, ObservedValueOf<O>|R> {\n  return mergeMap(project, resultSelector, 1);\n}\n","import { concatMap } from './concatMap';\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function concatMapTo<T, O extends ObservableInput<any>>(observable: O): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated */\nexport function concatMapTo<T, O extends ObservableInput<any>>(observable: O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated */\nexport function concatMapTo<T, R, O extends ObservableInput<any>>(observable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Projects each source value to the same Observable which is merged multiple\n * times in a serialized fashion on the output Observable.\n *\n * <span class=\"informal\">It's like {@link concatMap}, but maps each value\n * always to the same inner Observable.</span>\n *\n * ![](concatMapTo.png)\n *\n * Maps each source value to the given Observable `innerObservable` regardless\n * of the source value, and then flattens those resulting Observables into one\n * single Observable, which is the output Observable. Each new `innerObservable`\n * instance emitted on the output Observable is concatenated with the previous\n * `innerObservable` instance.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMapTo` is equivalent to `mergeMapTo` with concurrency parameter\n * set to `1`.\n *\n * ## Example\n * For each click event, tick every second from 0 to 3, with no concurrency\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { concatMapTo, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   concatMapTo(interval(1000).pipe(take(4))),\n * );\n * result.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 *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMap}\n * @see {@link mergeMapTo}\n * @see {@link switchMapTo}\n *\n * @param {ObservableInput} innerObservable An Observable to replace each value from\n * the source Observable.\n * @return {Observable} An observable of values merged together by joining the\n * passed observable with itself, one after the other, for each value emitted\n * from the source.\n * @method concatMapTo\n * @owner Observable\n */\nexport function concatMapTo<T, R, O extends ObservableInput<any>>(\n  innerObservable: O,\n  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R\n): OperatorFunction<T, ObservedValueOf<O>|R> {\n  return concatMap(() => innerObservable, resultSelector);\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Observer, OperatorFunction } from '../types';\nimport { Subscriber } from '../Subscriber';\n/**\n * Counts the number of emissions on the source and emits that number when the\n * source completes.\n *\n * <span class=\"informal\">Tells how many values were emitted, when the source\n * completes.</span>\n *\n * ![](count.png)\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\n *\n * ## Examples\n *\n * Counts how many seconds have passed before the first click happened\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { count, takeUntil } from 'rxjs/operators';\n *\n * const seconds = interval(1000);\n * const clicks = fromEvent(document, 'click');\n * const secondsBeforeClick = seconds.pipe(takeUntil(clicks));\n * const result = secondsBeforeClick.pipe(count());\n * result.subscribe(x => console.log(x));\n * ```\n *\n * Counts how many odd numbers are there between 1 and 7\n * ```ts\n * import { range } from 'rxjs';\n * import { count } from 'rxjs/operators';\n *\n * const numbers = range(1, 7);\n * const result = numbers.pipe(count(i => i % 2 === 1));\n * result.subscribe(x => console.log(x));\n * // Results in:\n * // 4\n * ```\n *\n * @see {@link max}\n * @see {@link min}\n * @see {@link reduce}\n *\n * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A\n * boolean function to select what values are to be counted. It is provided with\n * arguments of:\n * - `value`: the value from the source Observable.\n * - `index`: the (zero-based) \"index\" of the value from the source Observable.\n * - `source`: the source Observable instance itself.\n * @return {Observable} An Observable of one number that represents the count as\n * described above.\n * @method count\n * @owner Observable\n */\n\nexport function count<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, number> {\n  return (source: Observable<T>) => source.lift(new CountOperator(predicate, source));\n}\n\nclass CountOperator<T> implements Operator<T, number> {\n  constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,\n              private source?: Observable<T>) {\n  }\n\n  call(subscriber: Subscriber<number>, source: any): any {\n    return source.subscribe(new CountSubscriber(subscriber, this.predicate, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass CountSubscriber<T> extends Subscriber<T> {\n  private count: number = 0;\n  private index: number = 0;\n\n  constructor(destination: Observer<number>,\n              private predicate?: (value: T, index: number, source: Observable<T>) => boolean,\n              private source?: Observable<T>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    if (this.predicate) {\n      this._tryPredicate(value);\n    } else {\n      this.count++;\n    }\n  }\n\n  private _tryPredicate(value: T) {\n    let result: any;\n\n    try {\n      result = this.predicate(value, this.index++, this.source);\n    } catch (err) {\n      this.destination.error(err);\n      return;\n    }\n\n    if (result) {\n      this.count++;\n    }\n  }\n\n  protected _complete(): void {\n    this.destination.next(this.count);\n    this.destination.complete();\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { MonoTypeOperatorFunction, SubscribableOrPromise, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Emits a value from the source Observable only after a particular time span\n * determined by another Observable has passed without another source emission.\n *\n * <span class=\"informal\">It's like {@link debounceTime}, but the time span of\n * emission silence is determined by a second Observable.</span>\n *\n * ![](debounce.png)\n *\n * `debounce` delays values emitted by the source Observable, but drops previous\n * pending delayed emissions if a new value arrives on the source Observable.\n * This operator keeps track of the most recent value from the source\n * Observable, and spawns a duration Observable by calling the\n * `durationSelector` function. The value is emitted only when the duration\n * Observable emits a value or completes, and if no other value was emitted on\n * the source Observable since the duration Observable was spawned. If a new\n * value appears before the duration Observable emits, the previous value will\n * be dropped and will not be emitted on the output Observable.\n *\n * Like {@link debounceTime}, this is a rate-limiting operator, and also a\n * delay-like operator since output emissions do not necessarily occur at the\n * same time as they did on the source Observable.\n *\n * ## Example\n * Emit the most recent click after a burst of clicks\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { debounce } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(debounce(() => interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link audit}\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n * @see {@link throttle}\n *\n * @param {function(value: T): SubscribableOrPromise} durationSelector A function\n * that receives a value from the source Observable, for computing the timeout\n * duration for each source value, returned as an Observable or a Promise.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified duration Observable returned by\n * `durationSelector`, and may drop some values if they occur too frequently.\n * @method debounce\n * @owner Observable\n */\nexport function debounce<T>(durationSelector: (value: T) => SubscribableOrPromise<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new DebounceOperator(durationSelector));\n}\n\nclass DebounceOperator<T> implements Operator<T, T> {\n  constructor(private durationSelector: (value: T) => SubscribableOrPromise<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DebounceSubscriber(subscriber, this.durationSelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DebounceSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private value?: T;\n  private hasValue = false;\n  private durationSubscription?: Subscription;\n\n  constructor(destination: Subscriber<R>,\n              private durationSelector: (value: T) => SubscribableOrPromise<any>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    try {\n      const result = this.durationSelector.call(this, value);\n\n      if (result) {\n        this._tryNext(value, result);\n      }\n    } catch (err) {\n      this.destination.error!(err);\n    }\n  }\n\n  protected _complete(): void {\n    this.emitValue();\n    this.destination.complete!();\n  }\n\n  private _tryNext(value: T, duration: SubscribableOrPromise<any>): void {\n    let subscription = this.durationSubscription;\n    this.value = value;\n    this.hasValue = true;\n    if (subscription) {\n      subscription.unsubscribe();\n      this.remove(subscription);\n    }\n\n    subscription = innerSubscribe(duration, new SimpleInnerSubscriber(this));\n    if (subscription && !subscription.closed) {\n      this.add(this.durationSubscription = subscription);\n    }\n  }\n\n  notifyNext(): void {\n    this.emitValue();\n  }\n\n  notifyComplete(): void {\n    this.emitValue();\n  }\n\n  emitValue(): void {\n    if (this.hasValue) {\n      const value = this.value;\n      const subscription = this.durationSubscription;\n      if (subscription) {\n        this.durationSubscription = undefined;\n        subscription.unsubscribe();\n        this.remove(subscription);\n      }\n      // This must be done *before* passing the value\n      // along to the destination because it's possible for\n      // the value to synchronously re-enter this operator\n      // recursively if the duration selector Observable\n      // emits synchronously\n      this.value = undefined;\n      this.hasValue = false;\n      super._next(value!);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { async } from '../scheduler/async';\nimport { MonoTypeOperatorFunction, SchedulerLike, TeardownLogic } from '../types';\n\n/**\n * Emits a value from the source Observable only after a particular time span\n * has passed without another source emission.\n *\n * <span class=\"informal\">It's like {@link delay}, but passes only the most\n * recent value from each burst of emissions.</span>\n *\n * ![](debounceTime.png)\n *\n * `debounceTime` delays values emitted by the source Observable, but drops\n * previous pending delayed emissions if a new value arrives on the source\n * Observable. This operator keeps track of the most recent value from the\n * source Observable, and emits that only when `dueTime` enough time has passed\n * without any other value appearing on the source Observable. If a new value\n * appears before `dueTime` silence occurs, the previous value will be dropped\n * and will not be emitted on the output Observable.\n *\n * This is a rate-limiting operator, because it is impossible for more than one\n * value to be emitted in any time window of duration `dueTime`, but it is also\n * a delay-like operator since output emissions do not occur at the same time as\n * they did on the source Observable. Optionally takes a {@link SchedulerLike} for\n * managing timers.\n *\n * ## Example\n * Emit the most recent click after a burst of clicks\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { debounceTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(debounceTime(1000));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link auditTime}\n * @see {@link debounce}\n * @see {@link delay}\n * @see {@link sampleTime}\n * @see {@link throttleTime}\n *\n * @param {number} dueTime The timeout duration in milliseconds (or the time\n * unit determined internally by the optional `scheduler`) for the window of\n * time required to wait for emission silence before emitting the most recent\n * source value.\n * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for\n * managing the timers that handle the timeout for each value.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified `dueTime`, and may drop some values if they occur\n * too frequently.\n * @method debounceTime\n * @owner Observable\n */\nexport function debounceTime<T>(dueTime: number, scheduler: SchedulerLike = async): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new DebounceTimeOperator(dueTime, scheduler));\n}\n\nclass DebounceTimeOperator<T> implements Operator<T, T> {\n  constructor(private dueTime: number, private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DebounceTimeSubscriber<T> extends Subscriber<T> {\n  private debouncedSubscription: Subscription = null;\n  private lastValue: T = null;\n  private hasValue: boolean = false;\n\n  constructor(destination: Subscriber<T>,\n              private dueTime: number,\n              private scheduler: SchedulerLike) {\n    super(destination);\n  }\n\n  protected _next(value: T) {\n    this.clearDebounce();\n    this.lastValue = value;\n    this.hasValue = true;\n    this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this));\n  }\n\n  protected _complete() {\n    this.debouncedNext();\n    this.destination.complete();\n  }\n\n  debouncedNext(): void {\n    this.clearDebounce();\n\n    if (this.hasValue) {\n      const { lastValue } = this;\n      // This must be done *before* passing the value\n      // along to the destination because it's possible for\n      // the value to synchronously re-enter this operator\n      // recursively when scheduled with things like\n      // VirtualScheduler/TestScheduler.\n      this.lastValue = null;\n      this.hasValue = false;\n      this.destination.next(lastValue);\n    }\n  }\n\n  private clearDebounce(): void {\n    const debouncedSubscription = this.debouncedSubscription;\n\n    if (debouncedSubscription !== null) {\n      this.remove(debouncedSubscription);\n      debouncedSubscription.unsubscribe();\n      this.debouncedSubscription = null;\n    }\n  }\n}\n\nfunction dispatchNext(subscriber: DebounceTimeSubscriber<any>) {\n  subscriber.debouncedNext();\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { OperatorFunction, MonoTypeOperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function defaultIfEmpty<T>(defaultValue?: T): MonoTypeOperatorFunction<T>;\nexport function defaultIfEmpty<T, R>(defaultValue?: R): OperatorFunction<T, T | R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Emits a given value if the source Observable completes without emitting any\n * `next` value, otherwise mirrors the source Observable.\n *\n * <span class=\"informal\">If the source Observable turns out to be empty, then\n * this operator will emit a default value.</span>\n *\n * ![](defaultIfEmpty.png)\n *\n * `defaultIfEmpty` emits the values emitted by the source Observable or a\n * specified default value if the source Observable is empty (completes without\n * having emitted any `next` value).\n *\n * ## Example\n * If no clicks happen in 5 seconds, then emit \"no clicks\"\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { defaultIfEmpty, takeUntil } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const clicksBeforeFive = clicks.pipe(takeUntil(interval(5000)));\n * const result = clicksBeforeFive.pipe(defaultIfEmpty('no clicks'));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link empty}\n * @see {@link last}\n *\n * @param {any} [defaultValue=null] The default value used if the source\n * Observable is empty.\n * @return {Observable} An Observable that emits either the specified\n * `defaultValue` if the source Observable emits no items, or the values emitted\n * by the source Observable.\n * @method defaultIfEmpty\n * @owner Observable\n */\nexport function defaultIfEmpty<T, R>(defaultValue: R = null): OperatorFunction<T, T | R> {\n  return (source: Observable<T>) => source.lift(new DefaultIfEmptyOperator(defaultValue)) as Observable<T | R>;\n}\n\nclass DefaultIfEmptyOperator<T, R> implements Operator<T, T | R> {\n\n  constructor(private defaultValue: R) {\n  }\n\n  call(subscriber: Subscriber<T | R>, source: any): any {\n    return source.subscribe(new DefaultIfEmptySubscriber(subscriber, this.defaultValue));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DefaultIfEmptySubscriber<T, R> extends Subscriber<T> {\n  private isEmpty: boolean = true;\n\n  constructor(destination: Subscriber<T | R>, private defaultValue: R) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    this.isEmpty = false;\n    this.destination.next(value);\n  }\n\n  protected _complete(): void {\n    if (this.isEmpty) {\n      this.destination.next(this.defaultValue);\n    }\n    this.destination.complete();\n  }\n}\n","export function isDate(value: any): value is Date {\n  return value instanceof Date && !isNaN(+value);\n}\n","import { async } from '../scheduler/async';\nimport { isDate } from '../util/isDate';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { Notification } from '../Notification';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, PartialObserver, SchedulerAction, SchedulerLike, TeardownLogic } from '../types';\n\n/**\n * Delays the emission of items from the source Observable by a given timeout or\n * until a given Date.\n *\n * <span class=\"informal\">Time shifts each item by some specified amount of\n * milliseconds.</span>\n *\n * ![](delay.png)\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\n *\n * ## Examples\n * Delay each click by one second\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { delay } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const delayedClicks = clicks.pipe(delay(1000)); // each click emitted after 1 second\n * delayedClicks.subscribe(x => console.log(x));\n * ```\n *\n * Delay all clicks until a future date happens\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { delay } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const date = new Date('March 15, 2050 12:00:00'); // in the future\n * const delayedClicks = clicks.pipe(delay(date)); // click emitted only after that date\n * delayedClicks.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n *\n * @param {number|Date} delay The delay duration in milliseconds (a `number`) or\n * a `Date` until which the emission of the source items is delayed.\n * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for\n * managing the timers that handle the time-shift for each item.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified timeout or Date.\n * @method delay\n * @owner Observable\n */\nexport function delay<T>(delay: number|Date,\n                         scheduler: SchedulerLike = async): MonoTypeOperatorFunction<T> {\n  const absoluteDelay = isDate(delay);\n  const delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(<number>delay);\n  return (source: Observable<T>) => source.lift(new DelayOperator(delayFor, scheduler));\n}\n\nclass DelayOperator<T> implements Operator<T, T> {\n  constructor(private delay: number,\n              private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));\n  }\n}\n\ninterface DelayState<T> {\n  source: DelaySubscriber<T>;\n  destination: PartialObserver<T>;\n  scheduler: SchedulerLike;\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DelaySubscriber<T> extends Subscriber<T> {\n  private queue: Array<DelayMessage<T>> = [];\n  private active: boolean = false;\n  private errored: boolean = false;\n\n  private static dispatch<T>(this: SchedulerAction<DelayState<T>>, state: DelayState<T>): void {\n    const source = state.source;\n    const queue = source.queue;\n    const scheduler = state.scheduler;\n    const destination = state.destination;\n\n    while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {\n      queue.shift().notification.observe(destination);\n    }\n\n    if (queue.length > 0) {\n      const delay = Math.max(0, queue[0].time - scheduler.now());\n      this.schedule(state, delay);\n    } else {\n      this.unsubscribe();\n      source.active = false;\n    }\n  }\n\n  constructor(destination: Subscriber<T>,\n              private delay: number,\n              private scheduler: SchedulerLike) {\n    super(destination);\n  }\n\n  private _schedule(scheduler: SchedulerLike): void {\n    this.active = true;\n    const destination = this.destination as Subscription;\n    destination.add(scheduler.schedule<DelayState<T>>(DelaySubscriber.dispatch, this.delay, {\n      source: this, destination: this.destination, scheduler: scheduler\n    }));\n  }\n\n  private scheduleNotification(notification: Notification<T>): void {\n    if (this.errored === true) {\n      return;\n    }\n\n    const scheduler = this.scheduler;\n    const message = new DelayMessage(scheduler.now() + this.delay, notification);\n    this.queue.push(message);\n\n    if (this.active === false) {\n      this._schedule(scheduler);\n    }\n  }\n\n  protected _next(value: T) {\n    this.scheduleNotification(Notification.createNext(value));\n  }\n\n  protected _error(err: any) {\n    this.errored = true;\n    this.queue = [];\n    this.destination.error(err);\n    this.unsubscribe();\n  }\n\n  protected _complete() {\n    this.scheduleNotification(Notification.createComplete());\n    this.unsubscribe();\n  }\n}\n\nclass DelayMessage<T> {\n  constructor(public readonly time: number,\n              public readonly notification: Notification<T>) {\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated In future versions, empty notifiers will no longer re-emit the source value on the output observable. */\nexport function delayWhen<T>(delayDurationSelector: (value: T, index: number) => Observable<never>, subscriptionDelay?: Observable<any>): MonoTypeOperatorFunction<T>;\nexport function delayWhen<T>(delayDurationSelector: (value: T, index: number) => Observable<any>, subscriptionDelay?: Observable<any>): MonoTypeOperatorFunction<T>;\n/* tslint:disable:max-line-length */\n\n/**\n * Delays the emission of items from the source Observable by a given time span\n * determined by the emissions of another Observable.\n *\n * <span class=\"informal\">It's like {@link delay}, but the time span of the\n * delay duration is determined by a second Observable.</span>\n *\n * ![](delayWhen.png)\n *\n * `delayWhen` time shifts each emitted value from the source Observable by a\n * time span determined by another Observable. When the source emits a value,\n * the `delayDurationSelector` function is called with the source value as\n * argument, and should return an Observable, called the \"duration\" Observable.\n * The source value is emitted on the output Observable only when the duration\n * Observable emits a value or completes.\n * The completion of the notifier triggering the emission of the source value\n * is deprecated behavior and will be removed in future versions.\n *\n * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which\n * is an Observable. When `subscriptionDelay` emits its first value or\n * completes, the source Observable is subscribed to and starts behaving like\n * described in the previous paragraph. If `subscriptionDelay` is not provided,\n * `delayWhen` will subscribe to the source Observable as soon as the output\n * Observable is subscribed.\n *\n * ## Example\n * Delay each click by a random amount of time, between 0 and 5 seconds\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { delayWhen } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const delayedClicks = clicks.pipe(\n *   delayWhen(event => interval(Math.random() * 5000)),\n * );\n * delayedClicks.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link delay}\n * @see {@link throttle}\n * @see {@link throttleTime}\n * @see {@link debounce}\n * @see {@link debounceTime}\n * @see {@link sample}\n * @see {@link sampleTime}\n * @see {@link audit}\n * @see {@link auditTime}\n *\n * @param {function(value: T, index: number): Observable} delayDurationSelector A function that\n * returns an Observable for each value emitted by the source Observable, which\n * is then used to delay the emission of that item on the output Observable\n * until the Observable returned from this function emits a value.\n * @param {Observable} subscriptionDelay An Observable that triggers the\n * subscription to the source Observable once it emits any value.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by an amount of time specified by the Observable returned by\n * `delayDurationSelector`.\n * @method delayWhen\n * @owner Observable\n */\nexport function delayWhen<T>(delayDurationSelector: (value: T, index: number) => Observable<any>,\n                             subscriptionDelay?: Observable<any>): MonoTypeOperatorFunction<T> {\n  if (subscriptionDelay) {\n    return (source: Observable<T>) =>\n      new SubscriptionDelayObservable(source, subscriptionDelay)\n        .lift(new DelayWhenOperator(delayDurationSelector));\n  }\n  return (source: Observable<T>) => source.lift(new DelayWhenOperator(delayDurationSelector));\n}\n\nclass DelayWhenOperator<T> implements Operator<T, T> {\n  constructor(private delayDurationSelector: (value: T, index: number) => Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DelayWhenSubscriber(subscriber, this.delayDurationSelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DelayWhenSubscriber<T, R> extends OuterSubscriber<T, R> {\n  private completed: boolean = false;\n  private delayNotifierSubscriptions: Array<Subscription> = [];\n  private index: number = 0;\n\n  constructor(destination: Subscriber<T>,\n              private delayDurationSelector: (value: T, index: number) => Observable<any>) {\n    super(destination);\n  }\n\n  notifyNext(outerValue: T, _innerValue: any,\n             _outerIndex: number, _innerIndex: number,\n             innerSub: InnerSubscriber<T, R>): void {\n    this.destination.next!(outerValue);\n    this.removeSubscription(innerSub);\n    this.tryComplete();\n  }\n\n  notifyError(error: any, innerSub: InnerSubscriber<T, R>): void {\n    this._error(error);\n  }\n\n  notifyComplete(innerSub: InnerSubscriber<T, R>): void {\n    const value = this.removeSubscription(innerSub);\n    if (value) {\n      this.destination.next!(value);\n    }\n    this.tryComplete();\n  }\n\n  protected _next(value: T): void {\n    const index = this.index++;\n    try {\n      const delayNotifier = this.delayDurationSelector(value, index);\n      if (delayNotifier) {\n        this.tryDelay(delayNotifier, value);\n      }\n    } catch (err) {\n      this.destination.error!(err);\n    }\n  }\n\n  protected _complete(): void {\n    this.completed = true;\n    this.tryComplete();\n    this.unsubscribe();\n  }\n\n  private removeSubscription(subscription: InnerSubscriber<T, R>): T {\n    subscription.unsubscribe();\n\n    const subscriptionIdx = this.delayNotifierSubscriptions.indexOf(subscription);\n    if (subscriptionIdx !== -1) {\n      this.delayNotifierSubscriptions.splice(subscriptionIdx, 1);\n    }\n\n    return subscription.outerValue;\n  }\n\n  private tryDelay(delayNotifier: Observable<any>, value: T): void {\n    const notifierSubscription = subscribeToResult(this, delayNotifier, value);\n\n    if (notifierSubscription && !notifierSubscription.closed) {\n      const destination = this.destination as Subscription;\n      destination.add(notifierSubscription);\n      this.delayNotifierSubscriptions.push(notifierSubscription);\n    }\n  }\n\n  private tryComplete(): void {\n    if (this.completed && this.delayNotifierSubscriptions.length === 0) {\n      this.destination.complete!();\n    }\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SubscriptionDelayObservable<T> extends Observable<T> {\n  constructor(public source: Observable<T>, private subscriptionDelay: Observable<any>) {\n    super();\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _subscribe(subscriber: Subscriber<T>) {\n    this.subscriptionDelay.subscribe(new SubscriptionDelaySubscriber(subscriber, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SubscriptionDelaySubscriber<T> extends Subscriber<T> {\n  private sourceSubscribed: boolean = false;\n\n  constructor(private parent: Subscriber<T>, private source: Observable<T>) {\n    super();\n  }\n\n  protected _next(unused: any) {\n    this.subscribeToSource();\n  }\n\n  protected _error(err: any) {\n    this.unsubscribe();\n    this.parent.error(err);\n  }\n\n  protected _complete() {\n    this.unsubscribe();\n    this.subscribeToSource();\n  }\n\n  private subscribeToSource(): void {\n    if (!this.sourceSubscribed) {\n      this.sourceSubscribed = true;\n      this.unsubscribe();\n      this.source.subscribe(this.parent);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Notification } from '../Notification';\nimport { OperatorFunction } from '../types';\n\n/**\n * Converts an Observable of {@link Notification} objects into the emissions\n * that they represent.\n *\n * <span class=\"informal\">Unwraps {@link Notification} objects as actual `next`,\n * `error` and `complete` emissions. The opposite of {@link materialize}.</span>\n *\n * ![](dematerialize.png)\n *\n * `dematerialize` is assumed to operate an Observable that only emits\n * {@link Notification} objects as `next` emissions, and does not emit any\n * `error`. Such Observable is the output of a `materialize` operation. Those\n * notifications are then unwrapped using the metadata they contain, and emitted\n * as `next`, `error`, and `complete` on the output Observable.\n *\n * Use this operator in conjunction with {@link materialize}.\n *\n * ## Example\n * Convert an Observable of Notifications to an actual Observable\n * ```ts\n * import { of, Notification } from 'rxjs';\n * import { dematerialize } from 'rxjs/operators';\n *\n * const notifA = new Notification('N', 'A');\n * const notifB = new Notification('N', 'B');\n * const notifE = new Notification('E', undefined,\n *   new TypeError('x.toUpperCase is not a function')\n * );\n * const materialized = of(notifA, notifB, notifE);\n * const upperCase = materialized.pipe(dematerialize());\n * upperCase.subscribe(x => console.log(x), e => console.error(e));\n *\n * // Results in:\n * // A\n * // B\n * // TypeError: x.toUpperCase is not a function\n * ```\n *\n * @see {@link Notification}\n * @see {@link materialize}\n *\n * @return {Observable} An Observable that emits items and notifications\n * embedded in Notification objects emitted by the source Observable.\n * @method dematerialize\n * @owner Observable\n */\nexport function dematerialize<T>(): OperatorFunction<Notification<T>, T> {\n  return function dematerializeOperatorFunction(source: Observable<Notification<T>>) {\n    return source.lift(new DeMaterializeOperator());\n  };\n}\n\nclass DeMaterializeOperator<T extends Notification<any>, R> implements Operator<T, R> {\n  call(subscriber: Subscriber<any>, source: any): any {\n    return source.subscribe(new DeMaterializeSubscriber(subscriber));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DeMaterializeSubscriber<T extends Notification<any>> extends Subscriber<T> {\n  constructor(destination: Subscriber<any>) {\n    super(destination);\n  }\n\n  protected _next(value: T) {\n    value.observe(this.destination);\n  }\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.\n *\n * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will\n * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the\n * source observable directly with an equality check against previous values.\n *\n * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.\n *\n * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the\n * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`\n * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so\n * that the internal `Set` can be \"flushed\", basically clearing it of values.\n *\n * ## Examples\n * A simple example with numbers\n * ```ts\n * import { of } from 'rxjs';\n * import { distinct } from 'rxjs/operators';\n *\n * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1).pipe(\n *     distinct(),\n *   )\n *   .subscribe(x => console.log(x)); // 1, 2, 3, 4\n * ```\n *\n * An example using a keySelector function\n * ```typescript\n * import { of } from 'rxjs';\n * import { distinct } from 'rxjs/operators';\n *\n * interface Person {\n *    age: number,\n *    name: string\n * }\n *\n * of<Person>(\n *     { age: 4, name: 'Foo'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo'},\n *   ).pipe(\n *     distinct((p: Person) => p.name),\n *   )\n *   .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Foo' }\n * // { age: 7, name: 'Bar' }\n * ```\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n *\n * @param {function} [keySelector] Optional function to select which value you want to check as distinct.\n * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.\n * @return {Observable} An Observable that emits items from the source Observable with distinct values.\n * @method distinct\n * @owner Observable\n */\nexport function distinct<T, K>(keySelector?: (value: T) => K,\n                               flushes?: Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new DistinctOperator(keySelector, flushes));\n}\n\nclass DistinctOperator<T, K> implements Operator<T, T> {\n  constructor(private keySelector?: (value: T) => K, private flushes?: Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DistinctSubscriber(subscriber, this.keySelector, this.flushes));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class DistinctSubscriber<T, K> extends SimpleOuterSubscriber<T, T> {\n  private values = new Set<K>();\n\n  constructor(destination: Subscriber<T>, private keySelector?: (value: T) => K, flushes?: Observable<any>) {\n    super(destination);\n\n    if (flushes) {\n      this.add(innerSubscribe(flushes, new SimpleInnerSubscriber(this)));\n    }\n  }\n\n  notifyNext(): void {\n    this.values.clear();\n  }\n\n  notifyError(error: any): void {\n    this._error(error);\n  }\n\n  protected _next(value: T): void {\n    if (this.keySelector) {\n      this._useKeySelector(value);\n    } else {\n      this._finalizeNext(value, value);\n    }\n  }\n\n  private _useKeySelector(value: T): void {\n    let key: K;\n    const { destination } = this;\n    try {\n      key = this.keySelector!(value);\n    } catch (err) {\n      destination.error!(err);\n      return;\n    }\n    this._finalizeNext(key, value);\n  }\n\n  private _finalizeNext(key: K|T, value: T) {\n    const { values } = this;\n    if (!values.has(<K>key)) {\n      values.add(<K>key);\n      this.destination.next!(value);\n    }\n  }\n\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean): MonoTypeOperatorFunction<T>;\nexport function distinctUntilChanged<T, K>(compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): MonoTypeOperatorFunction<T>;\n/* tslint:enable:max-line-length */\n\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\n * A simple example with numbers\n * ```ts\n * import { of } from 'rxjs';\n * import { distinctUntilChanged } from 'rxjs/operators';\n *\n * of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4).pipe(\n *     distinctUntilChanged(),\n *   )\n *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4\n * ```\n *\n * An example using a compare function\n * ```typescript\n * import { of } from 'rxjs';\n * import { distinctUntilChanged } from 'rxjs/operators';\n *\n * interface Person {\n *    age: number,\n *    name: string\n * }\n *\n * of<Person>(\n *     { age: 4, name: 'Foo'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo'},\n *     { age: 6, name: 'Foo'},\n *   ).pipe(\n *     distinctUntilChanged((p: Person, q: Person) => p.name === q.name),\n *   )\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 *\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 */\nexport function distinctUntilChanged<T, K>(compare?: (x: K, y: K) => boolean, keySelector?: (x: T) => K): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new DistinctUntilChangedOperator<T, K>(compare, keySelector));\n}\n\nclass DistinctUntilChangedOperator<T, K> implements Operator<T, T> {\n  constructor(private compare: (x: K, y: K) => boolean,\n              private keySelector: (x: T) => K) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass DistinctUntilChangedSubscriber<T, K> extends Subscriber<T> {\n  private key: K;\n  private hasKey: boolean = false;\n\n  constructor(destination: Subscriber<T>,\n              compare: (x: K, y: K) => boolean,\n              private keySelector: (x: T) => K) {\n    super(destination);\n    if (typeof compare === 'function') {\n      this.compare = compare;\n    }\n  }\n\n  private compare(x: any, y: any): boolean {\n    return x === y;\n  }\n\n  protected _next(value: T): void {\n    let key: any;\n    try {\n      const { keySelector } = this;\n      key = keySelector ? keySelector(value) : value;\n    } catch (err) {\n      return this.destination.error(err);\n    }\n    let result = false;\n    if (this.hasKey) {\n      try {\n        const { compare } = this;\n        result = compare(this.key, key);\n      } catch (err) {\n        return this.destination.error(err);\n      }\n    } else {\n      this.hasKey = true;\n    }\n    if (!result) {\n      this.key = key;\n      this.destination.next(value);\n    }\n  }\n}\n","import { distinctUntilChanged } from './distinctUntilChanged';\nimport { MonoTypeOperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function distinctUntilKeyChanged<T>(key: keyof T): MonoTypeOperatorFunction<T>;\nexport function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T>;\n/* tslint:enable:max-line-length */\n\n/**\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item,\n * using a property accessed by using the key provided to check if the two items are distinct.\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 * ## Examples\n * An example comparing the name of persons\n * ```typescript\n * import { of } from 'rxjs';\n * import { distinctUntilKeyChanged } from 'rxjs/operators';\n *\n *  interface Person {\n *     age: number,\n *     name: string\n *  }\n *\n * of<Person>(\n *     { age: 4, name: 'Foo'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo'},\n *     { age: 6, name: 'Foo'},\n *   ).pipe(\n *     distinctUntilKeyChanged('name'),\n *   )\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 *\n * An example comparing the first letters of the name\n * ```typescript\n * import { of } from 'rxjs';\n * import { distinctUntilKeyChanged } from 'rxjs/operators';\n *\n * interface Person {\n *     age: number,\n *     name: string\n *  }\n *\n * of<Person>(\n *     { age: 4, name: 'Foo1'},\n *     { age: 7, name: 'Bar'},\n *     { age: 5, name: 'Foo2'},\n *     { age: 6, name: 'Foo3'},\n *   ).pipe(\n *     distinctUntilKeyChanged('name', (x: string, y: string) => x.substring(0, 3) === y.substring(0, 3)),\n *   )\n *   .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Foo1' }\n * // { age: 7, name: 'Bar' }\n * // { age: 5, name: 'Foo2' }\n * ```\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n *\n * @param {string} key String key for object property lookup on each item.\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 based on the key specified.\n * @method distinctUntilKeyChanged\n * @owner Observable\n */\nexport function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare?: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T> {\n  return distinctUntilChanged((x: T, y: T) => compare ? compare(x[key], y[key]) : x[key] === y[key]);\n}\n","import { EmptyError } from '../util/EmptyError';\nimport { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { TeardownLogic, MonoTypeOperatorFunction } from '../types';\n\n/**\n * If the source observable completes without emitting a value, it will emit\n * an error. The error will be created at that time by the optional\n * `errorFactory` argument, otherwise, the error will be {@link EmptyError}.\n *\n * ![](throwIfEmpty.png)\n *\n * ## Example\n * ```ts\n * import { fromEvent, timer } from 'rxjs';\n * import { throwIfEmpty, takeUntil } from 'rxjs/operators';\n *\n * const click$ = fromEvent(document, 'click');\n *\n * click$.pipe(\n *   takeUntil(timer(1000)),\n *   throwIfEmpty(\n *     () => new Error('the document was not clicked within 1 second')\n *   ),\n * )\n * .subscribe({\n *   next() { console.log('The button was clicked'); },\n *   error(err) { console.error(err); }\n * });\n * ```\n *\n * @param errorFactory A factory function called to produce the\n * error to be thrown when the source observable completes without emitting a\n * value.\n */\nexport function throwIfEmpty <T>(errorFactory: (() => any) = defaultErrorFactory): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => {\n    return source.lift(new ThrowIfEmptyOperator(errorFactory));\n  };\n}\n\nclass ThrowIfEmptyOperator<T> implements Operator<T, T> {\n  constructor(private errorFactory: () => any) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new ThrowIfEmptySubscriber(subscriber, this.errorFactory));\n  }\n}\n\nclass ThrowIfEmptySubscriber<T> extends Subscriber<T> {\n  private hasValue: boolean = false;\n\n  constructor(destination: Subscriber<T>, private errorFactory: () => any) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    this.hasValue = true;\n    this.destination.next(value);\n  }\n\n  protected _complete() {\n    if (!this.hasValue) {\n      let err: any;\n      try {\n        err = this.errorFactory();\n      } catch (e) {\n        err = e;\n      }\n      this.destination.error(err);\n    } else {\n        return this.destination.complete();\n    }\n  }\n}\n\nfunction defaultErrorFactory() {\n  return new EmptyError();\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';\nimport { empty } from '../observable/empty';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\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 * ![](take.png)\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\n * Take the first 5 seconds of an infinite 1-second interval Observable\n * ```ts\n * import { interval } from 'rxjs';\n * import { take } from 'rxjs/operators';\n *\n * const intervalCount = interval(1000);\n * const takeFive = intervalCount.pipe(take(5));\n * takeFive.subscribe(x => console.log(x));\n *\n * // Logs:\n * // 0\n * // 1\n * // 2\n * // 3\n * // 4\n * ```\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 */\nexport function take<T>(count: number): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => {\n    if (count === 0) {\n      return empty();\n    } else {\n      return source.lift(new TakeOperator(count));\n    }\n  };\n}\n\nclass TakeOperator<T> implements Operator<T, T> {\n  constructor(private total: number) {\n    if (this.total < 0) {\n      throw new ArgumentOutOfRangeError;\n    }\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new TakeSubscriber(subscriber, this.total));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass TakeSubscriber<T> extends Subscriber<T> {\n  private count: number = 0;\n\n  constructor(destination: Subscriber<T>, private total: number) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const total = this.total;\n    const 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}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { filter } from './filter';\nimport { throwIfEmpty } from './throwIfEmpty';\nimport { defaultIfEmpty } from './defaultIfEmpty';\nimport { take } from './take';\n\n/**\n * Emits the single value at the specified `index` in a sequence of emissions\n * from the source Observable.\n *\n * <span class=\"informal\">Emits only the i-th value, then completes.</span>\n *\n * ![](elementAt.png)\n *\n * `elementAt` returns an Observable that emits the item at the specified\n * `index` in the source Observable, or a default value if that `index` is out\n * of range and the `default` argument is provided. If the `default` argument is\n * not given and the `index` is out of range, the output Observable will emit an\n * `ArgumentOutOfRangeError` error.\n *\n * ## Example\n * Emit only the third click event\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { elementAt } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(elementAt(2));\n * result.subscribe(x => console.log(x));\n *\n * // Results in:\n * // click 1 = nothing\n * // click 2 = nothing\n * // click 3 = MouseEvent object logged to console\n * ```\n *\n * @see {@link first}\n * @see {@link last}\n * @see {@link skip}\n * @see {@link single}\n * @see {@link take}\n *\n * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0` or the\n * Observable has completed before emitting the i-th `next` notification.\n *\n * @param {number} index Is the number `i` for the i-th source emission that has\n * happened since the subscription, starting from the number `0`.\n * @param {T} [defaultValue] The default value returned for missing indices.\n * @return {Observable} An Observable that emits a single item, if it is found.\n * Otherwise, will emit the default value if given. If not, then emits an error.\n * @method elementAt\n * @owner Observable\n */\nexport function elementAt<T>(index: number, defaultValue?: T): MonoTypeOperatorFunction<T> {\n  if (index < 0) { throw new ArgumentOutOfRangeError(); }\n  const hasDefaultValue = arguments.length >= 2;\n  return (source: Observable<T>) => source.pipe(\n    filter((v, i) => i === index),\n    take(1),\n    hasDefaultValue\n      ? defaultIfEmpty(defaultValue)\n      : throwIfEmpty(() => new ArgumentOutOfRangeError()),\n  );\n}\n","import { Observable } from '../Observable';\nimport { concat } from '../observable/concat';\nimport { of } from '../observable/of';\nimport { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A>(v1: A, scheduler: SchedulerLike): OperatorFunction<T, T | A>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A, B>(v1: A, v2: B, scheduler: SchedulerLike): OperatorFunction<T, T | A | B>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A, B, C>(v1: A, v2: B, v3: C, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A, B, C, D>(v1: A, v2: B, v3: C, v4: D, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A, B, C, D, E>(v1: A, v2: B, v3: C, v4: D, v5: E, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D | E>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, A, B, C, D, E, F>(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D | E | F>;\n\nexport function endWith<T, A>(v1: A): OperatorFunction<T, T | A>;\nexport function endWith<T, A, B>(v1: A, v2: B): OperatorFunction<T, T | A | B>;\nexport function endWith<T, A, B, C>(v1: A, v2: B, v3: C): OperatorFunction<T, T | A | B | C>;\nexport function endWith<T, A, B, C, D>(v1: A, v2: B, v3: C, v4: D): OperatorFunction<T, T | A | B | C | D>;\nexport function endWith<T, A, B, C, D, E>(v1: A, v2: B, v3: C, v4: D, v5: E): OperatorFunction<T, T | A | B | C | D | E>;\nexport function endWith<T, A, B, C, D, E, F>(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F): OperatorFunction<T, T | A | B | C | D | E | F>;\nexport function endWith<T, Z = T>(...array: Z[]): OperatorFunction<T, T | Z>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */\nexport function endWith<T, Z = T>(...array: Array<Z | SchedulerLike>): OperatorFunction<T, T | Z>;\n/* tslint:enable:max-line-length */\n\n/**\n * Returns an Observable that emits the items you specify as arguments after it finishes emitting\n * items emitted by the source Observable.\n *\n * ![](endWith.png)\n *\n * ## Example\n * ### After the source observable completes, appends an emission and then completes too.\n *\n * ```ts\n * import { of } from 'rxjs';\n * import { endWith } from 'rxjs/operators';\n *\n * of('hi', 'how are you?', 'sorry, I have to go now').pipe(\n *   endWith('goodbye!'),\n * )\n * .subscribe(word => console.log(word));\n * // result:\n * // 'hi'\n * // 'how are you?'\n * // 'sorry, I have to go now'\n * // 'goodbye!'\n * ```\n *\n * @param {...T} values - Items you want the modified Observable to emit last.\n * @param {SchedulerLike} [scheduler] - A {@link SchedulerLike} to use for scheduling\n * the emissions of the `next` notifications.\n * @return {Observable} An Observable that emits the items emitted by the source Observable\n *  and then emits the items in the specified Iterable.\n * @method endWith\n * @owner Observable\n */\nexport function endWith<T>(...array: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => concat(source, of(...array)) as Observable<T>;\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Observer, OperatorFunction } from '../types';\n\n/**\n * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.\n *\n * ## Example\n * A simple example emitting true if all elements are less than 5, false otherwise\n * ```ts\n * import { of } from 'rxjs';\n * import { every } from 'rxjs/operators';\n *\n *  of(1, 2, 3, 4, 5, 6).pipe(\n *     every(x => x < 5),\n * )\n * .subscribe(x => console.log(x)); // -> false\n * ```\n *\n * @param {function} predicate A function for determining if an item meets a specified condition.\n * @param {any} [thisArg] Optional object to use for `this` in the callback.\n * @return {Observable} An Observable of booleans that determines if all items of the source Observable meet the condition specified.\n * @method every\n * @owner Observable\n */\nexport function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean,\n                         thisArg?: any): OperatorFunction<T, boolean> {\n  return (source: Observable<T>) => source.lift(new EveryOperator(predicate, thisArg, source));\n}\n\nclass EveryOperator<T> implements Operator<T, boolean> {\n  constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,\n              private thisArg?: any,\n              private source?: Observable<T>) {\n  }\n\n  call(observer: Subscriber<boolean>, source: any): any {\n    return source.subscribe(new EverySubscriber(observer, this.predicate, this.thisArg, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass EverySubscriber<T> extends Subscriber<T> {\n  private index: number = 0;\n\n  constructor(destination: Observer<boolean>,\n              private predicate: (value: T, index: number, source: Observable<T>) => boolean,\n              private thisArg: any,\n              private source?: Observable<T>) {\n    super(destination);\n    this.thisArg = thisArg || this;\n  }\n\n  private notifyComplete(everyValueMatch: boolean): void {\n    this.destination.next(everyValueMatch);\n    this.destination.complete();\n  }\n\n  protected _next(value: T): void {\n    let result = false;\n    try {\n      result = this.predicate.call(this.thisArg, value, this.index++, this.source);\n    } catch (err) {\n      this.destination.error(err);\n      return;\n    }\n\n    if (!result) {\n      this.notifyComplete(false);\n    }\n  }\n\n  protected _complete(): void {\n    this.notifyComplete(true);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { ObservableInput, OperatorFunction, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\nexport function exhaust<T>(): OperatorFunction<ObservableInput<T>, T>;\nexport function exhaust<R>(): OperatorFunction<any, R>;\n\n/**\n * Converts a higher-order Observable into a first-order Observable by dropping\n * inner Observables while the previous inner Observable has not yet completed.\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables by dropping the\n * next inner Observables while the current inner is still executing.</span>\n *\n * ![](exhaust.png)\n *\n * `exhaust` subscribes to an Observable that emits Observables, also known as a\n * higher-order Observable. Each time it observes one of these emitted inner\n * Observables, the output Observable begins emitting the items emitted by that\n * inner Observable. So far, it behaves like {@link mergeAll}. However,\n * `exhaust` ignores every new inner Observable if the previous Observable has\n * not yet completed. Once that one completes, it will accept and flatten the\n * next inner Observable and repeat this process.\n *\n * ## Example\n * Run a finite timer for each click, only if there is no currently active timer\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { exhaust, map, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const higherOrder = clicks.pipe(\n *   map((ev) => interval(1000).pipe(take(5))),\n * );\n * const result = higherOrder.pipe(exhaust());\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link combineAll}\n * @see {@link concatAll}\n * @see {@link switchAll}\n * @see {@link switchMap}\n * @see {@link mergeAll}\n * @see {@link exhaustMap}\n * @see {@link zipAll}\n *\n * @return {Observable} An Observable that takes a source of Observables and propagates the first observable\n * exclusively until it completes before subscribing to the next.\n * @method exhaust\n * @owner Observable\n */\nexport function exhaust<T>(): OperatorFunction<any, T> {\n  return (source: Observable<T>) => source.lift(new SwitchFirstOperator<T>());\n}\n\nclass SwitchFirstOperator<T> implements Operator<T, T> {\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SwitchFirstSubscriber(subscriber));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SwitchFirstSubscriber<T> extends SimpleOuterSubscriber<T, T> {\n  private hasCompleted: boolean = false;\n  private hasSubscription: boolean = false;\n\n  constructor(destination: Subscriber<T>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    if (!this.hasSubscription) {\n      this.hasSubscription = true;\n      this.add(innerSubscribe(value, new SimpleInnerSubscriber(this)));\n    }\n  }\n\n  protected _complete(): void {\n    this.hasCompleted = true;\n    if (!this.hasSubscription) {\n      this.destination.complete!();\n    }\n  }\n\n  notifyComplete(): void {\n    this.hasSubscription = false;\n    if (this.hasCompleted) {\n      this.destination.complete!();\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\nimport { map } from './map';\nimport { from } from '../observable/from';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector is no longer supported. Use inner map instead. */\nexport function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector is no longer supported. Use inner map instead. */\nexport function exhaustMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable only if the previous projected Observable has completed.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link exhaust}.</span>\n *\n * ![](exhaustMap.png)\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. When it projects a source value to\n * an Observable, the output Observable begins emitting the items emitted by\n * that projected Observable. However, `exhaustMap` ignores every new projected\n * Observable if the previous projected Observable has not yet completed. Once\n * that one completes, it will accept and flatten the next projected Observable\n * and repeat this process.\n *\n * ## Example\n * Run a finite timer for each click, only if there is no currently active timer\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { exhaustMap, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   exhaustMap(ev => interval(1000).pipe(take(5)))\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link concatMap}\n * @see {@link exhaust}\n * @see {@link mergeMap}\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 * @return {Observable} An Observable containing projected Observables\n * of each item of the source, ignoring projected Observables that start before\n * their preceding Observable has completed.\n * @method exhaustMap\n * @owner Observable\n */\nexport function exhaustMap<T, R, O extends ObservableInput<any>>(\n  project: (value: T, index: number) => O,\n  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R,\n): OperatorFunction<T, ObservedValueOf<O>|R> {\n  if (resultSelector) {\n    // DEPRECATED PATH\n    return (source: Observable<T>) => source.pipe(\n      exhaustMap((a, i) => from(project(a, i)).pipe(\n        map((b: any, ii: any) => resultSelector(a, b, i, ii)),\n      )),\n    );\n  }\n  return (source: Observable<T>) =>\n    source.lift(new ExhaustMapOperator(project));\n}\n\nclass ExhaustMapOperator<T, R> implements Operator<T, R> {\n  constructor(private project: (value: T, index: number) => ObservableInput<R>) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new ExhaustMapSubscriber(subscriber, this.project));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass ExhaustMapSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private hasSubscription = false;\n  private hasCompleted = false;\n  private index = 0;\n\n  constructor(destination: Subscriber<R>,\n              private project: (value: T, index: number) => ObservableInput<R>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    if (!this.hasSubscription) {\n      this.tryNext(value);\n    }\n  }\n\n  private tryNext(value: T): void {\n    let result: ObservableInput<R>;\n    const index = this.index++;\n    try {\n      result = this.project(value, index);\n    } catch (err) {\n      this.destination.error!(err);\n      return;\n    }\n    this.hasSubscription = true;\n    this._innerSub(result);\n  }\n\n  private _innerSub(result: ObservableInput<R>): void {\n    const innerSubscriber = new SimpleInnerSubscriber(this);\n    const destination = this.destination as Subscription;\n    destination.add(innerSubscriber);\n    const innerSubscription = innerSubscribe(result, innerSubscriber);\n    // The returned subscription will usually be the subscriber that was\n    // passed. However, interop subscribers will be wrapped and for\n    // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n    if (innerSubscription !== innerSubscriber) {\n      destination.add(innerSubscription);\n    }\n  }\n\n  protected _complete(): void {\n    this.hasCompleted = true;\n    if (!this.hasSubscription) {\n      this.destination.complete!();\n    }\n    this.unsubscribe();\n  }\n\n  notifyNext(innerValue: R): void {\n    this.destination.next!(innerValue);\n  }\n\n  notifyError(err: any): void {\n    this.destination.error!(err);\n  }\n\n  notifyComplete(): void {\n    this.hasSubscription = false;\n    if (this.hasCompleted) {\n      this.destination.complete!();\n    }\n  }\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { MonoTypeOperatorFunction, OperatorFunction, ObservableInput, SchedulerLike } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function expand<T, R>(project: (value: T, index: number) => ObservableInput<R>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, R>;\nexport function expand<T>(project: (value: T, index: number) => ObservableInput<T>, concurrent?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\n/* tslint:enable:max-line-length */\n\n/**\n * Recursively projects each source value to an Observable which is merged in\n * the output Observable.\n *\n * <span class=\"informal\">It's similar to {@link mergeMap}, but applies the\n * projection function to every source value as well as every output value.\n * It's recursive.</span>\n *\n * ![](expand.png)\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. *Expand* will re-emit on the output\n * Observable every source value. Then, each output value is given to the\n * `project` function which returns an inner Observable to be merged on the\n * output Observable. Those output values resulting from the projection are also\n * given to the `project` function to produce new output values. This is how\n * *expand* behaves recursively.\n *\n * ## Example\n * Start emitting the powers of two on every click, at most 10 of them\n * ```ts\n * import { fromEvent, of } from 'rxjs';\n * import { expand, mapTo, delay, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const powersOfTwo = clicks.pipe(\n *   mapTo(1),\n *   expand(x => of(2 * x).pipe(delay(1000))),\n *   take(10),\n * );\n * powersOfTwo.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link mergeMap}\n * @see {@link mergeScan}\n *\n * @param {function(value: T, index: number) => Observable} project A function\n * that, when applied to an item emitted by the source or the output Observable,\n * returns an Observable.\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @param {SchedulerLike} [scheduler=null] The {@link SchedulerLike} to use for subscribing to\n * each projected inner Observable.\n * @return {Observable} An Observable that emits the source values and also\n * result of applying the projection function to each value emitted on the\n * output Observable and and merging the results of the Observables obtained\n * from this transformation.\n * @method expand\n * @owner Observable\n */\nexport function expand<T, R>(project: (value: T, index: number) => ObservableInput<R>,\n                             concurrent: number = Number.POSITIVE_INFINITY,\n                             scheduler?: SchedulerLike): OperatorFunction<T, R> {\n  concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent;\n\n  return (source: Observable<T>) => source.lift(new ExpandOperator(project, concurrent, scheduler));\n}\n\nexport class ExpandOperator<T, R> implements Operator<T, R> {\n  constructor(private project: (value: T, index: number) => ObservableInput<R>,\n              private concurrent: number,\n              private scheduler?: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler));\n  }\n}\n\ninterface DispatchArg<T, R> {\n  subscriber: ExpandSubscriber<T, R>;\n  result: ObservableInput<R>;\n  value: any;\n  index: number;\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class ExpandSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private index: number = 0;\n  private active: number = 0;\n  private hasCompleted: boolean = false;\n  private buffer?: any[];\n\n  constructor(destination: Subscriber<R>,\n              private project: (value: T, index: number) => ObservableInput<R>,\n              private concurrent: number,\n              private scheduler?: SchedulerLike) {\n    super(destination);\n    if (concurrent < Number.POSITIVE_INFINITY) {\n      this.buffer = [];\n    }\n  }\n\n  private static dispatch<T, R>(arg: DispatchArg<T, R>): void {\n    const {subscriber, result, value, index} = arg;\n    subscriber.subscribeToProjection(result, value, index);\n  }\n\n  protected _next(value: any): void {\n    const destination = this.destination;\n\n    if (destination.closed) {\n      this._complete();\n      return;\n    }\n\n    const index = this.index++;\n    if (this.active < this.concurrent) {\n      destination.next!(value);\n      try {\n        const { project } = this;\n        const result = project(value, index);\n        if (!this.scheduler) {\n          this.subscribeToProjection(result, value, index);\n        } else {\n          const state: DispatchArg<T, R> = { subscriber: this, result, value, index };\n          const destination = this.destination as Subscription;\n          destination.add(this.scheduler.schedule<DispatchArg<T, R>>(ExpandSubscriber.dispatch as any, 0, state));\n        }\n      } catch (e) {\n        destination.error!(e);\n      }\n    } else {\n      this.buffer!.push(value);\n    }\n  }\n\n  private subscribeToProjection(result: any, value: T, index: number): void {\n    this.active++;\n    const destination = this.destination as Subscription;\n    destination.add(innerSubscribe(result, new SimpleInnerSubscriber(this)));\n  }\n\n  protected _complete(): void {\n    this.hasCompleted = true;\n    if (this.hasCompleted && this.active === 0) {\n      this.destination.complete!();\n    }\n    this.unsubscribe();\n  }\n\n  notifyNext(innerValue: R): void {\n    this._next(innerValue);\n  }\n\n  notifyComplete(): void {\n    const buffer = this.buffer;\n    this.active--;\n    if (buffer && buffer.length > 0) {\n      this._next(buffer.shift());\n    }\n    if (this.hasCompleted && this.active === 0) {\n      this.destination.complete!();\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that mirrors the source Observable, but will call a specified function when\n * the source terminates on complete or error.\n * @param {function} callback Function to be called when source terminates.\n * @return {Observable} An Observable that mirrors the source, but will call the specified function on termination.\n * @method finally\n * @owner Observable\n */\nexport function finalize<T>(callback: () => void): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new FinallyOperator(callback));\n}\n\nclass FinallyOperator<T> implements Operator<T, T> {\n  constructor(private callback: () => void) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new FinallySubscriber(subscriber, this.callback));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass FinallySubscriber<T> extends Subscriber<T> {\n  constructor(destination: Subscriber<T>, callback: () => void) {\n    super(destination);\n    this.add(new Subscription(callback));\n  }\n}\n","import {Observable} from '../Observable';\nimport {Operator} from '../Operator';\nimport {Subscriber} from '../Subscriber';\nimport {OperatorFunction} from '../types';\n\nexport function find<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S,\n                                     thisArg?: any): OperatorFunction<T, S | undefined>;\nexport function find<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean,\n                        thisArg?: any): OperatorFunction<T, T | undefined>;\n/**\n * Emits only the first value emitted by the source Observable that meets some\n * condition.\n *\n * <span class=\"informal\">Finds the first value that passes some test and emits\n * that.</span>\n *\n * ![](find.png)\n *\n * `find` searches for the first item in the source Observable that matches the\n * specified condition embodied by the `predicate`, and returns the first\n * occurrence in the source. Unlike {@link first}, the `predicate` is required\n * in `find`, and does not emit an error if a valid value is not found.\n *\n * ## Example\n * Find and emit the first click that happens on a DIV element\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { find } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(find(ev => ev.target.tagName === 'DIV'));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link filter}\n * @see {@link first}\n * @see {@link findIndex}\n * @see {@link take}\n *\n * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate\n * A function called with each item to test for condition matching.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable<T>} An Observable of the first item that matches the\n * condition.\n * @method find\n * @owner Observable\n */\nexport function find<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean,\n                        thisArg?: any): OperatorFunction<T, T | undefined> {\n  if (typeof predicate !== 'function') {\n    throw new TypeError('predicate is not a function');\n  }\n  return (source: Observable<T>) => source.lift(new FindValueOperator(predicate, source, false, thisArg)) as Observable<T | undefined>;\n}\n\nexport class FindValueOperator<T> implements Operator<T, T | number | undefined> {\n  constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,\n              private source: Observable<T>,\n              private yieldIndex: boolean,\n              private thisArg?: any) {\n  }\n\n  call(observer: Subscriber<T>, source: any): any {\n    return source.subscribe(new FindValueSubscriber(observer, this.predicate, this.source, this.yieldIndex, this.thisArg));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class FindValueSubscriber<T> extends Subscriber<T> {\n  private index: number = 0;\n\n  constructor(destination: Subscriber<T>,\n              private predicate: (value: T, index: number, source: Observable<T>) => boolean,\n              private source: Observable<T>,\n              private yieldIndex: boolean,\n              private thisArg?: any) {\n    super(destination);\n  }\n\n  private notifyComplete(value: any): void {\n    const destination = this.destination;\n\n    destination.next(value);\n    destination.complete();\n    this.unsubscribe();\n  }\n\n  protected _next(value: T): void {\n    const {predicate, thisArg} = this;\n    const index = this.index++;\n    try {\n      const result = predicate.call(thisArg || this, value, index, this.source);\n      if (result) {\n        this.notifyComplete(this.yieldIndex ? index : value);\n      }\n    } catch (err) {\n      this.destination.error(err);\n    }\n  }\n\n  protected _complete(): void {\n    this.notifyComplete(this.yieldIndex ? -1 : undefined);\n  }\n}\n","import { Observable } from '../Observable';\nimport { FindValueOperator } from '../operators/find';\nimport { OperatorFunction } from '../types';\n/**\n * Emits only the index of the first value emitted by the source Observable that\n * meets some condition.\n *\n * <span class=\"informal\">It's like {@link find}, but emits the index of the\n * found value, not the value itself.</span>\n *\n * ![](findIndex.png)\n *\n * `findIndex` searches for the first item in the source Observable that matches\n * the specified condition embodied by the `predicate`, and returns the\n * (zero-based) index of the first occurrence in the source. Unlike\n * {@link first}, the `predicate` is required in `findIndex`, and does not emit\n * an error if a valid value is not found.\n *\n * ## Example\n * Emit the index of first click that happens on a DIV element\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { findIndex } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(findIndex(ev => ev.target.tagName === 'DIV'));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link filter}\n * @see {@link find}\n * @see {@link first}\n * @see {@link take}\n *\n * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate\n * A function called with each item to test for condition matching.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of the index of the first item that\n * matches the condition.\n * @method find\n * @owner Observable\n */\nexport function findIndex<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean,\n                             thisArg?: any): OperatorFunction<T, number> {\n  return (source: Observable<T>) => source.lift(new FindValueOperator(predicate, source, true, thisArg)) as Observable<any>;\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { EmptyError } from '../util/EmptyError';\nimport { OperatorFunction } from '../../internal/types';\nimport { filter } from './filter';\nimport { take } from './take';\nimport { defaultIfEmpty } from './defaultIfEmpty';\nimport { throwIfEmpty } from './throwIfEmpty';\nimport { identity } from '../util/identity';\n\n/* tslint:disable:max-line-length */\nexport function first<T, D = T>(\n  predicate?: null,\n  defaultValue?: D\n): OperatorFunction<T, T | D>;\nexport function first<T, S extends T>(\n  predicate: (value: T, index: number, source: Observable<T>) => value is S,\n  defaultValue?: S\n): OperatorFunction<T, S>;\nexport function first<T, D = T>(\n  predicate: (value: T, index: number, source: Observable<T>) => boolean,\n  defaultValue?: D\n): OperatorFunction<T, T | D>;\n/* tslint:enable:max-line-length */\n\n/**\n * Emits only the first value (or the first value that meets some condition)\n * emitted by the source Observable.\n *\n * <span class=\"informal\">Emits only the first value. Or emits only the first\n * value that passes some test.</span>\n *\n * ![](first.png)\n *\n * If called with no arguments, `first` emits the first value of the source\n * Observable, then completes. If called with a `predicate` function, `first`\n * emits the first value of the source that matches the specified condition. It\n * may also take a deprecated `resultSelector` function to produce the output\n * value from the input value, and a `defaultValue` to emit in case the source\n * completes before it is able to emit a valid value. Throws an error if\n * `defaultValue` was not provided and a matching element is not found.\n *\n * ## Examples\n * Emit only the first click that happens on the DOM\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { first } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(first());\n * result.subscribe(x => console.log(x));\n * ```\n *\n * Emits the first click that happens on a DIV\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { first } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(first(ev => ev.target.tagName === 'DIV'));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link filter}\n * @see {@link find}\n * @see {@link take}\n *\n * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`\n * callback if the Observable completes before any `next` notification was sent.\n *\n * @param {function(value: T, index: number, source: Observable<T>): boolean} [predicate]\n * An optional function called with each item to test for condition matching.\n * @param {R} [defaultValue] The default value emitted in case no valid value\n * was found on the source.\n * @return {Observable<T|R>} An Observable of the first item that matches the\n * condition.\n * @method first\n * @owner Observable\n */\nexport function first<T, D>(\n  predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null,\n  defaultValue?: D\n): OperatorFunction<T, T | D> {\n  const hasDefaultValue = arguments.length >= 2;\n  return (source: Observable<T>) => source.pipe(\n    predicate ? filter((v, i) => predicate(v, i, source)) : identity,\n    take(1),\n    hasDefaultValue ? defaultIfEmpty<T | D>(defaultValue) : throwIfEmpty(() => new EmptyError()),\n  );\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { OperatorFunction } from '../types';\n\n/**\n * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.\n *\n * ![](ignoreElements.png)\n *\n * ## Examples\n * ### Ignores emitted values, reacts to observable's completion.\n * ```ts\n * import { of } from 'rxjs';\n * import { ignoreElements } from 'rxjs/operators';\n *\n * of('you', 'talking', 'to', 'me').pipe(\n *   ignoreElements(),\n * )\n * .subscribe(\n *   word => console.log(word),\n *   err => console.log('error:', err),\n *   () => console.log('the end'),\n * );\n * // result:\n * // 'the end'\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 */\nexport function ignoreElements(): OperatorFunction<any, never> {\n  return function ignoreElementsOperatorFunction(source: Observable<any>) {\n    return source.lift(new IgnoreElementsOperator());\n  };\n}\n\nclass IgnoreElementsOperator<T, R> implements Operator<T, R> {\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new IgnoreElementsSubscriber(subscriber));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass IgnoreElementsSubscriber<T> extends Subscriber<T> {\n  protected _next(unused: T): void {\n    // Do nothing\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { OperatorFunction } from '../types';\n\n/**\n * Emits false if the input observable emits any values, or emits true if the\n * input observable completes without emitting any values.\n *\n * <span class=\"informal\">Tells whether any values are emitted by an observable</span>\n *\n * ![](isEmpty.png)\n *\n * `isEmpty` transforms an Observable that emits values into an Observable that\n * emits a single boolean value representing whether or not any values were\n * emitted by the source Observable. As soon as the source Observable emits a\n * value, `isEmpty` will emit a `false` and complete.  If the source Observable\n * completes having not emitted anything, `isEmpty` will emit a `true` and\n * complete.\n *\n * A similar effect could be achieved with {@link count}, but `isEmpty` can emit\n * a `false` value sooner.\n *\n * ## Examples\n *\n * Emit `false` for a non-empty Observable\n * ```javascript\n * import { Subject } from 'rxjs';\n * import { isEmpty } from 'rxjs/operators';\n *\n * const source = new Subject<string>();\n * const result = source.pipe(isEmpty());\n * source.subscribe(x => console.log(x));\n * result.subscribe(x => console.log(x));\n * source.next('a');\n * source.next('b');\n * source.next('c');\n * source.complete();\n *\n * // Results in:\n * // a\n * // false\n * // b\n * // c\n * ```\n *\n * Emit `true` for an empty Observable\n * ```javascript\n * import { EMPTY } from 'rxjs';\n * import { isEmpty } from 'rxjs/operators';\n *\n * const result = EMPTY.pipe(isEmpty());\n * result.subscribe(x => console.log(x));\n * // Results in:\n * // true\n * ```\n *\n * @see {@link count}\n * @see {@link EMPTY}\n *\n * @return {OperatorFunction<T, boolean>} An Observable of a boolean value indicating whether observable was empty or not\n * @method isEmpty\n * @owner Observable\n */\n\nexport function isEmpty<T>(): OperatorFunction<T, boolean> {\n  return (source: Observable<T>) => source.lift(new IsEmptyOperator());\n}\n\nclass IsEmptyOperator implements Operator<any, boolean> {\n  call (observer: Subscriber<boolean>, source: any): any {\n    return source.subscribe(new IsEmptySubscriber(observer));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass IsEmptySubscriber extends Subscriber<any> {\n  constructor(destination: Subscriber<boolean>) {\n    super(destination);\n  }\n\n  private notifyComplete(isEmpty: boolean): void {\n    const destination = this.destination;\n\n    destination.next(isEmpty);\n    destination.complete();\n  }\n\n  protected _next(value: boolean) {\n    this.notifyComplete(false);\n  }\n\n  protected _complete() {\n    this.notifyComplete(true);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';\nimport { empty } from '../observable/empty';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Emits only the last `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Remembers the latest `count` values, then emits those\n * only when the source completes.</span>\n *\n * ![](takeLast.png)\n *\n * `takeLast` returns an Observable that emits at most the last `count` values\n * emitted by the source Observable. If the source emits fewer than `count`\n * values then all of its values are emitted. This operator must wait until the\n * `complete` notification emission from the source in order to emit the `next`\n * values on the output Observable, because otherwise it is impossible to know\n * whether or not more values will be emitted on the source. For this reason,\n * all values are emitted synchronously, followed by the complete notification.\n *\n * ## Example\n * Take the last 3 values of an Observable with many values\n * ```ts\n * import { range } from 'rxjs';\n * import { takeLast } from 'rxjs/operators';\n *\n * const many = range(1, 100);\n * const lastThree = many.pipe(takeLast(3));\n * lastThree.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link take}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `takeLast(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of values to emit from the end of\n * the sequence of values emitted by the source Observable.\n * @return {Observable<T>} An Observable that emits at most the last count\n * values emitted by the source Observable.\n * @method takeLast\n * @owner Observable\n */\nexport function takeLast<T>(count: number): MonoTypeOperatorFunction<T> {\n  return function takeLastOperatorFunction(source: Observable<T>): Observable<T> {\n    if (count === 0) {\n      return empty();\n    } else {\n      return source.lift(new TakeLastOperator(count));\n    }\n  };\n}\n\nclass TakeLastOperator<T> implements Operator<T, T> {\n  constructor(private total: number) {\n    if (this.total < 0) {\n      throw new ArgumentOutOfRangeError;\n    }\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new TakeLastSubscriber(subscriber, this.total));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass TakeLastSubscriber<T> extends Subscriber<T> {\n  private ring: Array<T> = new Array();\n  private count: number = 0;\n\n  constructor(destination: Subscriber<T>, private total: number) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const ring = this.ring;\n    const total = this.total;\n    const count = this.count++;\n\n    if (ring.length < total) {\n      ring.push(value);\n    } else {\n      const index = count % total;\n      ring[index] = value;\n    }\n  }\n\n  protected _complete(): void {\n    const destination = this.destination;\n    let count = this.count;\n\n    if (count > 0) {\n      const total = this.count >= this.total ? this.total : this.count;\n      const ring  = this.ring;\n\n      for (let i = 0; i < total; i++) {\n        const idx = (count++) % total;\n        destination.next(ring[idx]);\n      }\n    }\n\n    destination.complete();\n  }\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { EmptyError } from '../util/EmptyError';\nimport { OperatorFunction } from '../../internal/types';\nimport { filter } from './filter';\nimport { takeLast } from './takeLast';\nimport { throwIfEmpty } from './throwIfEmpty';\nimport { defaultIfEmpty } from './defaultIfEmpty';\nimport { identity } from '../util/identity';\n\n/* tslint:disable:max-line-length */\nexport function last<T, D = T>(\n  predicate?: null,\n  defaultValue?: D\n): OperatorFunction<T, T | D>;\nexport function last<T, S extends T>(\n  predicate: (value: T, index: number, source: Observable<T>) => value is S,\n  defaultValue?: S\n): OperatorFunction<T, S>;\nexport function last<T, D = T>(\n  predicate: (value: T, index: number, source: Observable<T>) => boolean,\n  defaultValue?: D\n): OperatorFunction<T, T | D>;\n/* tslint:enable:max-line-length */\n\n/**\n * Returns an Observable that emits only the last item emitted by the source Observable.\n * It optionally takes a predicate function as a parameter, in which case, rather than emitting\n * the last item from the source Observable, the resulting Observable will emit the last item\n * from the source Observable that satisfies the predicate.\n *\n * ![](last.png)\n *\n * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`\n * callback if the Observable completes before any `next` notification was sent.\n * @param {function} [predicate] - The condition any source emitted item has to satisfy.\n * @param {any} [defaultValue] - An optional default value to provide if last\n * predicate isn't met or no values were emitted.\n * @return {Observable} An Observable that emits only the last item satisfying the given condition\n * from the source, or an NoSuchElementException if no such items are emitted.\n * @throws - Throws if no items that match the predicate are emitted by the source Observable.\n */\nexport function last<T, D>(\n  predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null,\n  defaultValue?: D\n): OperatorFunction<T, T | D> {\n  const hasDefaultValue = arguments.length >= 2;\n  return (source: Observable<T>) => source.pipe(\n    predicate ? filter((v, i) => predicate(v, i, source)) : identity,\n    takeLast(1),\n    hasDefaultValue ? defaultIfEmpty<T | D>(defaultValue) : throwIfEmpty(() => new EmptyError()),\n  );\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { OperatorFunction } from '../types';\n\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 * ![](mapTo.png)\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\n * Map every click to the string 'Hi'\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { mapTo } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const greetings = clicks.pipe(mapTo('Hi'));\n * greetings.subscribe(x => console.log(x));\n * ```\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 */\nexport function mapTo<T, R>(value: R): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift(new MapToOperator(value));\n}\n\nclass MapToOperator<T, R> implements Operator<T, R> {\n\n  value: R;\n\n  constructor(value: R) {\n    this.value = value;\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new MapToSubscriber(subscriber, this.value));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass MapToSubscriber<T, R> extends Subscriber<T> {\n\n  value: R;\n\n  constructor(destination: Subscriber<R>, value: R) {\n    super(destination);\n    this.value = value;\n  }\n\n  protected _next(x: T) {\n    this.destination.next(this.value);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Notification } from '../Notification';\nimport { OperatorFunction } from '../types';\n\n/**\n * Represents all of the notifications from the source Observable as `next`\n * emissions marked with their original types within {@link Notification}\n * objects.\n *\n * <span class=\"informal\">Wraps `next`, `error` and `complete` emissions in\n * {@link Notification} objects, emitted as `next` on the output Observable.\n * </span>\n *\n * ![](materialize.png)\n *\n * `materialize` returns an Observable that emits a `next` notification for each\n * `next`, `error`, or `complete` emission of the source Observable. When the\n * source Observable emits `complete`, the output Observable will emit `next` as\n * a Notification of type \"complete\", and then it will emit `complete` as well.\n * When the source Observable emits `error`, the output will emit `next` as a\n * Notification of type \"error\", and then `complete`.\n *\n * This operator is useful for producing metadata of the source Observable, to\n * be consumed as `next` emissions. Use it in conjunction with\n * {@link dematerialize}.\n *\n * ## Example\n * Convert a faulty Observable to an Observable of Notifications\n * ```ts\n * import { of } from 'rxjs';\n * import { materialize, map } from 'rxjs/operators';\n *\n * const letters = of('a', 'b', 13, 'd');\n * const upperCase = letters.pipe(map(x => x.toUpperCase()));\n * const materialized = upperCase.pipe(materialize());\n * materialized.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // - Notification {kind: \"N\", value: \"A\", error: undefined, hasValue: true}\n * // - Notification {kind: \"N\", value: \"B\", error: undefined, hasValue: true}\n * // - Notification {kind: \"E\", value: undefined, error: TypeError:\n * //   x.toUpperCase is not a function at MapSubscriber.letters.map.x\n * //   [as project] (http://1…, hasValue: false}\n * ```\n *\n * @see {@link Notification}\n * @see {@link dematerialize}\n *\n * @return {Observable<Notification<T>>} An Observable that emits\n * {@link Notification} objects that wrap the original emissions from the source\n * Observable with metadata.\n * @method materialize\n * @owner Observable\n */\nexport function materialize<T>(): OperatorFunction<T, Notification<T>> {\n  return function materializeOperatorFunction(source: Observable<T>) {\n    return source.lift(new MaterializeOperator());\n  };\n}\n\nclass MaterializeOperator<T> implements Operator<T, Notification<T>> {\n  call(subscriber: Subscriber<Notification<T>>, source: any): any {\n    return source.subscribe(new MaterializeSubscriber(subscriber));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass MaterializeSubscriber<T> extends Subscriber<T> {\n  constructor(destination: Subscriber<Notification<T>>) {\n    super(destination);\n  }\n\n  protected _next(value: T) {\n    this.destination.next(Notification.createNext(value));\n  }\n\n  protected _error(err: any) {\n    const destination = this.destination;\n    destination.next(Notification.createError(err));\n    destination.complete();\n  }\n\n  protected _complete() {\n    const destination = this.destination;\n    destination.next(Notification.createComplete());\n    destination.complete();\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { OperatorFunction, MonoTypeOperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function scan<T, R>(accumulator: (acc: R, value: T, index: number) => R, seed: R): OperatorFunction<T, R>;\nexport function scan<T>(accumulator: (acc: T, value: T, index: number) => T, seed?: T): MonoTypeOperatorFunction<T>;\nexport function scan<T, R>(accumulator: (acc: R, value: T, index: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Applies an accumulator function over the source Observable, and returns each\n * intermediate result, with an optional seed value.\n *\n * <span class=\"informal\">It's like {@link reduce}, but emits the current\n * accumulation whenever the source emits a value.</span>\n *\n * ![](scan.png)\n *\n * Combines together all values emitted on the source, using an accumulator\n * function that knows how to join a new source value into the accumulation from\n * the past. Is similar to {@link reduce}, but emits the intermediate\n * accumulations.\n *\n * Returns an Observable that applies a specified `accumulator` function to each\n * item emitted by the source Observable. If a `seed` value is specified, then\n * that value will be used as the initial value for the accumulator. If no seed\n * value is specified, the first item of the source is used as the seed.\n *\n * ## Example\n * Count the number of click events\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { scan, mapTo } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const ones = clicks.pipe(mapTo(1));\n * const seed = 0;\n * const count = ones.pipe(scan((acc, one) => acc + one, seed));\n * count.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link expand}\n * @see {@link mergeScan}\n * @see {@link reduce}\n *\n * @param {function(acc: R, value: T, index: number): R} accumulator\n * The accumulator function called on each source value.\n * @param {T|R} [seed] The initial accumulation value.\n * @return {Observable<R>} An observable of the accumulated values.\n * @method scan\n * @owner Observable\n */\nexport function scan<T, R>(accumulator: (acc: R, value: T, index: number) => R, seed?: T | R): OperatorFunction<T, R> {\n  let hasSeed = false;\n  // providing a seed of `undefined` *should* be valid and trigger\n  // hasSeed! so don't use `seed !== undefined` checks!\n  // For this reason, we have to check it here at the original call site\n  // otherwise inside Operator/Subscriber we won't know if `undefined`\n  // means they didn't provide anything or if they literally provided `undefined`\n  if (arguments.length >= 2) {\n    hasSeed = true;\n  }\n\n  return function scanOperatorFunction(source: Observable<T>): Observable<R> {\n    return source.lift(new ScanOperator(accumulator, seed, hasSeed));\n  };\n}\n\nclass ScanOperator<T, R> implements Operator<T, R> {\n  constructor(private accumulator: (acc: R, value: T, index: number) => R, private seed?: T | R, private hasSeed: boolean = false) {}\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new ScanSubscriber(subscriber, this.accumulator, this.seed, this.hasSeed));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass ScanSubscriber<T, R> extends Subscriber<T> {\n  private index: number = 0;\n\n  get seed(): T | R {\n    return this._seed;\n  }\n\n  set seed(value: T | R) {\n    this.hasSeed = true;\n    this._seed = value;\n  }\n\n  constructor(destination: Subscriber<R>, private accumulator: (acc: R, value: T, index: number) => R, private _seed: T | R,\n              private hasSeed: boolean) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    if (!this.hasSeed) {\n      this.seed = value;\n      this.destination.next(value);\n    } else {\n      return this._tryNext(value);\n    }\n  }\n\n  private _tryNext(value: T): void {\n    const index = this.index++;\n    let result: any;\n    try {\n      result = this.accumulator(<R>this.seed, value, index);\n    } catch (err) {\n      this.destination.error(err);\n    }\n    this.seed = result;\n    this.destination.next(result);\n  }\n}\n","import { Observable } from '../Observable';\nimport { scan } from './scan';\nimport { takeLast } from './takeLast';\nimport { defaultIfEmpty } from './defaultIfEmpty';\nimport { OperatorFunction, MonoTypeOperatorFunction } from '../types';\nimport { pipe } from '../util/pipe';\n\n/* tslint:disable:max-line-length */\nexport function reduce<T, R>(accumulator: (acc: R, value: T, index: number) => R, seed: R): OperatorFunction<T, R>;\nexport function reduce<T>(accumulator: (acc: T, value: T, index: number) => T, seed?: T): MonoTypeOperatorFunction<T>;\nexport function reduce<T, R>(accumulator: (acc: R, value: T, index: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Applies an accumulator function over the source Observable, and returns the\n * accumulated result when the source completes, given an optional seed value.\n *\n * <span class=\"informal\">Combines together all values emitted on the source,\n * using an accumulator function that knows how to join a new source value into\n * the accumulation from the past.</span>\n *\n * ![](reduce.png)\n *\n * Like\n * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),\n * `reduce` applies an `accumulator` function against an accumulation and each\n * value of the source Observable (from the past) to reduce it to a single\n * value, emitted on the output Observable. Note that `reduce` will only emit\n * one value, only when the source Observable completes. It is equivalent to\n * applying operator {@link scan} followed by operator {@link last}.\n *\n * Returns an Observable that applies a specified `accumulator` function to each\n * item emitted by the source Observable. If a `seed` value is specified, then\n * that value will be used as the initial value for the accumulator. If no seed\n * value is specified, the first item of the source is used as the seed.\n *\n * ## Example\n * Count the number of click events that happened in 5 seconds\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { reduce, takeUntil, mapTo } from 'rxjs/operators';\n *\n * const clicksInFiveSeconds = fromEvent(document, 'click').pipe(\n *   takeUntil(interval(5000)),\n * );\n * const ones = clicksInFiveSeconds.pipe(mapTo(1));\n * const seed = 0;\n * const count = ones.pipe(reduce((acc, one) => acc + one, seed));\n * count.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link count}\n * @see {@link expand}\n * @see {@link mergeScan}\n * @see {@link scan}\n *\n * @param {function(acc: R, value: T, index: number): R} accumulator The accumulator function\n * called on each source value.\n * @param {R} [seed] The initial accumulation value.\n * @return {Observable<R>} An Observable that emits a single value that is the\n * result of accumulating the values emitted by the source Observable.\n * @method reduce\n * @owner Observable\n */\nexport function reduce<T, R>(accumulator: (acc: T | R, value: T, index?: number) => T | R, seed?: T | R): OperatorFunction<T, T | R> {\n  // providing a seed of `undefined` *should* be valid and trigger\n  // hasSeed! so don't use `seed !== undefined` checks!\n  // For this reason, we have to check it here at the original call site\n  // otherwise inside Operator/Subscriber we won't know if `undefined`\n  // means they didn't provide anything or if they literally provided `undefined`\n  if (arguments.length >= 2) {\n    return function reduceOperatorFunctionWithSeed(source: Observable<T>): Observable<T | R> {\n      return pipe(scan(accumulator, seed), takeLast(1), defaultIfEmpty(seed))(source);\n    };\n  }\n  return function reduceOperatorFunction(source: Observable<T>): Observable<T | R> {\n    return pipe(\n      scan<T, T | R>((acc, value, index) => accumulator(acc, value, index + 1)),\n      takeLast(1),\n    )(source);\n  };\n}\n","import { reduce } from './reduce';\nimport { MonoTypeOperatorFunction } from '../types';\n\n/**\n * The Max operator operates on an Observable that emits numbers (or items that can be compared with a provided function),\n * and when source Observable completes it emits a single item: the item with the largest value.\n *\n * ![](max.png)\n *\n * ## Examples\n * Get the maximal value of a series of numbers\n * ```ts\n * import { of } from 'rxjs';\n * import { max } from 'rxjs/operators';\n *\n * of(5, 4, 7, 2, 8).pipe(\n *   max(),\n * )\n * .subscribe(x => console.log(x)); // -> 8\n * ```\n *\n * Use a comparer function to get the maximal item\n * ```typescript\n * import { of } from 'rxjs';\n * import { max } from 'rxjs/operators';\n *\n * interface Person {\n *   age: number,\n *   name: string\n * }\n * of<Person>(\n *   {age: 7, name: 'Foo'},\n *   {age: 5, name: 'Bar'},\n *   {age: 9, name: 'Beer'},\n * ).pipe(\n *   max<Person>((a: Person, b: Person) => a.age < b.age ? -1 : 1),\n * )\n * .subscribe((x: Person) => console.log(x.name)); // -> 'Beer'\n * ```\n *\n * @see {@link min}\n *\n * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the\n * value of two items.\n * @return {Observable} An Observable that emits item with the largest value.\n * @method max\n * @owner Observable\n */\nexport function max<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {\n  const max: (x: T, y: T) => T = (typeof comparer === 'function')\n    ? (x, y) => comparer(x, y) > 0 ? x : y\n    : (x, y) => x > y ? x : y;\n\n  return reduce(max);\n}\n","import { merge as mergeStatic } from '../observable/merge';\nimport { Observable } from '../Observable';\nimport { ObservableInput, OperatorFunction, MonoTypeOperatorFunction, SchedulerLike } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T>(scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T>(concurrent?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2>(v2: ObservableInput<T2>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2>(v2: ObservableInput<T2>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, T | T2>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T>(...observables: Array<ObservableInput<T> | SchedulerLike | number>): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static merge. */\nexport function merge<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike | number>): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * @deprecated Deprecated in favor of static {@link merge}.\n */\nexport function merge<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike | number>): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift.call(mergeStatic(source, ...observables));\n}\n","import { Observable } from '../Observable';\nimport { OperatorFunction, ObservedValueOf } from '../../internal/types';\nimport { mergeMap } from './mergeMap';\nimport { ObservableInput } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function mergeMapTo<T, O extends ObservableInput<any>>(innerObservable: O, concurrent?: number): OperatorFunction<any, ObservedValueOf<O>>;\n/** @deprecated */\nexport function mergeMapTo<T, R, O extends ObservableInput<any>>(innerObservable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, concurrent?: number): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Projects each source value to the same Observable which is merged multiple\n * times in the output Observable.\n *\n * <span class=\"informal\">It's like {@link mergeMap}, but maps each value always\n * to the same inner Observable.</span>\n *\n * ![](mergeMapTo.png)\n *\n * Maps each source value to the given Observable `innerObservable` regardless\n * of the source value, and then merges those resulting Observables into one\n * single Observable, which is the output Observable.\n *\n * ## Example\n * For each click event, start an interval Observable ticking every 1 second\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { mergeMapTo } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(mergeMapTo(interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link concatMapTo}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMap}\n * @see {@link mergeScan}\n * @see {@link switchMapTo}\n *\n * @param {ObservableInput} innerObservable An Observable to replace each value from\n * the source 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 items from the given\n * `innerObservable`\n * @method mergeMapTo\n * @owner Observable\n */\nexport function mergeMapTo<T, R, O extends ObservableInput<any>>(\n  innerObservable: O,\n  resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number,\n  concurrent: number = Number.POSITIVE_INFINITY\n): OperatorFunction<T, ObservedValueOf<O>|R> {\n  if (typeof resultSelector === 'function') {\n    return mergeMap(() => innerObservable, resultSelector, concurrent);\n  }\n  if (typeof resultSelector === 'number') {\n    concurrent = resultSelector;\n  }\n  return mergeMap(() => innerObservable, concurrent);\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { ObservableInput, OperatorFunction } from '../types';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/**\n * Applies an accumulator function over the source Observable where the\n * accumulator function itself returns an Observable, then each intermediate\n * Observable returned is merged into the output Observable.\n *\n * <span class=\"informal\">It's like {@link scan}, but the Observables returned\n * by the accumulator are merged into the outer Observable.</span>\n *\n * ## Example\n * Count the number of click events\n * ```ts\n * import { fromEvent, of } from 'rxjs';\n * import { mapTo, mergeScan } from 'rxjs/operators';\n *\n * const click$ = fromEvent(document, 'click');\n * const one$ = click$.pipe(mapTo(1));\n * const seed = 0;\n * const count$ = one$.pipe(\n *   mergeScan((acc, one) => of(acc + one), seed),\n * );\n * count$.subscribe(x => console.log(x));\n *\n * // Results:\n * // 1\n * // 2\n * // 3\n * // 4\n * // ...and so on for each click\n * ```\n *\n * @param {function(acc: R, value: T): Observable<R>} accumulator\n * The accumulator function called on each source value.\n * @param seed The initial accumulation value.\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of\n * input Observables being subscribed to concurrently.\n * @return {Observable<R>} An observable of the accumulated values.\n * @method mergeScan\n * @owner Observable\n */\nexport function mergeScan<T, R>(accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,\n                                seed: R,\n                                concurrent: number = Number.POSITIVE_INFINITY): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift(new MergeScanOperator(accumulator, seed, concurrent));\n}\n\nexport class MergeScanOperator<T, R> implements Operator<T, R> {\n  constructor(private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,\n              private seed: R,\n              private concurrent: number) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new MergeScanSubscriber(\n      subscriber, this.accumulator, this.seed, this.concurrent\n    ));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class MergeScanSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private hasValue: boolean = false;\n  private hasCompleted: boolean = false;\n  private buffer: Observable<any>[] = [];\n  private active: number = 0;\n  protected index: number = 0;\n\n  constructor(destination: Subscriber<R>,\n              private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,\n              private acc: R,\n              private concurrent: number) {\n    super(destination);\n  }\n\n  protected _next(value: any): void {\n    if (this.active < this.concurrent) {\n      const index = this.index++;\n      const destination = this.destination;\n      let ish;\n      try {\n        const { accumulator } = this;\n        ish = accumulator(this.acc, value, index);\n      } catch (e) {\n        return destination.error!(e);\n      }\n      this.active++;\n      this._innerSub(ish);\n    } else {\n      this.buffer.push(value);\n    }\n  }\n\n  private _innerSub(ish: any): void {\n    const innerSubscriber = new SimpleInnerSubscriber(this);\n    const destination = this.destination as Subscription;\n    destination.add(innerSubscriber);\n    const innerSubscription = innerSubscribe(ish, innerSubscriber);\n    // The returned subscription will usually be the subscriber that was\n    // passed. However, interop subscribers will be wrapped and for\n    // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n    if (innerSubscription !== innerSubscriber) {\n      destination.add(innerSubscription);\n    }\n  }\n\n  protected _complete(): void {\n    this.hasCompleted = true;\n    if (this.active === 0 && this.buffer.length === 0) {\n      if (this.hasValue === false) {\n        this.destination.next!(this.acc);\n      }\n      this.destination.complete!();\n    }\n    this.unsubscribe();\n  }\n\n  notifyNext(innerValue: R): void {\n    const { destination } = this;\n    this.acc = innerValue;\n    this.hasValue = true;\n    destination.next!(innerValue);\n  }\n\n  notifyComplete(): void {\n    const buffer = this.buffer;\n    this.active--;\n    if (buffer.length > 0) {\n      this._next(buffer.shift());\n    } else if (this.active === 0 && this.hasCompleted) {\n      if (this.hasValue === false) {\n        this.destination.next!(this.acc);\n      }\n      this.destination.complete!();\n    }\n  }\n}\n","import { reduce } from './reduce';\nimport { MonoTypeOperatorFunction } from '../types';\n\n/**\n * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),\n * and when source Observable completes it emits a single item: the item with the smallest value.\n *\n * ![](min.png)\n *\n * ## Examples\n * Get the minimal value of a series of numbers\n * ```ts\n * import { of } from 'rxjs';\n * import { min } from 'rxjs/operators';\n *\n * of(5, 4, 7, 2, 8).pipe(\n *   min(),\n * )\n * .subscribe(x => console.log(x)); // -> 2\n * ```\n *\n * Use a comparer function to get the minimal item\n * ```typescript\n * import { of } from 'rxjs';\n * import { min } from 'rxjs/operators';\n *\n * interface Person {\n *   age: number,\n *   name: string\n * }\n * of<Person>(\n *   {age: 7, name: 'Foo'},\n *   {age: 5, name: 'Bar'},\n *   {age: 9, name: 'Beer'},\n * ).pipe(\n *   min<Person>( (a: Person, b: Person) => a.age < b.age ? -1 : 1),\n * )\n * .subscribe((x: Person) => console.log(x.name)); // -> 'Bar'\n * ```\n * @see {@link max}\n *\n * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the\n * value of two items.\n * @return {Observable<R>} An Observable that emits item with the smallest value.\n * @method min\n * @owner Observable\n */\nexport function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {\n  const min: (x: T, y: T) => T = (typeof comparer === 'function')\n    ? (x, y) => comparer(x, y) < 0 ? x : y\n    : (x, y) => x < y ? x : y;\n  return reduce(min);\n}\n","import { Subject } from '../Subject';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { ConnectableObservable, connectableObservableDescriptor } from '../observable/ConnectableObservable';\nimport { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;\nexport function multicast<T, O extends ObservableInput<any>>(subject: Subject<T>, selector: (shared: Observable<T>) => O): UnaryFunction<Observable<T>, ConnectableObservable<ObservedValueOf<O>>>;\nexport function multicast<T>(subjectFactory: (this: Observable<T>) => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;\nexport function multicast<T, O extends ObservableInput<any>>(SubjectFactory: (this: Observable<T>) => Subject<T>, selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;\n/* tslint:enable:max-line-length */\n\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 * ![](multicast.png)\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 */\nexport function multicast<T, R>(subjectOrSubjectFactory: Subject<T> | (() => Subject<T>),\n                                selector?: (source: Observable<T>) => Observable<R>): OperatorFunction<T, R> {\n  return function multicastOperatorFunction(source: Observable<T>): Observable<R> {\n    let subjectFactory: () => Subject<T>;\n    if (typeof subjectOrSubjectFactory === 'function') {\n      subjectFactory = <() => Subject<T>>subjectOrSubjectFactory;\n    } else {\n      subjectFactory = function subjectFactory() {\n        return <Subject<T>>subjectOrSubjectFactory;\n      };\n    }\n\n    if (typeof selector === 'function') {\n      return source.lift(new MulticastOperator(subjectFactory, selector));\n    }\n\n    const connectable: any = Object.create(source, connectableObservableDescriptor);\n    connectable.source = source;\n    connectable.subjectFactory = subjectFactory;\n\n    return <ConnectableObservable<R>> connectable;\n  };\n}\n\nexport class MulticastOperator<T, R> implements Operator<T, R> {\n  constructor(private subjectFactory: () => Subject<T>,\n              private selector: (source: Observable<T>) => Observable<R>) {\n  }\n  call(subscriber: Subscriber<R>, source: any): any {\n    const { selector } = this;\n    const subject = this.subjectFactory();\n    const subscription = selector(subject).subscribe(subscriber);\n    subscription.add(source.subscribe(subject));\n    return subscription;\n  }\n}\n","import { Observable } from '../Observable';\nimport { from } from '../observable/from';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { isArray } from '../util/isArray';\nimport { ObservableInput, OperatorFunction } from '../types';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function onErrorResumeNext<T>(): OperatorFunction<T, T>;\nexport function onErrorResumeNext<T, T2>(v: ObservableInput<T2>): OperatorFunction<T, T | T2>;\nexport function onErrorResumeNext<T, T2, T3>(v: ObservableInput<T2>, v2: ObservableInput<T3>): OperatorFunction<T, T | T2 | T3>;\nexport function onErrorResumeNext<T, T2, T3, T4>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>): OperatorFunction<T, T | T2 | T3 | T4>;\nexport function onErrorResumeNext<T, T2, T3, T4, T5>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>): OperatorFunction<T, T | T2 | T3 | T4 | T5>;\nexport function onErrorResumeNext<T, T2, T3, T4, T5, T6>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>, v5: ObservableInput<T6>): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;\nexport function onErrorResumeNext<T, T2, T3, T4, T5, T6, T7>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>, v5: ObservableInput<T6>, v6: ObservableInput<T7>): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6 | T7>;\nexport function onErrorResumeNext<T, R>(...observables: Array<ObservableInput<any>>): OperatorFunction<T, T | R>;\nexport function onErrorResumeNext<T, R>(array: ObservableInput<any>[]): OperatorFunction<T, T | R>;\n/* tslint:enable:max-line-length */\n\n/**\n * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one\n * that was passed.\n *\n * <span class=\"informal\">Execute series of Observables no matter what, even if it means swallowing errors.</span>\n *\n * ![](onErrorResumeNext.png)\n *\n * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as\n * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same\n * as the source.\n *\n * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.\n * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`\n * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting\n * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another\n * Observable in provided series, no matter if previous Observable completed or ended with an error. This will\n * be happening until there is no more Observables left in the series, at which point returned Observable will\n * complete - even if the last subscribed stream ended with an error.\n *\n * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive\n * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable\n * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with\n * an error.\n *\n * Note that you do not get any access to errors emitted by the Observables. In particular do not\n * expect these errors to appear in error callback passed to {@link Observable#subscribe}. If you want to take\n * specific actions based on what error was emitted by an Observable, you should try out {@link catchError} instead.\n *\n *\n * ## Example\n * Subscribe to the next Observable after map fails\n * ```ts\n * import { of } from 'rxjs';\n * import { onErrorResumeNext, map } from 'rxjs/operators';\n *\n * of(1, 2, 3, 0).pipe(\n *   map(x => {\n *       if (x === 0) { throw Error(); }\n *        return 10 / x;\n *   }),\n *   onErrorResumeNext(of(1, 2, 3)),\n * )\n * .subscribe(\n *   val => console.log(val),\n *   err => console.log(err),          // Will never be called.\n *   () => console.log('that\\'s it!')\n * );\n *\n * // Logs:\n * // 10\n * // 5\n * // 3.3333333333333335\n * // 1\n * // 2\n * // 3\n * // \"that's it!\"\n * ```\n *\n * @see {@link concat}\n * @see {@link catchError}\n *\n * @param {...ObservableInput} observables Observables passed either directly or as an array.\n * @return {Observable} An Observable that emits values from source Observable, but - if it errors - subscribes\n * to the next passed Observable and so on, until it completes or runs out of Observables.\n * @method onErrorResumeNext\n * @owner Observable\n */\n\nexport function onErrorResumeNext<T, R>(...nextSources: Array<ObservableInput<any> |\n                                                       Array<ObservableInput<any>>>): OperatorFunction<T, R> {\n  if (nextSources.length === 1 && isArray(nextSources[0])) {\n    nextSources = <Array<Observable<any>>>nextSources[0];\n  }\n\n  return (source: Observable<T>) => source.lift(new OnErrorResumeNextOperator<T, R>(nextSources));\n}\n\n/* tslint:disable:max-line-length */\nexport function onErrorResumeNextStatic<R>(v: ObservableInput<R>): Observable<R>;\nexport function onErrorResumeNextStatic<T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<R>;\nexport function onErrorResumeNextStatic<T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<R>;\nexport function onErrorResumeNextStatic<T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<R>;\nexport function onErrorResumeNextStatic<T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<R>;\n\nexport function onErrorResumeNextStatic<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;\nexport function onErrorResumeNextStatic<R>(array: ObservableInput<any>[]): Observable<R>;\n/* tslint:enable:max-line-length */\n\nexport function onErrorResumeNextStatic<T, R>(...nextSources: Array<ObservableInput<any> |\n  Array<ObservableInput<any>> |\n  ((...values: Array<any>) => R)>): Observable<R> {\n  let source: ObservableInput<any>|undefined = undefined;\n\n  if (nextSources.length === 1 && isArray(nextSources[0])) {\n    nextSources = nextSources[0] as ObservableInput<any>[];\n  }\n  // TODO: resolve issue with passing no arguments.\n  source = nextSources.shift()!;\n\n  return from(source).lift(new OnErrorResumeNextOperator<T, R>(nextSources));\n}\n\nclass OnErrorResumeNextOperator<T, R> implements Operator<T, R> {\n  constructor(private nextSources: Array<ObservableInput<any>>) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new OnErrorResumeNextSubscriber(subscriber, this.nextSources));\n  }\n}\n\nclass OnErrorResumeNextSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  constructor(protected destination: Subscriber<T>,\n              private nextSources: Array<ObservableInput<any>>) {\n    super(destination);\n  }\n\n  notifyError(): void {\n    this.subscribeToNextSource();\n  }\n\n  notifyComplete(): void {\n    this.subscribeToNextSource();\n  }\n\n  protected _error(err: any): void {\n    this.subscribeToNextSource();\n    this.unsubscribe();\n  }\n\n  protected _complete(): void {\n    this.subscribeToNextSource();\n    this.unsubscribe();\n  }\n\n  private subscribeToNextSource(): void {\n    const next = this.nextSources.shift();\n    if (!!next) {\n      const innerSubscriber = new SimpleInnerSubscriber(this);\n      const destination = this.destination as Subscription;\n      destination.add(innerSubscriber);\n      const innerSubscription = innerSubscribe(next, innerSubscriber);\n      // The returned subscription will usually be the subscriber that was\n      // passed. However, interop subscribers will be wrapped and for\n      // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n      if (innerSubscription !== innerSubscriber) {\n        destination.add(innerSubscription);\n      }\n    } else {\n      this.destination.complete();\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { OperatorFunction } from '../types';\n\n/**\n * Groups pairs of consecutive emissions together and emits them as an array of\n * two values.\n *\n * <span class=\"informal\">Puts the current value and previous value together as\n * an array, and emits that.</span>\n *\n * ![](pairwise.png)\n *\n * The Nth emission from the source Observable will cause the output Observable\n * to emit an array [(N-1)th, Nth] of the previous and the current value, as a\n * pair. For this reason, `pairwise` emits on the second and subsequent\n * emissions from the source Observable, but not on the first emission, because\n * there is no previous value in that case.\n *\n * ## Example\n * On every click (starting from the second), emit the relative distance to the previous click\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { pairwise, map } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const pairs = clicks.pipe(pairwise());\n * const distance = pairs.pipe(\n *   map(pair => {\n *     const x0 = pair[0].clientX;\n *     const y0 = pair[0].clientY;\n *     const x1 = pair[1].clientX;\n *     const y1 = pair[1].clientY;\n *     return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));\n *   }),\n * );\n * distance.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link buffer}\n * @see {@link bufferCount}\n *\n * @return {Observable<Array<T>>} An Observable of pairs (as arrays) of\n * consecutive values from the source Observable.\n * @method pairwise\n * @owner Observable\n */\nexport function pairwise<T>(): OperatorFunction<T, [T, T]> {\n  return (source: Observable<T>) => source.lift(new PairwiseOperator());\n}\n\nclass PairwiseOperator<T> implements Operator<T, [T, T]> {\n  call(subscriber: Subscriber<[T, T]>, source: any): any {\n    return source.subscribe(new PairwiseSubscriber(subscriber));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass PairwiseSubscriber<T> extends Subscriber<T> {\n  private prev: T;\n  private hasPrev: boolean = false;\n\n  constructor(destination: Subscriber<[T, T]>) {\n    super(destination);\n  }\n\n  _next(value: T): void {\n    let pair: [T, T] | undefined;\n\n    if (this.hasPrev) {\n      pair = [this.prev, value];\n    } else {\n      this.hasPrev = true;\n    }\n\n    this.prev = value;\n\n    if (pair) {\n      this.destination.next(pair);\n    }\n  }\n}\n","import { not } from '../util/not';\nimport { filter } from './filter';\nimport { Observable } from '../Observable';\nimport { UnaryFunction } from '../types';\n\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 * ![](partition.png)\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\n * Partition click events into those on DIV elements and those elsewhere\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { partition } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const parts = clicks.pipe(partition(ev => ev.target.tagName === 'DIV'));\n * const clicksOnDivs = parts[0];\n * const clicksElsewhere = parts[1];\n * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));\n * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));\n * ```\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 * @deprecated use `partition` static creation function instead\n */\nexport function partition<T>(predicate: (value: T, index: number) => boolean,\n                             thisArg?: any): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> {\n  return (source: Observable<T>) => [\n    filter(predicate, thisArg)(source),\n    filter(not(predicate, thisArg) as any)(source)\n  ] as [Observable<T>, Observable<T>];\n}\n","import { Observable } from '../Observable';\nimport { map } from './map';\nimport { OperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;\nexport function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;\nexport function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(k1: K1, k2: K2, k3: K3): OperatorFunction<T, T[K1][K2][K3]>;\nexport function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(k1: K1, k2: K2, k3: K3, k4: K4): OperatorFunction<T, T[K1][K2][K3][K4]>;\nexport function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;\nexport function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;\nexport function pluck<T, R>(...properties: string[]): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\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 * ![](pluck.png)\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\n * Map every click to the tagName of the clicked target element\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { pluck } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const tagNames = clicks.pipe(pluck('target', 'tagName'));\n * tagNames.subscribe(x => console.log(x));\n * ```\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 */\nexport function pluck<T, R>(...properties: string[]): OperatorFunction<T, R> {\n  const length = properties.length;\n  if (length === 0) {\n    throw new Error('list of properties cannot be empty.');\n  }\n  return (source: Observable<T>) => map(plucker(properties, length))(source as any);\n}\n\nfunction plucker(props: string[], length: number): (x: string) => any {\n  const mapper = (x: string) => {\n    let currentProp = x;\n    for (let i = 0; i < length; i++) {\n      const p = currentProp != null ? currentProp[props[i]] : undefined;\n      if (p !== void 0) {\n        currentProp = p;\n      } else {\n        return undefined;\n      }\n    }\n    return currentProp;\n  };\n\n  return mapper;\n}\n","import { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { multicast } from './multicast';\nimport { ConnectableObservable } from '../observable/ConnectableObservable';\nimport { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;\nexport function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;\nexport function publish<T>(selector: MonoTypeOperatorFunction<T>): MonoTypeOperatorFunction<T>;\n/* tslint:enable:max-line-length */\n\n/**\n * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called\n * before it begins emitting items to those Observers that have subscribed to it.\n *\n * <span class=\"informal\">Makes a cold Observable hot</span>\n *\n * ![](publish.png)\n *\n * ## Examples\n * Make source$ hot by applying publish operator, then merge each inner observable into a single one\n * and subscribe.\n * ```ts\n * import { of, zip, interval, merge } from \"rxjs\";\n * import { map, publish, tap } from \"rxjs/operators\";\n *\n * const source$ = zip(interval(2000), of(1, 2, 3, 4, 5, 6, 7, 8, 9)).pipe(\n *   map(values => values[1])\n * );\n *\n * source$\n *   .pipe(\n *     publish(multicasted$ =>\n *       merge(\n *         multicasted$.pipe(tap(x => console.log('Stream 1:', x))),\n *         multicasted$.pipe(tap(x => console.log('Stream 2:', x))),\n *         multicasted$.pipe(tap(x => console.log('Stream 3:', x))),\n *       )\n *     )\n *   )\n *   .subscribe();\n *\n * // Results every two seconds\n * // Stream 1: 1\n * // Stream 2: 1\n * // Stream 3: 1\n * // ...\n * // Stream 1: 9\n * // Stream 2: 9\n * // Stream 3: 9\n * ```\n *\n * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times\n * as needed, without causing multiple subscriptions to the source sequence.\n * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.\n * @return A ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.\n * @method publish\n * @owner Observable\n *\n *\n */\nexport function publish<T, R>(selector?: OperatorFunction<T, R>): MonoTypeOperatorFunction<T> | OperatorFunction<T, R> {\n  return selector ?\n    multicast(() => new Subject<T>(), selector) :\n    multicast(new Subject<T>());\n}\n","import { Observable } from '../Observable';\nimport { BehaviorSubject } from '../BehaviorSubject';\nimport { multicast } from './multicast';\nimport { ConnectableObservable } from '../observable/ConnectableObservable';\nimport { UnaryFunction } from '../types';\n\n/**\n * @param value\n * @return {ConnectableObservable<T>}\n * @method publishBehavior\n * @owner Observable\n */\nexport function publishBehavior<T>(value: T):  UnaryFunction<Observable<T>, ConnectableObservable<T>> {\n  return (source: Observable<T>) => multicast(new BehaviorSubject<T>(value))(source) as ConnectableObservable<T>;\n}\n","import { Observable } from '../Observable';\nimport { AsyncSubject } from '../AsyncSubject';\nimport { multicast } from './multicast';\nimport { ConnectableObservable } from '../observable/ConnectableObservable';\nimport { UnaryFunction } from '../types';\n\n/**\n * Returns a connectable observable sequence that shares a single subscription to the\n * underlying sequence containing only the last notification.\n *\n * ![](publishLast.png)\n *\n * Similar to {@link publish}, but it waits until the source observable completes and stores\n * the last emitted value.\n * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last\n * value even if it has no more subscribers. If subsequent subscriptions happen, they will\n * immediately get that last stored value and complete.\n *\n * ## Example\n *\n * ```ts\n * import { interval } from 'rxjs';\n * import { publishLast, tap, take } from 'rxjs/operators';\n *\n * const connectable =\n *   interval(1000)\n *     .pipe(\n *       tap(x => console.log(\"side effect\", x)),\n *       take(3),\n *       publishLast());\n *\n * connectable.subscribe(\n *   x => console.log(  \"Sub. A\", x),\n *   err => console.log(\"Sub. A Error\", err),\n *   () => console.log( \"Sub. A Complete\"));\n *\n * connectable.subscribe(\n *   x => console.log(  \"Sub. B\", x),\n *   err => console.log(\"Sub. B Error\", err),\n *   () => console.log( \"Sub. B Complete\"));\n *\n * connectable.connect();\n *\n * // Results:\n * //    \"side effect 0\"\n * //    \"side effect 1\"\n * //    \"side effect 2\"\n * //    \"Sub. A 2\"\n * //    \"Sub. B 2\"\n * //    \"Sub. A Complete\"\n * //    \"Sub. B Complete\"\n * ```\n *\n * @see {@link ConnectableObservable}\n * @see {@link publish}\n * @see {@link publishReplay}\n * @see {@link publishBehavior}\n *\n * @return {ConnectableObservable} An observable sequence that contains the elements of a\n * sequence produced by multicasting the source sequence.\n * @method publishLast\n * @owner Observable\n */\n\nexport function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>> {\n  return (source: Observable<T>) => multicast(new AsyncSubject<T>())(source);\n}\n","import { Observable } from '../Observable';\nimport { ReplaySubject } from '../ReplaySubject';\nimport { multicast } from './multicast';\nimport { ConnectableObservable } from '../observable/ConnectableObservable';\nimport { UnaryFunction, MonoTypeOperatorFunction, OperatorFunction, SchedulerLike, ObservableInput, ObservedValueOf } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function publishReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\nexport function publishReplay<T, O extends ObservableInput<any>>(bufferSize?: number, windowTime?: number, selector?: (shared: Observable<T>) => O, scheduler?: SchedulerLike): OperatorFunction<T, ObservedValueOf<O>>;\n/* tslint:enable:max-line-length */\n\nexport function publishReplay<T, R>(bufferSize?: number,\n                                    windowTime?: number,\n                                    selectorOrScheduler?: SchedulerLike | OperatorFunction<T, R>,\n                                    scheduler?: SchedulerLike): UnaryFunction<Observable<T>, ConnectableObservable<R>> {\n\n  if (selectorOrScheduler && typeof selectorOrScheduler !== 'function') {\n    scheduler = selectorOrScheduler;\n  }\n\n  const selector = typeof selectorOrScheduler === 'function' ? selectorOrScheduler : undefined;\n  const subject = new ReplaySubject<T>(bufferSize, windowTime, scheduler);\n\n  return (source: Observable<T>) => multicast(() => subject, selector)(source) as ConnectableObservable<R>;\n}\n","import { Observable } from '../Observable';\nimport { isArray } from '../util/isArray';\nimport { MonoTypeOperatorFunction, OperatorFunction } from '../types';\nimport { race as raceStatic } from '../observable/race';\n\n/* tslint:disable:max-line-length */\n/** @deprecated Deprecated in favor of static race. */\nexport function race<T>(observables: Array<Observable<T>>): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static race. */\nexport function race<T, R>(observables: Array<Observable<T>>): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static race. */\nexport function race<T>(...observables: Array<Observable<T> | Array<Observable<T>>>): MonoTypeOperatorFunction<T>;\n/** @deprecated Deprecated in favor of static race. */\nexport function race<T, R>(...observables: Array<Observable<any> | Array<Observable<any>>>): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Returns an Observable that mirrors the first source Observable to emit a next,\n * error or complete notification from the combination of this Observable and supplied Observables.\n * @param {...Observables} ...observables Sources used to race for which Observable emits first.\n * @return {Observable} An Observable that mirrors the output of the first Observable to emit an item.\n * @method race\n * @owner Observable\n * @deprecated Deprecated in favor of static {@link race}.\n */\nexport function race<T>(...observables: (Observable<T> | Observable<T>[])[]): MonoTypeOperatorFunction<T> {\n  return function raceOperatorFunction(source: Observable<T>) {\n    // if the only argument is an array, it was most likely called with\n    // `pair([obs1, obs2, ...])`\n    if (observables.length === 1 && isArray(observables[0])) {\n      observables = observables[0] as Observable<T>[];\n    }\n\n    return source.lift.call(raceStatic(source, ...(observables as Observable<T>[])));\n  };\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { empty } from '../observable/empty';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that will resubscribe to the source stream when the source stream completes, at most count times.\n *\n * <span class=\"informal\">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span>\n *\n * ![](repeat.png)\n *\n * Similar to {@link retry}, this operator repeats the stream of items emitted by the source for non error cases.\n * Repeat can be useful for creating observables that are meant to have some repeated pattern or rhythm.\n *\n * Note: `repeat(0)` returns an empty observable and `repeat()` will repeat forever\n *\n * ## Example\n * Repeat a message stream\n * ```ts\n * import { of } from 'rxjs';\n * import { repeat, delay } from 'rxjs/operators';\n *\n * const source = of('Repeat message');\n * const example = source.pipe(repeat(3));\n * example.subscribe(x => console.log(x));\n *\n * // Results\n * // Repeat message\n * // Repeat message\n * // Repeat message\n * ```\n *\n * Repeat 3 values, 2 times\n * ```ts\n * import { interval } from 'rxjs';\n * import { repeat, take } from 'rxjs/operators';\n *\n * const source = interval(1000);\n * const example = source.pipe(take(3), repeat(2));\n * example.subscribe(x => console.log(x));\n *\n * // Results every second\n * // 0\n * // 1\n * // 2\n * // 0\n * // 1\n * // 2\n * ```\n *\n * @see {@link repeatWhen}\n * @see {@link retry}\n *\n * @param {number} [count] The number of times the source Observable items are repeated, a count of 0 will yield\n * an empty Observable.\n * @return {Observable} An Observable that will resubscribe to the source stream when the source stream completes\n * , at most count times.\n * @method repeat\n * @owner Observable\n */\nexport function repeat<T>(count: number = -1): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => {\n    if (count === 0) {\n      return empty();\n    } else if (count < 0) {\n      return source.lift(new RepeatOperator(-1, source));\n    } else {\n      return source.lift(new RepeatOperator(count - 1, source));\n    }\n  };\n}\n\nclass RepeatOperator<T> implements Operator<T, T> {\n  constructor(private count: number,\n              private source: Observable<T>) {\n  }\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new RepeatSubscriber(subscriber, this.count, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass RepeatSubscriber<T> extends Subscriber<T> {\n  constructor(destination: Subscriber<any>,\n              private count: number,\n              private source: Observable<T>) {\n    super(destination);\n  }\n  complete() {\n    if (!this.isStopped) {\n      const { source, count } = this;\n      if (count === 0) {\n        return super.complete();\n      } else if (count > -1) {\n        this.count = count - 1;\n      }\n      source.subscribe(this._unsubscribeAndRecycle());\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { Subscription } from '../Subscription';\n\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source\n * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable\n * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise\n * this method will resubscribe to the source Observable.\n *\n * ![](repeatWhen.png)\n *\n * ## Example\n * Repeat a message stream on click\n * ```ts\n * import { of, fromEvent } from 'rxjs';\n * import { repeatWhen } from 'rxjs/operators';\n *\n * const source = of('Repeat message');\n * const documentClick$ = fromEvent(document, 'click');\n *\n * source.pipe(repeatWhen(() => documentClick$)\n * ).subscribe(data => console.log(data))\n * ```\n * @see {@link repeat}\n * @see {@link retry}\n * @see {@link retryWhen}\n *\n * @param {function(notifications: Observable): Observable} notifier - Receives an Observable of notifications with\n * which a user can `complete` or `error`, aborting the repetition.\n * @return {Observable} The source Observable modified with repeat logic.\n * @method repeatWhen\n * @owner Observable\n */\nexport function repeatWhen<T>(notifier: (notifications: Observable<any>) => Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new RepeatWhenOperator(notifier));\n}\n\nclass RepeatWhenOperator<T> implements Operator<T, T> {\n  constructor(protected notifier: (notifications: Observable<any>) => Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new RepeatWhenSubscriber(subscriber, this.notifier, source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass RepeatWhenSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n\n  private notifications?: Subject<any>;\n  private retries?: Observable<any>;\n  private retriesSubscription?: Subscription;\n  private sourceIsBeingSubscribedTo: boolean = true;\n\n  constructor(destination: Subscriber<R>,\n              private notifier: (notifications: Observable<any>) => Observable<any>,\n              private source: Observable<T>) {\n    super(destination);\n  }\n\n  notifyNext(): void {\n    this.sourceIsBeingSubscribedTo = true;\n    this.source.subscribe(this);\n  }\n\n  notifyComplete(): void {\n    if (this.sourceIsBeingSubscribedTo === false) {\n      return super.complete();\n    }\n  }\n\n  complete() {\n    this.sourceIsBeingSubscribedTo = false;\n\n    if (!this.isStopped) {\n      if (!this.retries) {\n        this.subscribeToRetries();\n      }\n      if (!this.retriesSubscription || this.retriesSubscription.closed) {\n        return super.complete();\n      }\n\n      this._unsubscribeAndRecycle();\n      this.notifications!.next(undefined);\n    }\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    const { notifications, retriesSubscription } = this;\n    if (notifications) {\n      notifications.unsubscribe();\n      this.notifications = undefined;\n    }\n    if (retriesSubscription) {\n      retriesSubscription.unsubscribe();\n      this.retriesSubscription = undefined;\n    }\n    this.retries = undefined;\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribeAndRecycle(): Subscriber<T> {\n    const { _unsubscribe } = this;\n\n    this._unsubscribe = null!;\n    super._unsubscribeAndRecycle();\n    this._unsubscribe = _unsubscribe;\n\n    return this;\n  }\n\n  private subscribeToRetries() {\n    this.notifications = new Subject();\n    let retries;\n    try {\n      const { notifier } = this;\n      retries = notifier(this.notifications);\n    } catch (e) {\n      return super.complete();\n    }\n    this.retries = retries;\n    this.retriesSubscription = innerSubscribe(retries, new SimpleInnerSubscriber(this));\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\n\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will resubscribe to the source Observable for a maximum of `count` resubscriptions (given\n * as a number parameter) rather than propagating the `error` call.\n *\n * ![](retry.png)\n *\n * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted\n * during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second\n * time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications\n * would be: [1, 2, 1, 2, 3, 4, 5, `complete`].\n *\n * ## Example\n * ```ts\n * import { interval, of, throwError } from 'rxjs';\n * import { mergeMap, retry } from 'rxjs/operators';\n *\n * const source = interval(1000);\n * const example = source.pipe(\n *   mergeMap(val => {\n *     if(val > 5){\n *       return throwError('Error!');\n *     }\n *     return of(val);\n *   }),\n *   //retry 2 times on error\n *   retry(2)\n * );\n *\n * const subscribe = example.subscribe({\n *   next: val => console.log(val),\n *   error: val => console.log(`${val}: Retried 2 times then quit!`)\n * });\n *\n * // Output:\n * // 0..1..2..3..4..5..\n * // 0..1..2..3..4..5..\n * // 0..1..2..3..4..5..\n * // \"Error!: Retried 2 times then quit!\"\n * ```\n *\n * @param {number} count - Number of retry attempts before failing.\n * @return {Observable} The source Observable modified with the retry logic.\n * @method retry\n * @owner Observable\n */\nexport function retry<T>(count: number = -1): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new RetryOperator(count, source));\n}\n\nclass RetryOperator<T> implements Operator<T, T> {\n  constructor(private count: number,\n              private source: Observable<T>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new RetrySubscriber(subscriber, this.count, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass RetrySubscriber<T> extends Subscriber<T> {\n  constructor(destination: Subscriber<any>,\n              private count: number,\n              private source: Observable<T>) {\n    super(destination);\n  }\n  error(err: any) {\n    if (!this.isStopped) {\n      const { source, count } = this;\n      if (count === 0) {\n        return super.error(err);\n      } else if (count > -1) {\n        this.count = count - 1;\n      }\n      source.subscribe(this._unsubscribeAndRecycle());\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { Subscription } from '../Subscription';\n\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.\n * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child\n * subscription. Otherwise this method will resubscribe to the source Observable.\n *\n * ![](retryWhen.png)\n *\n * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a\n * user can `complete` or `error`, aborting the retry.\n * @return {Observable} The source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nexport function retryWhen<T>(notifier: (errors: Observable<any>) => Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new RetryWhenOperator(notifier, source));\n}\n\nclass RetryWhenOperator<T> implements Operator<T, T> {\n  constructor(protected notifier: (errors: Observable<any>) => Observable<any>,\n              protected source: Observable<T>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new RetryWhenSubscriber(subscriber, this.notifier, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass RetryWhenSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n\n  private errors?: Subject<any>;\n  private retries?: Observable<any>;\n  private retriesSubscription?: Subscription;\n\n  constructor(destination: Subscriber<R>,\n              private notifier: (errors: Observable<any>) => Observable<any>,\n              private source: Observable<T>) {\n    super(destination);\n  }\n\n  error(err: any) {\n    if (!this.isStopped) {\n\n      let errors = this.errors;\n      let retries: any = this.retries;\n      let retriesSubscription = this.retriesSubscription;\n\n      if (!retries) {\n        errors = new Subject();\n        try {\n          const { notifier } = this;\n          retries = notifier(errors);\n        } catch (e) {\n          return super.error(e);\n        }\n        retriesSubscription = innerSubscribe(retries, new SimpleInnerSubscriber(this));\n      } else {\n        this.errors = undefined;\n        this.retriesSubscription = undefined;\n      }\n\n      this._unsubscribeAndRecycle();\n\n      this.errors = errors;\n      this.retries = retries;\n      this.retriesSubscription = retriesSubscription;\n\n      errors!.next(err);\n    }\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    const { errors, retriesSubscription } = this;\n    if (errors) {\n      errors.unsubscribe();\n      this.errors = undefined;\n    }\n    if (retriesSubscription) {\n      retriesSubscription.unsubscribe();\n      this.retriesSubscription = undefined;\n    }\n    this.retries = undefined;\n  }\n\n  notifyNext(): void {\n    const { _unsubscribe } = this;\n\n    this._unsubscribe = null!;\n    this._unsubscribeAndRecycle();\n    this._unsubscribe = _unsubscribe;\n\n    this.source.subscribe(this);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\n\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Emits the most recently emitted value from the source Observable whenever\n * another Observable, the `notifier`, emits.\n *\n * <span class=\"informal\">It's like {@link sampleTime}, but samples whenever\n * the `notifier` Observable emits something.</span>\n *\n * ![](sample.png)\n *\n * Whenever the `notifier` Observable emits a value or completes, `sample`\n * looks at the source Observable and emits whichever value it has most recently\n * emitted since the previous sampling, unless the source has not emitted\n * anything since the previous sampling. The `notifier` is subscribed to as soon\n * as the output Observable is subscribed.\n *\n * ## Example\n * On every click, sample the most recent \"seconds\" timer\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { sample } from 'rxjs/operators';\n *\n * const seconds = interval(1000);\n * const clicks = fromEvent(document, 'click');\n * const result = seconds.pipe(sample(clicks));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link audit}\n * @see {@link debounce}\n * @see {@link sampleTime}\n * @see {@link throttle}\n *\n * @param {Observable<any>} notifier The Observable to use for sampling the\n * source Observable.\n * @return {Observable<T>} An Observable that emits the results of sampling the\n * values emitted by the source Observable whenever the notifier Observable\n * emits value or completes.\n * @method sample\n * @owner Observable\n */\nexport function sample<T>(notifier: Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SampleOperator(notifier));\n}\n\nclass SampleOperator<T> implements Operator<T, T> {\n  constructor(private notifier: Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    const sampleSubscriber = new SampleSubscriber(subscriber);\n    const subscription = source.subscribe(sampleSubscriber);\n    subscription.add(innerSubscribe(this.notifier, new SimpleInnerSubscriber(sampleSubscriber)));\n    return subscription;\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SampleSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private value?: T;\n  private hasValue: boolean = false;\n\n  protected _next(value: T) {\n    this.value = value;\n    this.hasValue = true;\n  }\n\n  notifyNext(): void {\n    this.emitValue();\n  }\n\n  notifyComplete(): void {\n    this.emitValue();\n  }\n\n  emitValue() {\n    if (this.hasValue) {\n      this.hasValue = false;\n      this.destination.next!(this.value!);\n    }\n  }\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { async } from '../scheduler/async';\nimport { MonoTypeOperatorFunction, SchedulerAction, SchedulerLike, TeardownLogic } from '../types';\n\n/**\n * Emits the most recently emitted value from the source Observable within\n * periodic time intervals.\n *\n * <span class=\"informal\">Samples the source Observable at periodic time\n * intervals, emitting what it samples.</span>\n *\n * ![](sampleTime.png)\n *\n * `sampleTime` periodically looks at the source Observable and emits whichever\n * value it has most recently emitted since the previous sampling, unless the\n * source has not emitted anything since the previous sampling. The sampling\n * happens periodically in time every `period` milliseconds (or the time unit\n * defined by the optional `scheduler` argument). The sampling starts as soon as\n * the output Observable is subscribed.\n *\n * ## Example\n * Every second, emit the most recent click at most once\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { sampleTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(sampleTime(1000));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link auditTime}\n * @see {@link debounceTime}\n * @see {@link delay}\n * @see {@link sample}\n * @see {@link throttleTime}\n *\n * @param {number} period The sampling period expressed in milliseconds or the\n * time unit determined internally by the optional `scheduler`.\n * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for\n * managing the timers that handle the sampling.\n * @return {Observable<T>} An Observable that emits the results of sampling the\n * values emitted by the source Observable at the specified time interval.\n * @method sampleTime\n * @owner Observable\n */\nexport function sampleTime<T>(period: number, scheduler: SchedulerLike = async): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SampleTimeOperator(period, scheduler));\n}\n\nclass SampleTimeOperator<T> implements Operator<T, T> {\n  constructor(private period: number,\n              private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SampleTimeSubscriber(subscriber, this.period, this.scheduler));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SampleTimeSubscriber<T> extends Subscriber<T> {\n  lastValue: T;\n  hasValue: boolean = false;\n\n  constructor(destination: Subscriber<T>,\n              private period: number,\n              private scheduler: SchedulerLike) {\n    super(destination);\n    this.add(scheduler.schedule(dispatchNotification, period, { subscriber: this, period }));\n  }\n\n  protected _next(value: T) {\n    this.lastValue = value;\n    this.hasValue = true;\n  }\n\n  notifyNext() {\n    if (this.hasValue) {\n      this.hasValue = false;\n      this.destination.next(this.lastValue);\n    }\n  }\n}\n\nfunction dispatchNotification<T>(this: SchedulerAction<any>, state: any) {\n  let { subscriber, period } = state;\n  subscriber.notifyNext();\n  this.schedule(state, period);\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\n\nimport { Observer, OperatorFunction } from '../types';\n\n/**\n * Compares all values of two observables in sequence using an optional comparator function\n * and returns an observable of a single boolean value representing whether or not the two sequences\n * are equal.\n *\n * <span class=\"informal\">Checks to see of all values emitted by both observables are equal, in order.</span>\n *\n * ![](sequenceEqual.png)\n *\n * `sequenceEqual` subscribes to two observables and buffers incoming values from each observable. Whenever either\n * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom\n * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the\n * observables completes, the operator will wait for the other observable to complete; If the other\n * observable emits before completing, the returned observable will emit `false` and complete. If one observable never\n * completes or emits after the other complets, the returned observable will never complete.\n *\n * ## Example\n * figure out if the Konami code matches\n * ```ts\n * import { from, fromEvent } from 'rxjs';\n * import { sequenceEqual, bufferCount, mergeMap, map } from 'rxjs/operators';\n *\n * const codes = from([\n *   'ArrowUp',\n *   'ArrowUp',\n *   'ArrowDown',\n *   'ArrowDown',\n *   'ArrowLeft',\n *   'ArrowRight',\n *   'ArrowLeft',\n *   'ArrowRight',\n *   'KeyB',\n *   'KeyA',\n *   'Enter', // no start key, clearly.\n * ]);\n *\n * const keys = fromEvent(document, 'keyup').pipe(map(e => e.code));\n * const matches = keys.pipe(\n *   bufferCount(11, 1),\n *   mergeMap(\n *     last11 => from(last11).pipe(sequenceEqual(codes)),\n *   ),\n * );\n * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));\n * ```\n *\n * @see {@link combineLatest}\n * @see {@link zip}\n * @see {@link withLatestFrom}\n *\n * @param {Observable} compareTo The observable sequence to compare the source sequence to.\n * @param {function} [comparator] An optional function to compare each value pair\n * @return {Observable} An Observable of a single boolean value representing whether or not\n * the values emitted by both observables were equal in sequence.\n * @method sequenceEqual\n * @owner Observable\n */\nexport function sequenceEqual<T>(compareTo: Observable<T>,\n                                 comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean> {\n  return (source: Observable<T>) => source.lift(new SequenceEqualOperator(compareTo, comparator));\n}\n\nexport class SequenceEqualOperator<T> implements Operator<T, boolean> {\n  constructor(private compareTo: Observable<T>,\n              private comparator: (a: T, b: T) => boolean) {\n  }\n\n  call(subscriber: Subscriber<boolean>, source: any): any {\n    return source.subscribe(new SequenceEqualSubscriber(subscriber, this.compareTo, this.comparator));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class SequenceEqualSubscriber<T, R> extends Subscriber<T> {\n  private _a: T[] = [];\n  private _b: T[] = [];\n  private _oneComplete = false;\n\n  constructor(destination: Observer<R>,\n              private compareTo: Observable<T>,\n              private comparator: (a: T, b: T) => boolean) {\n    super(destination);\n    (this.destination as Subscription).add(compareTo.subscribe(new SequenceEqualCompareToSubscriber(destination, this)));\n  }\n\n  protected _next(value: T): void {\n    if (this._oneComplete && this._b.length === 0) {\n      this.emit(false);\n    } else {\n      this._a.push(value);\n      this.checkValues();\n    }\n  }\n\n  public _complete(): void {\n    if (this._oneComplete) {\n      this.emit(this._a.length === 0 && this._b.length === 0);\n    } else {\n      this._oneComplete = true;\n    }\n    this.unsubscribe();\n  }\n\n  checkValues() {\n    const { _a, _b, comparator } = this;\n    while (_a.length > 0 && _b.length > 0) {\n      let a = _a.shift();\n      let b = _b.shift();\n      let areEqual = false;\n      try {\n        areEqual = comparator ? comparator(a, b) : a === b;\n      } catch (e) {\n        this.destination.error(e);\n      }\n      if (!areEqual) {\n        this.emit(false);\n      }\n    }\n  }\n\n  emit(value: boolean) {\n    const { destination } = this;\n    destination.next(value);\n    destination.complete();\n  }\n\n  nextB(value: T) {\n    if (this._oneComplete && this._a.length === 0) {\n      this.emit(false);\n    } else {\n      this._b.push(value);\n      this.checkValues();\n    }\n  }\n\n  completeB() {\n    if (this._oneComplete) {\n      this.emit(this._a.length === 0 && this._b.length === 0);\n    } else {\n      this._oneComplete = true;\n    }\n  }\n}\n\nclass SequenceEqualCompareToSubscriber<T, R> extends Subscriber<T> {\n  constructor(destination: Observer<R>, private parent: SequenceEqualSubscriber<T, R>) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    this.parent.nextB(value);\n  }\n\n  protected _error(err: any): void {\n    this.parent.error(err);\n    this.unsubscribe();\n  }\n\n  protected _complete(): void {\n    this.parent.completeB();\n    this.unsubscribe();\n  }\n}\n","import { Observable } from '../Observable';\nimport { multicast } from './multicast';\nimport { refCount } from './refCount';\nimport { Subject } from '../Subject';\n\nimport { MonoTypeOperatorFunction } from '../types';\n\nfunction shareSubjectFactory() {\n  return new Subject();\n}\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 * ![](share.png)\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 */\nexport function share<T>(): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => refCount()(multicast(shareSubjectFactory)(source)) as Observable<T>;\n}\n","import { Observable } from '../Observable';\nimport { ReplaySubject } from '../ReplaySubject';\nimport { Subscription } from '../Subscription';\nimport { MonoTypeOperatorFunction, SchedulerLike } from '../types';\nimport { Subscriber } from '../Subscriber';\n\nexport interface ShareReplayConfig {\n  bufferSize?: number;\n  windowTime?: number;\n  refCount: boolean;\n  scheduler?: SchedulerLike;\n}\n\n/**\n * Share source and replay specified number of emissions on subscription.\n *\n * This operator is a specialization of `replay` that connects to a source observable\n * and multicasts through a `ReplaySubject` constructed with the specified arguments.\n * A successfully completed source will stay cached in the `shareReplayed observable` forever,\n * but an errored source can be retried.\n *\n * ## Why use shareReplay?\n * You generally want to use `shareReplay` when you have side-effects or taxing computations\n * that you do not wish to be executed amongst multiple subscribers.\n * It may also be valuable in situations where you know you will have late subscribers to\n * a stream that need access to previously emitted values.\n * This ability to replay values on subscription is what differentiates {@link share} and `shareReplay`.\n *\n * ![](shareReplay.png)\n *\n * ## Example\n * ```ts\n * import { interval } from 'rxjs';\n * import { shareReplay, take } from 'rxjs/operators';\n *\n * const obs$ = interval(1000);\n * const shared$ = obs$.pipe(\n *   take(4),\n *   shareReplay(3)\n * );\n * shared$.subscribe(x => console.log('source A: ', x));\n * shared$.subscribe(y => console.log('source B: ', y));\n *\n * ```\n *\n * @see {@link publish}\n * @see {@link share}\n * @see {@link publishReplay}\n *\n * @param {Number} [bufferSize=Number.POSITIVE_INFINITY] Maximum element count of the replay buffer.\n * @param {Number} [windowTime=Number.POSITIVE_INFINITY] Maximum time length of the replay buffer in milliseconds.\n * @param {Scheduler} [scheduler] Scheduler where connected observers within the selector function\n * will be invoked on.\n * @return {Observable} An observable sequence that contains the elements of a sequence produced\n * by multicasting the source sequence within a selector function.\n * @method shareReplay\n * @owner Observable\n */\nexport function shareReplay<T>(config: ShareReplayConfig): MonoTypeOperatorFunction<T>;\nexport function shareReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;\nexport function shareReplay<T>(\n  configOrBufferSize?: ShareReplayConfig | number,\n  windowTime?: number,\n  scheduler?: SchedulerLike\n): MonoTypeOperatorFunction<T> {\n  let config: ShareReplayConfig;\n  if (configOrBufferSize && typeof configOrBufferSize === 'object') {\n    config = configOrBufferSize as ShareReplayConfig;\n  } else {\n    config = {\n      bufferSize: configOrBufferSize as number | undefined,\n      windowTime,\n      refCount: false,\n      scheduler\n    };\n  }\n  return (source: Observable<T>) => source.lift(shareReplayOperator(config));\n}\n\nfunction shareReplayOperator<T>({\n  bufferSize = Number.POSITIVE_INFINITY,\n  windowTime = Number.POSITIVE_INFINITY,\n  refCount: useRefCount,\n  scheduler\n}: ShareReplayConfig) {\n  let subject: ReplaySubject<T> | undefined;\n  let refCount = 0;\n  let subscription: Subscription | undefined;\n  let hasError = false;\n  let isComplete = false;\n\n  return function shareReplayOperation(this: Subscriber<T>, source: Observable<T>) {\n    refCount++;\n    let innerSub: Subscription;\n    if (!subject || hasError) {\n      hasError = false;\n      subject = new ReplaySubject<T>(bufferSize, windowTime, scheduler);\n      innerSub = subject.subscribe(this);\n      subscription = source.subscribe({\n        next(value) { subject.next(value); },\n        error(err) {\n          hasError = true;\n          subject.error(err);\n        },\n        complete() {\n          isComplete = true;\n          subscription = undefined;\n          subject.complete();\n        },\n      });\n    } else {\n      innerSub = subject.subscribe(this);\n    }\n\n    this.add(() => {\n      refCount--;\n      innerSub.unsubscribe();\n      if (subscription && !isComplete && useRefCount && refCount === 0) {\n        subscription.unsubscribe();\n        subscription = undefined;\n        subject = undefined;\n      }\n    });\n  };\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { EmptyError } from '../util/EmptyError';\n\nimport { Observer, MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that emits the single item emitted by the source Observable that matches a specified\n * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no\n * items, notify of an IllegalArgumentException or NoSuchElementException respectively. If the source Observable\n * emits items but none match the specified predicate then `undefined` is emitted.\n *\n * <span class=\"informal\">Like {@link first}, but emit with error notification if there is more than one value.</span>\n * ![](single.png)\n *\n * ## Example\n * emits 'error'\n * ```ts\n * import { range } from 'rxjs';\n * import { single } from 'rxjs/operators';\n *\n * const numbers = range(1,5).pipe(single());\n * numbers.subscribe(x => console.log('never get called'), e => console.log('error'));\n * // result\n * // 'error'\n * ```\n *\n * emits 'undefined'\n * ```ts\n * import { range } from 'rxjs';\n * import { single } from 'rxjs/operators';\n *\n * const numbers = range(1,5).pipe(single(x => x === 10));\n * numbers.subscribe(x => console.log(x));\n * // result\n * // 'undefined'\n * ```\n *\n * @see {@link first}\n * @see {@link find}\n * @see {@link findIndex}\n * @see {@link elementAt}\n *\n * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`\n * callback if the Observable completes before any `next` notification was sent.\n * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.\n * @return {Observable<T>} An Observable that emits the single item emitted by the source Observable that matches\n * the predicate or `undefined` when no items match.\n *\n * @method single\n * @owner Observable\n */\nexport function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SingleOperator(predicate, source));\n}\n\nclass SingleOperator<T> implements Operator<T, T> {\n  constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,\n              private source?: Observable<T>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SingleSubscriber<T> extends Subscriber<T> {\n  private seenValue: boolean = false;\n  private singleValue: T;\n  private index: number = 0;\n\n  constructor(destination: Observer<T>,\n              private predicate?: (value: T, index: number, source: Observable<T>) => boolean,\n              private source?: Observable<T>) {\n    super(destination);\n  }\n\n  private applySingleValue(value: T): void {\n    if (this.seenValue) {\n      this.destination.error('Sequence contains more than one element');\n    } else {\n      this.seenValue = true;\n      this.singleValue = value;\n    }\n  }\n\n  protected _next(value: T): void {\n    const index = this.index++;\n\n    if (this.predicate) {\n      this.tryNext(value, index);\n    } else {\n      this.applySingleValue(value);\n    }\n  }\n\n  private tryNext(value: T, index: number): void {\n    try {\n      if (this.predicate(value, index, this.source)) {\n        this.applySingleValue(value);\n      }\n    } catch (err) {\n      this.destination.error(err);\n    }\n  }\n\n  protected _complete(): void {\n    const destination = this.destination;\n\n    if (this.index > 0) {\n      destination.next(this.seenValue ? this.singleValue : undefined);\n      destination.complete();\n    } else {\n      destination.error(new EmptyError);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that skips the first `count` items emitted by the source Observable.\n *\n * ![](skip.png)\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 */\nexport function skip<T>(count: number): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SkipOperator(count));\n}\n\nclass SkipOperator<T> implements Operator<T, T> {\n  constructor(private total: number) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SkipSubscriber(subscriber, this.total));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SkipSubscriber<T> extends Subscriber<T> {\n  count: number = 0;\n\n  constructor(destination: Subscriber<T>, private total: number) {\n    super(destination);\n  }\n\n  protected _next(x: T) {\n    if (++this.count > this.total) {\n      this.destination.next(x);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Skip the last `count` values emitted by the source Observable.\n *\n * ![](skipLast.png)\n *\n * `skipLast` returns an Observable that accumulates a queue with a length\n * enough to store the first `count` values. As more values are received,\n * values are taken from the front of the queue and produced on the result\n * sequence. This causes values to be delayed.\n *\n * ## Example\n * Skip the last 2 values of an Observable with many values\n * ```ts\n * import { range } from 'rxjs';\n * import { skipLast } from 'rxjs/operators';\n *\n * const many = range(1, 5);\n * const skipLastTwo = many.pipe(skipLast(2));\n * skipLastTwo.subscribe(x => console.log(x));\n *\n * // Results in:\n * // 1 2 3\n * ```\n *\n * @see {@link skip}\n * @see {@link skipUntil}\n * @see {@link skipWhile}\n * @see {@link take}\n *\n * @throws {ArgumentOutOfRangeError} When using `skipLast(i)`, it throws\n * ArgumentOutOrRangeError if `i < 0`.\n *\n * @param {number} count Number of elements to skip from the end of the source Observable.\n * @returns {Observable<T>} An Observable that skips the last count values\n * emitted by the source Observable.\n * @method skipLast\n * @owner Observable\n */\nexport function skipLast<T>(count: number): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SkipLastOperator(count));\n}\n\nclass SkipLastOperator<T> implements Operator<T, T> {\n  constructor(private _skipCount: number) {\n    if (this._skipCount < 0) {\n      throw new ArgumentOutOfRangeError;\n    }\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    if (this._skipCount === 0) {\n      // If we don't want to skip any values then just subscribe\n      // to Subscriber without any further logic.\n      return source.subscribe(new Subscriber(subscriber));\n    } else {\n      return source.subscribe(new SkipLastSubscriber(subscriber, this._skipCount));\n    }\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SkipLastSubscriber<T> extends Subscriber<T> {\n  private _ring: T[];\n  private _count: number = 0;\n\n  constructor(destination: Subscriber<T>, private _skipCount: number) {\n    super(destination);\n    this._ring = new Array<T>(_skipCount);\n  }\n\n  protected _next(value: T): void {\n    const skipCount = this._skipCount;\n    const count = this._count++;\n\n    if (count < skipCount) {\n      this._ring[count] = value;\n    } else {\n      const currentIndex = count % skipCount;\n      const ring = this._ring;\n      const oldValue = ring[currentIndex];\n\n      ring[currentIndex] = value;\n      this.destination.next(oldValue);\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, TeardownLogic, ObservableInput } from '../types';\nimport { Subscription } from '../Subscription';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/**\n * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.\n *\n * The `skipUntil` operator causes the observable stream to skip the emission of values ​​until the passed in observable emits the first value.\n * This can be particularly useful in combination with user interactions, responses of http requests or waiting for specific times to pass by.\n *\n * ![](skipUntil.png)\n *\n * Internally the `skipUntil` operator subscribes to the passed in observable (in the following called *notifier*) in order to recognize the emission\n * of its first value. When this happens, the operator unsubscribes from the *notifier* and starts emitting the values of the *source*\n * observable. It will never let the *source* observable emit any values if the *notifier* completes or throws an error without emitting\n * a value before.\n *\n * ## Example\n *\n * In the following example, all emitted values ​​of the interval observable are skipped until the user clicks anywhere within the page.\n *\n * ```ts\n * import { interval, fromEvent } from 'rxjs';\n * import { skipUntil } from 'rxjs/operators';\n *\n * const intervalObservable = interval(1000);\n * const click = fromEvent(document, 'click');\n *\n * const emitAfterClick = intervalObservable.pipe(\n *   skipUntil(click)\n * );\n * // clicked at 4.6s. output: 5...6...7...8........ or\n * // clicked at 7.3s. output: 8...9...10..11.......\n * const subscribe = emitAfterClick.subscribe(value => console.log(value));\n * ```\n *\n * @param {Observable} notifier - The second Observable that has to emit an item before the source Observable's elements begin to\n * be mirrored by the resulting Observable.\n * @return {Observable<T>} An Observable that skips items from the source Observable until the second Observable emits\n * an item, then emits the remaining items.\n * @method skipUntil\n * @owner Observable\n */\nexport function skipUntil<T>(notifier: Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SkipUntilOperator(notifier));\n}\n\nclass SkipUntilOperator<T> implements Operator<T, T> {\n  constructor(private notifier: Observable<any>) {\n  }\n\n  call(destination: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SkipUntilSubscriber(destination, this.notifier));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SkipUntilSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n\n  private hasValue: boolean = false;\n  private innerSubscription?: Subscription;\n\n  constructor(destination: Subscriber<R>, notifier: ObservableInput<any>) {\n    super(destination);\n    const innerSubscriber = new SimpleInnerSubscriber(this);\n    this.add(innerSubscriber);\n    this.innerSubscription = innerSubscriber;\n    const innerSubscription = innerSubscribe(notifier, innerSubscriber);\n    // The returned subscription will usually be the subscriber that was\n    // passed. However, interop subscribers will be wrapped and for\n    // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n    if (innerSubscription !== innerSubscriber) {\n      this.add(innerSubscription);\n      this.innerSubscription = innerSubscription;\n    }\n  }\n\n  protected _next(value: T) {\n    if (this.hasValue) {\n      super._next(value);\n    }\n  }\n\n  notifyNext(): void {\n    this.hasValue = true;\n    if (this.innerSubscription) {\n      this.innerSubscription.unsubscribe();\n    }\n  }\n\n  notifyComplete() {\n    /* do nothing */\n  }\n}\n","import { Observable } from '../Observable';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\n/**\n * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds\n * true, but emits all further source items as soon as the condition becomes false.\n *\n * ![](skipWhile.png)\n *\n * @param {Function} predicate - A function to test each item emitted from the source Observable.\n * @return {Observable<T>} An Observable that begins emitting items emitted by the source Observable when the\n * specified predicate becomes false.\n * @method skipWhile\n * @owner Observable\n */\nexport function skipWhile<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new SkipWhileOperator(predicate));\n}\n\nclass SkipWhileOperator<T> implements Operator<T, T> {\n  constructor(private predicate: (value: T, index: number) => boolean) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new SkipWhileSubscriber(subscriber, this.predicate));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SkipWhileSubscriber<T> extends Subscriber<T> {\n  private skipping: boolean = true;\n  private index: number = 0;\n\n  constructor(destination: Subscriber<T>,\n              private predicate: (value: T, index: number) => boolean) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const destination = this.destination;\n    if (this.skipping) {\n      this.tryCallPredicate(value);\n    }\n\n    if (!this.skipping) {\n      destination.next(value);\n    }\n  }\n\n  private tryCallPredicate(value: T): void {\n    try {\n      const result = this.predicate(value, this.index++);\n      this.skipping = Boolean(result);\n    } catch (err) {\n      this.destination.error(err);\n    }\n  }\n}\n","import { Observable } from '../Observable';\nimport { concat } from '../observable/concat';\nimport { isScheduler } from '../util/isScheduler';\nimport { MonoTypeOperatorFunction, OperatorFunction, SchedulerLike } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D>(v1: D, scheduler: SchedulerLike): OperatorFunction<T, T | D>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D, E>(v1: D, v2: E, scheduler: SchedulerLike): OperatorFunction<T, T | D | E>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D, E, F>(v1: D, v2: E, v3: F, scheduler: SchedulerLike): OperatorFunction<T, T | D | E | F>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D, E, F, G>(v1: D, v2:  E, v3: F, v4: G, scheduler: SchedulerLike): OperatorFunction<T, T | D | E | F | G>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D, E, F, G, H>(v1: D, v2: E, v3: F, v4: G, v5: H, scheduler: SchedulerLike): OperatorFunction<T, T | D | E | F | G | H>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D, E, F, G, H, I>(v1: D, v2: E, v3: F, v4: G, v5: H, v6: I, scheduler: SchedulerLike): OperatorFunction<T, T | D | E | F | G | H | I>;\n\nexport function startWith<T, D>(v1: D): OperatorFunction<T, T | D>;\nexport function startWith<T, D, E>(v1: D, v2: E): OperatorFunction<T, T | D | E>;\nexport function startWith<T, D, E, F>(v1: D, v2: E, v3: F): OperatorFunction<T, T | D | E | F>;\nexport function startWith<T, D, E, F, G>(v1: D, v2:  E, v3: F, v4: G): OperatorFunction<T, T | D | E | F | G>;\nexport function startWith<T, D, E, F, G, H>(v1: D, v2: E, v3: F, v4: G, v5: H): OperatorFunction<T, T | D | E | F | G | H>;\nexport function startWith<T, D, E, F, G, H, I>(v1: D, v2: E, v3: F, v4: G, v5: H, v6: I): OperatorFunction<T, T | D | E | F | G | H | I>;\nexport function startWith<T, D = T>(...array: D[]): OperatorFunction<T, T | D>;\n/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([[a, b, c], source], scheduler).pipe(concatAll())`) */\nexport function startWith<T, D = T>(...array: Array<D | SchedulerLike>): OperatorFunction<T, T | D>;\n/* tslint:enable:max-line-length */\n\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 * <span class=\"informal\">First emits its arguments in order, and then any\n * emissions from the source.</span>\n *\n * ![](startWith.png)\n *\n * ## Examples\n *\n * Start the chain of emissions with `\"first\"`, `\"second\"`\n *\n * ```ts\n * import { of } from 'rxjs';\n * import { startWith } from 'rxjs/operators';\n *\n * of(\"from source\")\n *   .pipe(startWith(\"first\", \"second\"))\n *   .subscribe(x => console.log(x));\n *\n * // results:\n * //   \"first\"\n * //   \"second\"\n * //   \"from source\"\n * ```\n *\n * @param {...T} values - Items you want the modified Observable to emit first.\n * @param {SchedulerLike} [scheduler] - A {@link SchedulerLike} 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 */\nexport function startWith<T, D>(...array: Array<T | SchedulerLike>): OperatorFunction<T, T | D> {\n  const scheduler = array[array.length - 1] as SchedulerLike;\n  if (isScheduler(scheduler)) {\n    // deprecated path\n    array.pop();\n    return (source: Observable<T>) => concat(array as T[], source, scheduler);\n  } else {\n    return (source: Observable<T>) => concat(array as T[], source);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\nimport { map } from './map';\nimport { from } from '../observable/from';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector is no longer supported, use inner map instead */\nexport function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;\n/** @deprecated resultSelector is no longer supported, use inner map instead */\nexport function switchMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\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.</span>\n *\n * ![](switchMap.png)\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\n * Generate new Observable according to source Observable values\n * ```typescript\n * import { of } from 'rxjs';\n * import { switchMap } from 'rxjs/operators';\n *\n * const switched = of(1, 2, 3).pipe(switchMap((x: number) => of(x, x ** 2, x ** 3)));\n * switched.subscribe(x => console.log(x));\n * // outputs\n * // 1\n * // 1\n * // 1\n * // 2\n * // 4\n * // 8\n * // ... and so on\n * ```\n *\n * Rerun an interval Observable on every click event\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { switchMap } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(switchMap((ev) => interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switchAll}\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 * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional deprecated `resultSelector`) to each item\n * emitted by the source Observable and taking only the values from the most recently\n * projected inner Observable.\n * @method switchMap\n * @owner Observable\n */\nexport function switchMap<T, R, O extends ObservableInput<any>>(\n  project: (value: T, index: number) => O,\n  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R,\n): OperatorFunction<T, ObservedValueOf<O>|R> {\n  if (typeof resultSelector === 'function') {\n    return (source: Observable<T>) => source.pipe(\n      switchMap((a, i) => from(project(a, i)).pipe(\n        map((b, ii) => resultSelector(a, b, i, ii))\n      ))\n    );\n  }\n  return (source: Observable<T>) => source.lift(new SwitchMapOperator(project));\n}\n\nclass SwitchMapOperator<T, R> implements Operator<T, R> {\n  constructor(private project: (value: T, index: number) => ObservableInput<R>) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass SwitchMapSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private index = 0;\n  private innerSubscription?: Subscription;\n\n  constructor(destination: Subscriber<R>,\n              private project: (value: T, index: number) => ObservableInput<R>) {\n    super(destination);\n  }\n\n  protected _next(value: T) {\n    let result: ObservableInput<R>;\n    const index = this.index++;\n    try {\n      result = this.project(value, index);\n    } catch (error) {\n      this.destination.error!(error);\n      return;\n    }\n    this._innerSub(result);\n  }\n\n  private _innerSub(result: ObservableInput<R>) {\n    const innerSubscription = this.innerSubscription;\n    if (innerSubscription) {\n      innerSubscription.unsubscribe();\n    }\n    const innerSubscriber = new SimpleInnerSubscriber(this);\n    const destination = this.destination as Subscription;\n    destination.add(innerSubscriber);\n    this.innerSubscription = innerSubscribe(result, innerSubscriber);\n    // The returned subscription will usually be the subscriber that was\n    // passed. However, interop subscribers will be wrapped and for\n    // unsubscriptions to chain correctly, the wrapper needs to be added, too.\n    if (this.innerSubscription !== innerSubscriber) {\n      destination.add(this.innerSubscription);\n    }\n  }\n\n  protected _complete(): void {\n    const {innerSubscription} = this;\n    if (!innerSubscription || innerSubscription.closed) {\n      super._complete();\n    }\n    this.unsubscribe();\n  }\n\n  protected _unsubscribe() {\n    this.innerSubscription = undefined;\n  }\n\n  notifyComplete(): void {\n    this.innerSubscription = undefined;\n    if (this.isStopped) {\n      super._complete();\n    }\n  }\n\n  notifyNext(innerValue: R): void {\n      this.destination.next!(innerValue);\n  }\n}\n","import {OperatorFunction, ObservableInput} from '../types';\nimport { switchMap } from './switchMap';\nimport { identity } from '../util/identity';\n\nexport function switchAll<T>(): OperatorFunction<ObservableInput<T>, T>;\nexport function switchAll<R>(): OperatorFunction<any, R>;\n\n/**\n * Converts a higher-order Observable into a first-order Observable\n * producing values only from the most recent observable sequence\n *\n * <span class=\"informal\">Flattens an Observable-of-Observables.</span>\n *\n * ![](switchAll.png)\n *\n * `switchAll` subscribes to a source that is an observable of observables, also known as a\n * \"higher-order observable\" (or `Observable<Observable<T>>`). It subscribes to the most recently\n * provided \"inner observable\" emitted by the source, unsubscribing from any previously subscribed\n * to inner observable, such that only the most recent inner observable may be subscribed to at\n * any point in time. The resulting observable returned by `switchAll` will only complete if the\n * source observable completes, *and* any currently subscribed to inner observable also has completed,\n * if there are any.\n *\n * ## Examples\n * Spawn a new interval observable for each click event, but for every new\n * click, cancel the previous interval and subscribe to the new one.\n *\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { switchAll, map, tap } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click').pipe(tap(() => console.log('click')));\n * const source = clicks.pipe(map((ev) => interval(1000)));\n *\n * source.pipe(\n *   switchAll()\n * ).subscribe(x => console.log(x));\n *\n * // Output\n * // click\n * // 1\n * // 2\n * // 3\n * // 4\n * // ...\n * // click\n * // 1\n * // 2\n * // 3\n * // ...\n * // click\n * // ...\n * ```\n *\n * @see {@link combineAll}\n * @see {@link concatAll}\n * @see {@link exhaust}\n * @see {@link switchMap}\n * @see {@link switchMapTo}\n * @see {@link mergeAll}\n */\n\nexport function switchAll<T>(): OperatorFunction<ObservableInput<T>, T> {\n  return switchMap(identity);\n}\n","import { ObservableInput, OperatorFunction } from '../types';\nimport { switchMap } from './switchMap';\n\n/* tslint:disable:max-line-length */\nexport function switchMapTo<R>(observable: ObservableInput<R>): OperatorFunction<any, R>;\n/** @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map */\nexport function switchMapTo<T, R>(observable: ObservableInput<R>, resultSelector: undefined): OperatorFunction<T, R>;\n/** @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map */\nexport function switchMapTo<T, I, R>(observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * Projects each source value to the same Observable which is flattened multiple\n * times with {@link switchMap} in the output Observable.\n *\n * <span class=\"informal\">It's like {@link switchMap}, but maps each value\n * always to the same inner Observable.</span>\n *\n * ![](switchMapTo.png)\n *\n * Maps each source value to the given Observable `innerObservable` regardless\n * of the source value, and then flattens those resulting Observables into one\n * single Observable, which is the output Observable. The output Observables\n * emits values only from the most recently emitted instance of\n * `innerObservable`.\n *\n * ## Example\n * Rerun an interval Observable on every click event\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { switchMapTo } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(switchMapTo(interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link concatMapTo}\n * @see {@link switchAll}\n * @see {@link switchMap}\n * @see {@link mergeMapTo}\n *\n * @param {ObservableInput} innerObservable An Observable to replace each value from\n * the source Observable.\n * @return {Observable} An Observable that emits items from the given\n * `innerObservable` (and optionally transformed through the deprecated `resultSelector`)\n * every time a value is emitted on the source Observable, and taking only the values\n * from the most recently projected inner Observable.\n * @method switchMapTo\n * @owner Observable\n */\nexport function switchMapTo<T, I, R>(\n  innerObservable: ObservableInput<I>,\n  resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R\n): OperatorFunction<T, I|R> {\n  return resultSelector ? switchMap(() => innerObservable, resultSelector) : switchMap(() => innerObservable);\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\n\nimport { MonoTypeOperatorFunction, TeardownLogic } from '../types';\nimport { innerSubscribe, SimpleInnerSubscriber, SimpleOuterSubscriber } from '../innerSubscribe';\n\n/**\n * Emits the values emitted by the source Observable until a `notifier`\n * Observable emits a value.\n *\n * <span class=\"informal\">Lets values pass until a second Observable,\n * `notifier`, emits a value. Then, it completes.</span>\n *\n * ![](takeUntil.png)\n *\n * `takeUntil` subscribes and begins mirroring the source Observable. It also\n * monitors a second Observable, `notifier` that you provide. If the `notifier`\n * emits a value, the output Observable stops mirroring the source Observable\n * and completes. If the `notifier` doesn't emit any value and completes\n * then `takeUntil` will pass all values.\n *\n * ## Example\n * Tick every second until the first click happens\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { takeUntil } from 'rxjs/operators';\n *\n * const source = interval(1000);\n * const clicks = fromEvent(document, 'click');\n * const result = source.pipe(takeUntil(clicks));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link take}\n * @see {@link takeLast}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @param {Observable} notifier The Observable whose first emitted value will\n * cause the output Observable of `takeUntil` to stop emitting values from the\n * source Observable.\n * @return {Observable<T>} An Observable that emits the values from the source\n * Observable until such time as `notifier` emits its first value.\n * @method takeUntil\n * @owner Observable\n */\nexport function takeUntil<T>(notifier: Observable<any>): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new TakeUntilOperator(notifier));\n}\n\nclass TakeUntilOperator<T> implements Operator<T, T> {\n  constructor(private notifier: Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    const takeUntilSubscriber = new TakeUntilSubscriber(subscriber);\n    const notifierSubscription = innerSubscribe(this.notifier, new SimpleInnerSubscriber(takeUntilSubscriber));\n    if (notifierSubscription && !takeUntilSubscriber.seenValue) {\n      takeUntilSubscriber.add(notifierSubscription);\n      return source.subscribe(takeUntilSubscriber);\n    }\n    return takeUntilSubscriber;\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass TakeUntilSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  seenValue = false;\n\n  constructor(destination: Subscriber<any>, ) {\n    super(destination);\n  }\n\n  notifyNext(): void {\n    this.seenValue = true;\n    this.complete();\n  }\n\n  notifyComplete(): void {\n    // noop\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { OperatorFunction, MonoTypeOperatorFunction, TeardownLogic } from '../types';\n\nexport function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;\nexport function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;\nexport function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;\n\n/**\n * Emits values emitted by the source Observable so long as each value satisfies\n * the given `predicate`, and then completes as soon as this `predicate` is not\n * satisfied.\n *\n * <span class=\"informal\">Takes values from the source only while they pass the\n * condition given. When the first value does not satisfy, it completes.</span>\n *\n * ![](takeWhile.png)\n *\n * `takeWhile` subscribes and begins mirroring the source Observable. Each value\n * emitted on the source is given to the `predicate` function which returns a\n * boolean, representing a condition to be satisfied by the source values. The\n * output Observable emits the source values until such time as the `predicate`\n * returns false, at which point `takeWhile` stops mirroring the source\n * Observable and completes the output Observable.\n *\n * ## Example\n * Emit click events only while the clientX property is greater than 200\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { takeWhile } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(takeWhile(ev => ev.clientX > 200));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link take}\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates a value emitted by the source Observable and returns a boolean.\n * Also takes the (zero-based) index as the second argument.\n * @param {boolean} inclusive When set to `true` the value that caused\n * `predicate` to return `false` will also be emitted.\n * @return {Observable<T>} An Observable that emits the values from the source\n * Observable so long as each value satisfies the condition defined by the\n * `predicate`, then completes.\n * @method takeWhile\n * @owner Observable\n */\nexport function takeWhile<T>(\n    predicate: (value: T, index: number) => boolean,\n    inclusive = false): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) =>\n             source.lift(new TakeWhileOperator(predicate, inclusive));\n}\n\nclass TakeWhileOperator<T> implements Operator<T, T> {\n  constructor(\n      private predicate: (value: T, index: number) => boolean,\n      private inclusive: boolean) {}\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(\n        new TakeWhileSubscriber(subscriber, this.predicate, this.inclusive));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass TakeWhileSubscriber<T> extends Subscriber<T> {\n  private index: number = 0;\n\n  constructor(\n      destination: Subscriber<T>,\n      private predicate: (value: T, index: number) => boolean,\n      private inclusive: boolean) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    const destination = this.destination;\n    let result: boolean;\n    try {\n      result = this.predicate(value, this.index++);\n    } catch (err) {\n      destination.error(err);\n      return;\n    }\n    this.nextOrComplete(value, result);\n  }\n\n  private nextOrComplete(value: T, predicateResult: boolean): void {\n    const destination = this.destination;\n    if (Boolean(predicateResult)) {\n      destination.next(value);\n    } else {\n      if (this.inclusive) {\n        destination.next(value);\n      }\n      destination.complete();\n    }\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { MonoTypeOperatorFunction, PartialObserver, TeardownLogic } from '../types';\nimport { noop } from '../util/noop';\nimport { isFunction } from '../util/isFunction';\n\n/* tslint:disable:max-line-length */\n/** @deprecated Use an observer instead of a complete callback */\nexport function tap<T>(next: null | undefined, error: null | undefined, complete: () => void): MonoTypeOperatorFunction<T>;\n/** @deprecated Use an observer instead of an error callback */\nexport function tap<T>(next: null | undefined, error: (error: any) => void, complete?: () => void): MonoTypeOperatorFunction<T>;\n/** @deprecated Use an observer instead of a complete callback */\nexport function tap<T>(next: (value: T) => void, error: null | undefined, complete: () => void): MonoTypeOperatorFunction<T>;\nexport function tap<T>(next?: (x: T) => void, error?: (e: any) => void, complete?: () => void): MonoTypeOperatorFunction<T>;\nexport function tap<T>(observer: PartialObserver<T>): MonoTypeOperatorFunction<T>;\n/* tslint:enable:max-line-length */\n\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 * ![](do.png)\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 `tap` is not subscribed, the side effects specified by the\n * Observer will never happen. `tap` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * ## Example\n * Map every click to the clientX position of that click, while also logging the click event\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { tap, map } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const positions = clicks.pipe(\n *   tap(ev => console.log(ev)),\n *   map(ev => ev.clientX),\n * );\n * positions.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link map}\n * @see {@link Observable#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 */\nexport function tap<T>(nextOrObserver?: PartialObserver<T> | ((x: T) => void),\n                       error?: (e: any) => void,\n                       complete?: () => void): MonoTypeOperatorFunction<T> {\n  return function tapOperatorFunction(source: Observable<T>): Observable<T> {\n    return source.lift(new DoOperator(nextOrObserver, error, complete));\n  };\n}\n\nclass DoOperator<T> implements Operator<T, T> {\n  constructor(private nextOrObserver?: PartialObserver<T> | ((x: T) => void),\n              private error?: (e: any) => void,\n              private complete?: () => void) {\n  }\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new TapSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\n\nclass TapSubscriber<T> extends Subscriber<T> {\n  private _context: any;\n\n  private _tapNext: ((value: T) => void) = noop;\n\n  private _tapError: ((err: any) => void) = noop;\n\n  private _tapComplete: (() => void) = noop;\n\n  constructor(destination: Subscriber<T>,\n              observerOrNext?: PartialObserver<T> | ((value: T) => void),\n              error?: (e?: any) => void,\n              complete?: () => void) {\n      super(destination);\n      this._tapError = error || noop;\n      this._tapComplete = complete || noop;\n      if (isFunction(observerOrNext)) {\n        this._context = this;\n        this._tapNext = observerOrNext;\n      } else if (observerOrNext) {\n        this._context = observerOrNext;\n        this._tapNext = observerOrNext.next || noop;\n        this._tapError = observerOrNext.error || noop;\n        this._tapComplete = observerOrNext.complete || noop;\n      }\n    }\n\n  _next(value: T) {\n    try {\n      this._tapNext.call(this._context, value);\n    } catch (err) {\n      this.destination.error(err);\n      return;\n    }\n    this.destination.next(value);\n  }\n\n  _error(err: any) {\n    try {\n      this._tapError.call(this._context, err);\n    } catch (err) {\n      this.destination.error(err);\n      return;\n    }\n    this.destination.error(err);\n  }\n\n  _complete() {\n    try {\n      this._tapComplete.call(this._context, );\n    } catch (err) {\n      this.destination.error(err);\n      return;\n    }\n    return this.destination.complete();\n  }\n}\n","import { Operator } from '../Operator';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\n\nimport { MonoTypeOperatorFunction, SubscribableOrPromise, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\nexport interface ThrottleConfig {\n  leading?: boolean;\n  trailing?: boolean;\n}\n\nexport const defaultThrottleConfig: ThrottleConfig = {\n  leading: true,\n  trailing: false\n};\n\n/**\n * Emits a value from the source Observable, then ignores subsequent source\n * values for a duration determined by another Observable, then repeats this\n * process.\n *\n * <span class=\"informal\">It's like {@link throttleTime}, but the silencing\n * duration is determined by a second Observable.</span>\n *\n * ![](throttle.png)\n *\n * `throttle` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled by calling the `durationSelector` function with the source value,\n * which returns the \"duration\" Observable. When the duration Observable emits a\n * value or completes, the timer is disabled, and this process repeats for the\n * next source value.\n *\n * ## Example\n * Emit clicks at a rate of at most one click per second\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { throttle } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(throttle(ev => interval(1000)));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link audit}\n * @see {@link debounce}\n * @see {@link delayWhen}\n * @see {@link sample}\n * @see {@link throttleTime}\n *\n * @param {function(value: T): SubscribableOrPromise} durationSelector A function\n * that receives a value from the source Observable, for computing the silencing\n * duration for each source value, returned as an Observable or a Promise.\n * @param {Object} config a configuration object to define `leading` and `trailing` behavior. Defaults\n * to `{ leading: true, trailing: false }`.\n * @return {Observable<T>} An Observable that performs the throttle operation to\n * limit the rate of emissions from the source.\n * @method throttle\n * @owner Observable\n */\nexport function throttle<T>(durationSelector: (value: T) => SubscribableOrPromise<any>,\n                            config: ThrottleConfig = defaultThrottleConfig): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new ThrottleOperator(durationSelector, !!config.leading, !!config.trailing));\n}\n\nclass ThrottleOperator<T> implements Operator<T, T> {\n  constructor(private durationSelector: (value: T) => SubscribableOrPromise<any>,\n              private leading: boolean,\n              private trailing: boolean) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(\n      new ThrottleSubscriber(subscriber, this.durationSelector, this.leading, this.trailing)\n    );\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc\n * @ignore\n * @extends {Ignored}\n */\nclass ThrottleSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n  private _throttled?: Subscription;\n  private _sendValue?: T;\n  private _hasValue = false;\n\n  constructor(protected destination: Subscriber<T>,\n              private durationSelector: (value: T) => SubscribableOrPromise<number>,\n              private _leading: boolean,\n              private _trailing: boolean) {\n    super(destination);\n  }\n\n  protected _next(value: T): void {\n    this._hasValue = true;\n    this._sendValue = value;\n\n    if (!this._throttled) {\n      if (this._leading) {\n        this.send();\n      } else {\n        this.throttle(value);\n      }\n    }\n  }\n\n  private send() {\n    const { _hasValue, _sendValue } = this;\n    if (_hasValue) {\n      this.destination.next(_sendValue);\n      this.throttle(_sendValue!);\n    }\n    this._hasValue = false;\n    this._sendValue = undefined;\n  }\n\n  private throttle(value: T): void {\n    const duration = this.tryDurationSelector(value);\n    if (!!duration) {\n      this.add(this._throttled = innerSubscribe(duration, new SimpleInnerSubscriber(this)));\n    }\n  }\n\n  private tryDurationSelector(value: T): SubscribableOrPromise<any> | null {\n    try {\n      return this.durationSelector(value);\n    } catch (err) {\n      this.destination.error(err);\n      return null;\n    }\n  }\n\n  private throttlingDone() {\n    const { _throttled, _trailing } = this;\n    if (_throttled) {\n      _throttled.unsubscribe();\n    }\n    this._throttled = undefined;\n\n    if (_trailing) {\n      this.send();\n    }\n  }\n\n  notifyNext(): void {\n    this.throttlingDone();\n  }\n\n  notifyComplete(): void {\n    this.throttlingDone();\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { async } from '../scheduler/async';\nimport { Observable } from '../Observable';\nimport { ThrottleConfig, defaultThrottleConfig } from './throttle';\nimport { MonoTypeOperatorFunction, SchedulerLike, TeardownLogic } from '../types';\n\n/**\n * Emits a value from the source Observable, then ignores subsequent source\n * values for `duration` milliseconds, then repeats this process.\n *\n * <span class=\"informal\">Lets a value pass, then ignores source values for the\n * next `duration` milliseconds.</span>\n *\n * ![](throttleTime.png)\n *\n * `throttleTime` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled. After `duration` milliseconds (or the time unit determined\n * internally by the optional `scheduler`) has passed, the timer is disabled,\n * and this process repeats for the next source value. Optionally takes a\n * {@link SchedulerLike} for managing timers.\n *\n * ## Examples\n *\n * #### Limit click rate\n *\n * Emit clicks at a rate of at most one click per second\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { throttleTime } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(throttleTime(1000));\n * result.subscribe(x => console.log(x));\n * ```\n *\n * #### Double Click\n *\n * The following example only emits clicks which happen within a subsequent\n * delay of 400ms of the previous click. This for example can emulate a double\n * click. It makes use of the `trailing` parameter of the throttle configuration.\n *\n * ```ts\n * import { fromEvent, asyncScheduler } from 'rxjs';\n * import { throttleTime, withLatestFrom } from 'rxjs/operators';\n *\n * // defaultThottleConfig = { leading: true, trailing: false }\n * const throttleConfig = {\n *   leading: false,\n *   trailing: true\n * }\n *\n * const click = fromEvent(document, 'click');\n * const doubleClick = click.pipe(\n *   throttleTime(400, asyncScheduler, throttleConfig)\n * );\n *\n * doubleClick.subscribe((throttleValue: Event) => {\n *   console.log(`Double-clicked! Timestamp: ${throttleValue.timeStamp}`);\n * });\n * ```\n *\n * If you enable the `leading` parameter in this example, the output would be the primary click and\n * the double click, but restricts additional clicks within 400ms.\n *\n * @see {@link auditTime}\n * @see {@link debounceTime}\n * @see {@link delay}\n * @see {@link sampleTime}\n * @see {@link throttle}\n *\n * @param {number} duration Time to wait before emitting another value after\n * emitting the last value, measured in milliseconds or the time unit determined\n * internally by the optional `scheduler`.\n * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for\n * managing the timers that handle the throttling.\n * @param {Object} config a configuration object to define `leading` and\n * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.\n * @return {Observable<T>} An Observable that performs the throttle operation to\n * limit the rate of emissions from the source.\n * @method throttleTime\n * @owner Observable\n */\nexport function throttleTime<T>(duration: number,\n                                scheduler: SchedulerLike = async,\n                                config: ThrottleConfig = defaultThrottleConfig): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => source.lift(new ThrottleTimeOperator(duration, scheduler, config.leading, config.trailing));\n}\n\nclass ThrottleTimeOperator<T> implements Operator<T, T> {\n  constructor(private duration: number,\n              private scheduler: SchedulerLike,\n              private leading: boolean,\n              private trailing: boolean) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(\n      new ThrottleTimeSubscriber(subscriber, this.duration, this.scheduler, this.leading, this.trailing)\n    );\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass ThrottleTimeSubscriber<T> extends Subscriber<T> {\n  private throttled: Subscription;\n  private _hasTrailingValue: boolean = false;\n  private _trailingValue: T = null;\n\n  constructor(destination: Subscriber<T>,\n              private duration: number,\n              private scheduler: SchedulerLike,\n              private leading: boolean,\n              private trailing: boolean) {\n    super(destination);\n  }\n\n  protected _next(value: T) {\n    if (this.throttled) {\n      if (this.trailing) {\n        this._trailingValue = value;\n        this._hasTrailingValue = true;\n      }\n    } else {\n      this.add(this.throttled = this.scheduler.schedule<DispatchArg<T>>(dispatchNext, this.duration, { subscriber: this }));\n      if (this.leading) {\n        this.destination.next(value);\n      } else if (this.trailing) {\n        this._trailingValue = value;\n        this._hasTrailingValue = true;\n      }\n    }\n  }\n\n  protected _complete() {\n    if (this._hasTrailingValue) {\n      this.destination.next(this._trailingValue);\n      this.destination.complete();\n    } else {\n      this.destination.complete();\n    }\n  }\n\n  clearThrottle() {\n    const throttled = this.throttled;\n    if (throttled) {\n      if (this.trailing && this._hasTrailingValue) {\n        this.destination.next(this._trailingValue);\n        this._trailingValue = null;\n        this._hasTrailingValue = false;\n      }\n      throttled.unsubscribe();\n      this.remove(throttled);\n      this.throttled = null;\n    }\n  }\n}\n\ninterface DispatchArg<T> {\n  subscriber: ThrottleTimeSubscriber<T>;\n}\n\nfunction dispatchNext<T>(arg: DispatchArg<T>) {\n  const { subscriber } = arg;\n  subscriber.clearThrottle();\n}\n","\nimport { Observable } from '../Observable';\nimport { async } from '../scheduler/async';\nimport { SchedulerLike, OperatorFunction } from '../types';\nimport { scan } from './scan';\nimport { defer } from '../observable/defer';\nimport { map } from './map';\n\n/**\n *\n * Emits an object containing the current value, and the time that has\n * passed between emitting the current value and the previous value, which is\n * calculated by using the provided `scheduler`'s `now()` method to retrieve\n * the current time at each emission, then calculating the difference. The `scheduler`\n * defaults to {@link asyncScheduler}, so by default, the `interval` will be in\n * milliseconds.\n *\n * <span class=\"informal\">Convert an Observable that emits items into one that\n * emits indications of the amount of time elapsed between those emissions.</span>\n *\n * ![](timeinterval.png)\n *\n * ## Examples\n * Emit inteval between current value with the last value\n *\n * ```ts\n * const seconds = interval(1000);\n *\n * seconds.pipe(timeInterval())\n * .subscribe(\n *     value => console.log(value),\n *     err => console.log(err),\n * );\n *\n * seconds.pipe(timeout(900))\n * .subscribe(\n *     value => console.log(value),\n *     err => console.log(err),\n * );\n *\n * // NOTE: The values will never be this precise,\n * // intervals created with `interval` or `setInterval`\n * // are non-deterministic.\n *\n * // {value: 0, interval: 1000}\n * // {value: 1, interval: 1000}\n * // {value: 2, interval: 1000}\n * ```\n *\n * @param {SchedulerLike} [scheduler] Scheduler used to get the current time.\n * @return {Observable<{ interval: number, value: T }>} Observable that emit infomation about value and interval\n * @method timeInterval\n */\nexport function timeInterval<T>(scheduler: SchedulerLike = async): OperatorFunction<T, TimeInterval<T>> {\n  return (source: Observable<T>) => defer(() => {\n    return source.pipe(\n      // TODO(benlesh): correct these typings.\n      scan(\n        ({ current }, value) => ({ value, current: scheduler.now(), last: current }),\n        { current: scheduler.now(), value: undefined,  last: undefined }\n      ) as any,\n      map<any, TimeInterval<T>>(({ current, last, value }) => new TimeInterval(value, current - last)),\n    );\n  });\n}\n\n// TODO(benlesh): make this an interface, export the interface, but not the implemented class,\n// there's no reason users should be manually creating this type.\n\n/**\n * @deprecated exposed API, use as interface only.\n */\nexport class TimeInterval<T> {\n  constructor(public value: T, public interval: number) {}\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { async } from '../scheduler/async';\nimport { Observable } from '../Observable';\nimport { isDate } from '../util/isDate';\nimport { ObservableInput, OperatorFunction, SchedulerAction, SchedulerLike, TeardownLogic } from '../types';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/* tslint:disable:max-line-length */\nexport function timeoutWith<T, R>(due: number | Date, withObservable: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;\n/* tslint:enable:max-line-length */\n\n/**\n *\n * Errors if Observable does not emit a value in given time span, in case of which\n * subscribes to the second Observable.\n *\n * <span class=\"informal\">It's a version of `timeout` operator that let's you specify fallback Observable.</span>\n *\n * ![](timeoutWith.png)\n *\n * `timeoutWith` is a variation of `timeout` operator. It behaves exactly the same,\n * still accepting as a first argument either a number or a Date, which control - respectively -\n * when values of source Observable should be emitted or when it should complete.\n *\n * The only difference is that it accepts a second, required parameter. This parameter\n * should be an Observable which will be subscribed when source Observable fails any timeout check.\n * So whenever regular `timeout` would emit an error, `timeoutWith` will instead start re-emitting\n * values from second Observable. Note that this fallback Observable is not checked for timeouts\n * itself, so it can emit values and complete at arbitrary points in time. From the moment of a second\n * subscription, Observable returned from `timeoutWith` simply mirrors fallback stream. When that\n * stream completes, it completes as well.\n *\n * Scheduler, which in case of `timeout` is provided as as second argument, can be still provided\n * here - as a third, optional parameter. It still is used to schedule timeout checks and -\n * as a consequence - when second Observable will be subscribed, since subscription happens\n * immediately after failing check.\n *\n * ## Example\n * Add fallback observable\n * ```ts\n * import { interval } from 'rxjs';\n * import { timeoutWith } from 'rxjs/operators';\n *\n * const seconds = interval(1000);\n * const minutes = interval(60 * 1000);\n *\n * seconds.pipe(timeoutWith(900, minutes))\n *   .subscribe(\n *     value => console.log(value), // After 900ms, will start emitting `minutes`,\n *                                  // since first value of `seconds` will not arrive fast enough.\n *     err => console.log(err),     // Would be called after 900ms in case of `timeout`,\n *                                  // but here will never be called.\n *   );\n * ```\n *\n * @param {number|Date} due Number specifying period within which Observable must emit values\n *                          or Date specifying before when Observable should complete\n * @param {Observable<T>} withObservable Observable which will be subscribed if source fails timeout check.\n * @param {SchedulerLike} [scheduler] Scheduler controlling when timeout checks occur.\n * @return {Observable<T>} Observable that mirrors behaviour of source or, when timeout check fails, of an Observable\n *                          passed as a second parameter.\n * @method timeoutWith\n * @owner Observable\n */\nexport function timeoutWith<T, R>(due: number | Date,\n                                  withObservable: ObservableInput<R>,\n                                  scheduler: SchedulerLike = async): OperatorFunction<T, T | R> {\n  return (source: Observable<T>) => {\n    let absoluteTimeout = isDate(due);\n    let waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(<number>due);\n    return source.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler));\n  };\n}\n\nclass TimeoutWithOperator<T> implements Operator<T, T> {\n  constructor(private waitFor: number,\n              private absoluteTimeout: boolean,\n              private withObservable: ObservableInput<any>,\n              private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<T>, source: any): TeardownLogic {\n    return source.subscribe(new TimeoutWithSubscriber(\n      subscriber, this.absoluteTimeout, this.waitFor, this.withObservable, this.scheduler\n    ));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass TimeoutWithSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {\n\n  private action?: SchedulerAction<TimeoutWithSubscriber<T, R>>;\n\n  constructor(destination: Subscriber<T>,\n              private absoluteTimeout: boolean,\n              private waitFor: number,\n              private withObservable: ObservableInput<any>,\n              private scheduler: SchedulerLike) {\n    super(destination);\n    this.scheduleTimeout();\n  }\n\n  private static dispatchTimeout<T, R>(subscriber: TimeoutWithSubscriber<T, R>): void {\n    const { withObservable } = subscriber;\n    subscriber._unsubscribeAndRecycle();\n    subscriber.add(innerSubscribe(withObservable, new SimpleInnerSubscriber(subscriber)));\n  }\n\n  private scheduleTimeout(): void {\n    const { action } = this;\n    if (action) {\n      // Recycle the action if we've already scheduled one. All the production\n      // Scheduler Actions mutate their state/delay time and return themeselves.\n      // VirtualActions are immutable, so they create and return a clone. In this\n      // case, we need to set the action reference to the most recent VirtualAction,\n      // to ensure that's the one we clone from next time.\n      this.action = (<SchedulerAction<TimeoutWithSubscriber<T, R>>> action.schedule(this, this.waitFor));\n    } else {\n      this.add(this.action = (<SchedulerAction<TimeoutWithSubscriber<T, R>>> this.scheduler.schedule<TimeoutWithSubscriber<T, R>>(\n        TimeoutWithSubscriber.dispatchTimeout as any, this.waitFor, this\n      )));\n    }\n  }\n\n  protected _next(value: T): void {\n    if (!this.absoluteTimeout) {\n      this.scheduleTimeout();\n    }\n    super._next(value);\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    this.action = undefined;\n    this.scheduler = null!;\n    this.withObservable = null!;\n  }\n}\n","import { async } from '../scheduler/async';\nimport { isDate } from '../util/isDate';\nimport { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { TimeoutError } from '../util/TimeoutError';\nimport { MonoTypeOperatorFunction, SchedulerAction, SchedulerLike, TeardownLogic } from '../types';\nimport { timeoutWith } from './timeoutWith';\nimport { throwError } from '../observable/throwError';\n\n/**\n *\n * Errors if Observable does not emit a value in given time span.\n *\n * <span class=\"informal\">Timeouts on Observable that doesn't emit values fast enough.</span>\n *\n * ![](timeout.png)\n *\n * `timeout` operator accepts as an argument either a number or a Date.\n *\n * If number was provided, it returns an Observable that behaves like a source\n * Observable, unless there is a period of time where there is no value emitted.\n * So if you provide `100` as argument and first value comes after 50ms from\n * the moment of subscription, this value will be simply re-emitted by the resulting\n * Observable. If however after that 100ms passes without a second value being emitted,\n * stream will end with an error and source Observable will be unsubscribed.\n * These checks are performed throughout whole lifecycle of Observable - from the moment\n * it was subscribed to, until it completes or errors itself. Thus every value must be\n * emitted within specified period since previous value.\n *\n * If provided argument was Date, returned Observable behaves differently. It throws\n * if Observable did not complete before provided Date. This means that periods between\n * emission of particular values do not matter in this case. If Observable did not complete\n * before provided Date, source Observable will be unsubscribed. Other than that, resulting\n * stream behaves just as source Observable.\n *\n * `timeout` accepts also a Scheduler as a second parameter. It is used to schedule moment (or moments)\n * when returned Observable will check if source stream emitted value or completed.\n *\n * ## Examples\n * Check if ticks are emitted within certain timespan\n * ```ts\n * import { interval } from 'rxjs';\n * import { timeout } from 'rxjs/operators';\n *\n * const seconds = interval(1000);\n *\n * seconds.pipe(timeout(1100))      // Let's use bigger timespan to be safe,\n *                                  // since `interval` might fire a bit later then scheduled.\n * .subscribe(\n *     value => console.log(value), // Will emit numbers just as regular `interval` would.\n *     err => console.log(err),     // Will never be called.\n * );\n *\n * seconds.pipe(timeout(900))\n * .subscribe(\n *     value => console.log(value), // Will never be called.\n *     err => console.log(err),     // Will emit error before even first value is emitted,\n *                                  // since it did not arrive within 900ms period.\n * );\n * ```\n *\n * Use Date to check if Observable completed\n * ```ts\n * import { interval } from 'rxjs';\n * import { timeout } from 'rxjs/operators';\n *\n * const seconds = interval(1000);\n *\n * seconds.pipe(\n *   timeout(new Date(\"December 17, 2020 03:24:00\")),\n * )\n * .subscribe(\n *     value => console.log(value), // Will emit values as regular `interval` would\n *                                  // until December 17, 2020 at 03:24:00.\n *     err => console.log(err)      // On December 17, 2020 at 03:24:00 it will emit an error,\n *                                  // since Observable did not complete by then.\n * );\n * ```\n * @see {@link timeoutWith}\n *\n * @param {number|Date} due Number specifying period within which Observable must emit values\n *                          or Date specifying before when Observable should complete\n * @param {SchedulerLike} [scheduler] Scheduler controlling when timeout checks occur.\n * @return {Observable<T>} Observable that mirrors behaviour of source, unless timeout checks fail.\n * @method timeout\n * @owner Observable\n */\nexport function timeout<T>(due: number | Date,\n                           scheduler: SchedulerLike = async): MonoTypeOperatorFunction<T> {\n  return timeoutWith(due, throwError(new TimeoutError()), scheduler);\n}\n","\nimport { async } from '../scheduler/async';\nimport { OperatorFunction, SchedulerLike, Timestamp as TimestampInterface } from '../types';\nimport { map } from './map';\n\n/**\n * Attaches a timestamp to each item emitted by an observable indicating when it was emitted\n *\n * The `timestamp` operator maps the *source* observable stream to an object of type\n * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value\n * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By\n * default it uses the *async* scheduler which simply returns `Date.now()` (milliseconds since 1970/01/01\n * 00:00:00:000) and therefore is of type `number`.\n *\n * ![](timestamp.png)\n *\n * ## Example\n *\n * In this example there is a timestamp attached to the documents click event.\n *\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { timestamp } from 'rxjs/operators';\n *\n * const clickWithTimestamp = fromEvent(document, 'click').pipe(\n *   timestamp()\n * );\n *\n * // Emits data of type {value: MouseEvent, timestamp: number}\n * clickWithTimestamp.subscribe(data => {\n *   console.log(data);\n * });\n * ```\n *\n * @param scheduler\n * @return {Observable<Timestamp<any>>|WebSocketSubject<T>|Observable<T>}\n * @method timestamp\n * @owner Observable\n */\nexport function timestamp<T>(scheduler: SchedulerLike = async): OperatorFunction<T, Timestamp<T>> {\n  return map((value: T) => new Timestamp(value, scheduler.now()));\n  // return (source: Observable<T>) => source.lift(new TimestampOperator(scheduler));\n}\n\nexport class Timestamp<T> implements TimestampInterface<T> {\n  constructor(public value: T, public timestamp: number) {\n  }\n}\n","import { reduce } from './reduce';\nimport { OperatorFunction } from '../types';\n\nfunction toArrayReducer<T>(arr: T[], item: T, index: number) {\n  if (index === 0) {\n    return [item];\n  }\n  arr.push(item);\n  return arr;\n}\n\n/**\n * Collects all source emissions and emits them as an array when the source completes.\n *\n * <span class=\"informal\">Get all values inside an array when the source completes</span>\n *\n * ![](toArray.png)\n *\n * `toArray` will wait until the source Observable completes before emitting\n * the array containing all emissions. When the source Observable errors no\n * array will be emitted.\n *\n *  ## Example\n * ```ts\n * import { interval } from 'rxjs';\n * import { toArray, take } from 'rxjs/operators';\n *\n * const source = interval(1000);\n * const example = source.pipe(\n *   take(10),\n *   toArray()\n * );\n *\n * const subscribe = example.subscribe(val => console.log(val));\n *\n * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n *\n * ```\n* @return An array from an observable sequence.\n* @method toArray\n* @owner Observable\n*/\nexport function toArray<T>(): OperatorFunction<T, T[]> {\n  return reduce(toArrayReducer, [] as T[]);\n}\n","import { Observable } from '../Observable';\nimport { OperatorFunction } from '../types';\nimport { Subject } from '../Subject';\nimport { Subscriber } from '../Subscriber';\nimport { Operator } from '../Operator';\nimport { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';\n\n/**\n * Branch out the source Observable values as a nested Observable whenever\n * `windowBoundaries` emits.\n *\n * <span class=\"informal\">It's like {@link buffer}, but emits a nested Observable\n * instead of an array.</span>\n *\n * ![](window.png)\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits connected, non-overlapping\n * windows. It emits the current window and opens a new one whenever the\n * Observable `windowBoundaries` emits an item. Because each window is an\n * Observable, the output is a higher-order Observable.\n *\n * ## Example\n * In every window of 1 second each, emit at most 2 click events\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { window, mergeAll, map, take } from 'rxjs/operators';\n *\n *  const clicks = fromEvent(document, 'click');\n *  const sec = interval(1000);\n *  const result = clicks.pipe(\n *      window(sec),\n *      map(win => win.pipe(take(2))), // each window has at most 2 emissions\n *      mergeAll(),              // flatten the Observable-of-Observables\n *  );\n *  result.subscribe(x => console.log(x));\n * ```\n * @see {@link windowCount}\n * @see {@link windowTime}\n * @see {@link windowToggle}\n * @see {@link windowWhen}\n * @see {@link buffer}\n *\n * @param {Observable<any>} windowBoundaries An Observable that completes the\n * previous window and starts a new window.\n * @return {Observable<Observable<T>>} An Observable of windows, which are\n * Observables emitting values of the source Observable.\n * @method window\n * @owner Observable\n */\nexport function window<T>(windowBoundaries: Observable<any>): OperatorFunction<T, Observable<T>> {\n  return function windowOperatorFunction(source: Observable<T>) {\n    return source.lift(new WindowOperator(windowBoundaries));\n  };\n}\n\nclass WindowOperator<T> implements Operator<T, Observable<T>> {\n\n  constructor(private windowBoundaries: Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<Observable<T>>, source: any): any {\n    const windowSubscriber = new WindowSubscriber(subscriber);\n    const sourceSubscription = source.subscribe(windowSubscriber);\n    if (!sourceSubscription.closed) {\n      windowSubscriber.add(innerSubscribe(this.windowBoundaries, new SimpleInnerSubscriber(windowSubscriber)));\n    }\n    return sourceSubscription;\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WindowSubscriber<T> extends SimpleOuterSubscriber<T, any> {\n\n  private window: Subject<T> = new Subject<T>();\n\n  constructor(destination: Subscriber<Observable<T>>) {\n    super(destination);\n    destination.next(this.window);\n  }\n\n  notifyNext(): void {\n    this.openWindow();\n  }\n\n  notifyError(error: any): void {\n    this._error(error);\n  }\n\n  notifyComplete(): void {\n    this._complete();\n  }\n\n  protected _next(value: T): void {\n    this.window.next(value);\n  }\n\n  protected _error(err: any): void {\n    this.window.error(err);\n    this.destination.error!(err);\n  }\n\n  protected _complete(): void {\n    this.window.complete();\n    this.destination.complete!();\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    this.window = null!;\n  }\n\n  private openWindow(): void  {\n    const prevWindow = this.window;\n    if (prevWindow) {\n      prevWindow.complete();\n    }\n    const destination = this.destination;\n    const newWindow = this.window = new Subject<T>();\n    destination.next!(newWindow);\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { OperatorFunction } from '../types';\n\n/**\n * Branch out the source Observable values as a nested Observable with each\n * nested Observable emitting at most `windowSize` values.\n *\n * <span class=\"informal\">It's like {@link bufferCount}, but emits a nested\n * Observable instead of an array.</span>\n *\n * ![](windowCount.png)\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits windows every `startWindowEvery`\n * items, each containing no more than `windowSize` items. When the source\n * Observable completes or encounters an error, the output Observable emits\n * the current window and propagates the notification from the source\n * Observable. If `startWindowEvery` is not provided, then new windows are\n * started immediately at the start of the source and when each window completes\n * with size `windowSize`.\n *\n * ## Examples\n * Ignore every 3rd click event, starting from the first one\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { windowCount, map, mergeAll, skip } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowCount(3),\n *   map(win => win.pipe(skip(1))), // skip first of every 3 clicks\n *   mergeAll()                     // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * Ignore every 3rd click event, starting from the third one\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { windowCount, mergeAll } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowCount(2, 3),\n *   mergeAll(),              // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link window}\n * @see {@link windowTime}\n * @see {@link windowToggle}\n * @see {@link windowWhen}\n * @see {@link bufferCount}\n *\n * @param {number} windowSize The maximum number of values emitted by each\n * window.\n * @param {number} [startWindowEvery] Interval at which to start a new window.\n * For example if `startWindowEvery` is `2`, then a new window will be started\n * on every other value from the source. A new window is started at the\n * beginning of the source by default.\n * @return {Observable<Observable<T>>} An Observable of windows, which in turn\n * are Observable of values.\n * @method windowCount\n * @owner Observable\n */\nexport function windowCount<T>(windowSize: number,\n                               startWindowEvery: number = 0): OperatorFunction<T, Observable<T>> {\n  return function windowCountOperatorFunction(source: Observable<T>) {\n    return source.lift(new WindowCountOperator<T>(windowSize, startWindowEvery));\n  };\n}\n\nclass WindowCountOperator<T> implements Operator<T, Observable<T>> {\n\n  constructor(private windowSize: number,\n              private startWindowEvery: number) {\n  }\n\n  call(subscriber: Subscriber<Observable<T>>, source: any): any {\n    return source.subscribe(new WindowCountSubscriber(subscriber, this.windowSize, this.startWindowEvery));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WindowCountSubscriber<T> extends Subscriber<T> {\n  private windows: Subject<T>[] = [ new Subject<T>() ];\n  private count: number = 0;\n\n  constructor(protected destination: Subscriber<Observable<T>>,\n              private windowSize: number,\n              private startWindowEvery: number) {\n    super(destination);\n    destination.next(this.windows[0]);\n  }\n\n  protected _next(value: T) {\n    const startWindowEvery = (this.startWindowEvery > 0) ? this.startWindowEvery : this.windowSize;\n    const destination = this.destination;\n    const windowSize = this.windowSize;\n    const windows = this.windows;\n    const len = windows.length;\n\n    for (let i = 0; i < len && !this.closed; i++) {\n      windows[i].next(value);\n    }\n    const c = this.count - windowSize + 1;\n    if (c >= 0 && c % startWindowEvery === 0 && !this.closed) {\n      windows.shift().complete();\n    }\n    if (++this.count % startWindowEvery === 0 && !this.closed) {\n      const window = new Subject<T>();\n      windows.push(window);\n      destination.next(window);\n    }\n  }\n\n  protected _error(err: any) {\n    const windows = this.windows;\n    if (windows) {\n      while (windows.length > 0 && !this.closed) {\n        windows.shift().error(err);\n      }\n    }\n    this.destination.error(err);\n  }\n\n  protected _complete() {\n    const windows = this.windows;\n    if (windows) {\n      while (windows.length > 0 && !this.closed) {\n        windows.shift().complete();\n      }\n    }\n    this.destination.complete();\n  }\n\n  protected _unsubscribe() {\n    this.count = 0;\n    this.windows = null;\n  }\n}\n","import { Subject } from '../Subject';\nimport { Operator } from '../Operator';\nimport { async } from '../scheduler/async';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { isNumeric } from '../util/isNumeric';\nimport { isScheduler } from '../util/isScheduler';\nimport { OperatorFunction, SchedulerLike, SchedulerAction } from '../types';\n\n/**\n * Branch out the source Observable values as a nested Observable periodically\n * in time.\n *\n * <span class=\"informal\">It's like {@link bufferTime}, but emits a nested\n * Observable instead of an array.</span>\n *\n * ![](windowTime.png)\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable starts a new window periodically, as\n * determined by the `windowCreationInterval` argument. It emits each window\n * after a fixed timespan, specified by the `windowTimeSpan` argument. When the\n * source Observable completes or encounters an error, the output Observable\n * emits the current window and propagates the notification from the source\n * Observable. If `windowCreationInterval` is not provided, the output\n * Observable starts a new window when the previous window of duration\n * `windowTimeSpan` completes. If `maxWindowCount` is provided, each window\n * will emit at most fixed number of values. Window will complete immediately\n * after emitting last value and next one still will open as specified by\n * `windowTimeSpan` and `windowCreationInterval` arguments.\n *\n * ## Examples\n * In every window of 1 second each, emit at most 2 click events\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { windowTime, map, mergeAll, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowTime(1000),\n *   map(win => win.pipe(take(2))), // each window has at most 2 emissions\n *   mergeAll(),                    // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * Every 5 seconds start a window 1 second long, and emit at most 2 click events per window\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { windowTime, map, mergeAll, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowTime(1000, 5000),\n *   map(win => win.pipe(take(2))), // each window has at most 2 emissions\n *   mergeAll(),                    // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * Same as example above but with maxWindowCount instead of take\n * ```ts\n * import { fromEvent } from 'rxjs';\n * import { windowTime, mergeAll } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowTime(1000, 5000, 2), // each window has still at most 2 emissions\n *   mergeAll(),                // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link window}\n * @see {@link windowCount}\n * @see {@link windowToggle}\n * @see {@link windowWhen}\n * @see {@link bufferTime}\n *\n * @param {number} windowTimeSpan The amount of time to fill each window.\n * @param {number} [windowCreationInterval] The interval at which to start new\n * windows.\n * @param {number} [maxWindowSize=Number.POSITIVE_INFINITY] Max number of\n * values each window can emit before completion.\n * @param {SchedulerLike} [scheduler=async] The scheduler on which to schedule the\n * intervals that determine window boundaries.\n * @return {Observable<Observable<T>>} An observable of windows, which in turn\n * are Observables.\n * @method windowTime\n * @owner Observable\n */\nexport function windowTime<T>(windowTimeSpan: number,\n                              scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;\nexport function windowTime<T>(windowTimeSpan: number,\n                              windowCreationInterval: number,\n                              scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;\nexport function windowTime<T>(windowTimeSpan: number,\n                              windowCreationInterval: number,\n                              maxWindowSize: number,\n                              scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;\n\nexport function windowTime<T>(windowTimeSpan: number): OperatorFunction<T, Observable<T>> {\n  let scheduler: SchedulerLike = async;\n  let windowCreationInterval: number = null;\n  let maxWindowSize: number = Number.POSITIVE_INFINITY;\n\n  if (isScheduler(arguments[3])) {\n    scheduler = arguments[3];\n  }\n\n  if (isScheduler(arguments[2])) {\n    scheduler = arguments[2];\n  } else if (isNumeric(arguments[2])) {\n    maxWindowSize = Number(arguments[2]);\n  }\n\n  if (isScheduler(arguments[1])) {\n    scheduler = arguments[1];\n  } else if (isNumeric(arguments[1])) {\n    windowCreationInterval = Number(arguments[1]);\n  }\n\n  return function windowTimeOperatorFunction(source: Observable<T>) {\n    return source.lift(new WindowTimeOperator<T>(windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler));\n  };\n}\n\nclass WindowTimeOperator<T> implements Operator<T, Observable<T>> {\n\n  constructor(private windowTimeSpan: number,\n              private windowCreationInterval: number | null,\n              private maxWindowSize: number,\n              private scheduler: SchedulerLike) {\n  }\n\n  call(subscriber: Subscriber<Observable<T>>, source: any): any {\n    return source.subscribe(new WindowTimeSubscriber(\n      subscriber, this.windowTimeSpan, this.windowCreationInterval, this.maxWindowSize, this.scheduler\n    ));\n  }\n}\n\ninterface CreationState<T> {\n  windowTimeSpan: number;\n  windowCreationInterval: number;\n  subscriber: WindowTimeSubscriber<T>;\n  scheduler: SchedulerLike;\n}\n\ninterface TimeSpanOnlyState<T> {\n    window: CountedSubject<T>;\n    windowTimeSpan: number;\n    subscriber: WindowTimeSubscriber<T>;\n  }\n\ninterface CloseWindowContext<T> {\n  action: SchedulerAction<CreationState<T>>;\n  subscription: Subscription;\n}\n\ninterface CloseState<T> {\n  subscriber: WindowTimeSubscriber<T>;\n  window: CountedSubject<T>;\n  context: CloseWindowContext<T>;\n}\n\nclass CountedSubject<T> extends Subject<T> {\n  private _numberOfNextedValues: number = 0;\n\n  next(value?: T): void {\n    this._numberOfNextedValues++;\n    super.next(value);\n  }\n\n  get numberOfNextedValues(): number {\n    return this._numberOfNextedValues;\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WindowTimeSubscriber<T> extends Subscriber<T> {\n  private windows: CountedSubject<T>[] = [];\n\n  constructor(protected destination: Subscriber<Observable<T>>,\n              private windowTimeSpan: number,\n              private windowCreationInterval: number | null,\n              private maxWindowSize: number,\n              private scheduler: SchedulerLike) {\n    super(destination);\n\n    const window = this.openWindow();\n    if (windowCreationInterval !== null && windowCreationInterval >= 0) {\n      const closeState: CloseState<T> = { subscriber: this, window, context: <any>null };\n      const creationState: CreationState<T> = { windowTimeSpan, windowCreationInterval, subscriber: this, scheduler };\n      this.add(scheduler.schedule<CloseState<T>>(dispatchWindowClose, windowTimeSpan, closeState));\n      this.add(scheduler.schedule<CreationState<T>>(dispatchWindowCreation, windowCreationInterval, creationState));\n    } else {\n      const timeSpanOnlyState: TimeSpanOnlyState<T> = { subscriber: this, window, windowTimeSpan };\n      this.add(scheduler.schedule<TimeSpanOnlyState<T>>(dispatchWindowTimeSpanOnly, windowTimeSpan, timeSpanOnlyState));\n    }\n  }\n\n  protected _next(value: T): void {\n    const windows = this.windows;\n    const len = windows.length;\n    for (let i = 0; i < len; i++) {\n      const window = windows[i];\n      if (!window.closed) {\n        window.next(value);\n        if (window.numberOfNextedValues >= this.maxWindowSize) {\n          this.closeWindow(window);\n        }\n      }\n    }\n  }\n\n  protected _error(err: any): void {\n    const windows = this.windows;\n    while (windows.length > 0) {\n      windows.shift().error(err);\n    }\n    this.destination.error(err);\n  }\n\n  protected _complete(): void {\n    const windows = this.windows;\n    while (windows.length > 0) {\n      const window = windows.shift();\n      if (!window.closed) {\n        window.complete();\n      }\n    }\n    this.destination.complete();\n  }\n\n  public openWindow(): CountedSubject<T> {\n    const window = new CountedSubject<T>();\n    this.windows.push(window);\n    const destination = this.destination;\n    destination.next(window);\n    return window;\n  }\n\n  public closeWindow(window: CountedSubject<T>): void {\n    window.complete();\n    const windows = this.windows;\n    windows.splice(windows.indexOf(window), 1);\n  }\n}\n\nfunction dispatchWindowTimeSpanOnly<T>(this: SchedulerAction<TimeSpanOnlyState<T>>, state: TimeSpanOnlyState<T>): void {\n  const { subscriber, windowTimeSpan, window } = state;\n  if (window) {\n    subscriber.closeWindow(window);\n  }\n  state.window = subscriber.openWindow();\n  this.schedule(state, windowTimeSpan);\n}\n\nfunction dispatchWindowCreation<T>(this: SchedulerAction<CreationState<T>>, state: CreationState<T>): void {\n  const { windowTimeSpan, subscriber, scheduler, windowCreationInterval } = state;\n  const window = subscriber.openWindow();\n  const action = this;\n  let context: CloseWindowContext<T> = { action, subscription: <any>null };\n  const timeSpanState: CloseState<T> = { subscriber, window, context };\n  context.subscription = scheduler.schedule<CloseState<T>>(dispatchWindowClose, windowTimeSpan, timeSpanState);\n  action.add(context.subscription);\n  action.schedule(state, windowCreationInterval);\n}\n\nfunction dispatchWindowClose<T>(state: CloseState<T>): void {\n  const { subscriber, window, context } = state;\n  if (context && context.action && context.subscription) {\n    context.action.remove(context.subscription);\n  }\n  subscriber.closeWindow(window);\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { Subscription } from '../Subscription';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { OperatorFunction } from '../types';\n\n/**\n * Branch out the source Observable values as a nested Observable starting from\n * an emission from `openings` and ending when the output of `closingSelector`\n * emits.\n *\n * <span class=\"informal\">It's like {@link bufferToggle}, but emits a nested\n * Observable instead of an array.</span>\n *\n * ![](windowToggle.png)\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits windows that contain those items\n * emitted by the source Observable between the time when the `openings`\n * Observable emits an item and when the Observable returned by\n * `closingSelector` emits an item.\n *\n * ## Example\n * Every other second, emit the click events from the next 500ms\n * ```ts\n * import { fromEvent, interval, EMPTY } from 'rxjs';\n * import { windowToggle, mergeAll } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const openings = interval(1000);\n * const result = clicks.pipe(\n *   windowToggle(openings, i => i % 2 ? interval(500) : EMPTY),\n *   mergeAll()\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link window}\n * @see {@link windowCount}\n * @see {@link windowTime}\n * @see {@link windowWhen}\n * @see {@link bufferToggle}\n *\n * @param {Observable<O>} openings An observable of notifications to start new\n * windows.\n * @param {function(value: O): Observable} closingSelector A function that takes\n * the value emitted by the `openings` observable and returns an Observable,\n * which, when it emits (either `next` or `complete`), signals that the\n * associated window should complete.\n * @return {Observable<Observable<T>>} An observable of windows, which in turn\n * are Observables.\n * @method windowToggle\n * @owner Observable\n */\nexport function windowToggle<T, O>(openings: Observable<O>,\n                                   closingSelector: (openValue: O) => Observable<any>): OperatorFunction<T, Observable<T>> {\n  return (source: Observable<T>) => source.lift(new WindowToggleOperator<T, O>(openings, closingSelector));\n}\n\nclass WindowToggleOperator<T, O> implements Operator<T, Observable<T>> {\n\n  constructor(private openings: Observable<O>,\n              private closingSelector: (openValue: O) => Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<Observable<T>>, source: any): any {\n    return source.subscribe(new WindowToggleSubscriber(\n      subscriber, this.openings, this.closingSelector\n    ));\n  }\n}\n\ninterface WindowContext<T> {\n  window: Subject<T>;\n  subscription: Subscription;\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WindowToggleSubscriber<T, O> extends OuterSubscriber<T, any> {\n  private contexts: WindowContext<T>[] = [];\n  private openSubscription: Subscription;\n\n  constructor(destination: Subscriber<Observable<T>>,\n              private openings: Observable<O>,\n              private closingSelector: (openValue: O) => Observable<any>) {\n    super(destination);\n    this.add(this.openSubscription = subscribeToResult(this, openings, openings as any));\n  }\n\n  protected _next(value: T) {\n    const { contexts } = this;\n    if (contexts) {\n      const len = contexts.length;\n      for (let i = 0; i < len; i++) {\n        contexts[i].window.next(value);\n      }\n    }\n  }\n\n  protected _error(err: any) {\n\n    const { contexts } = this;\n    this.contexts = null;\n\n    if (contexts) {\n      const len = contexts.length;\n      let index = -1;\n\n      while (++index < len) {\n        const context = contexts[index];\n        context.window.error(err);\n        context.subscription.unsubscribe();\n      }\n    }\n\n    super._error(err);\n  }\n\n  protected _complete() {\n    const { contexts } = this;\n    this.contexts = null;\n    if (contexts) {\n      const len = contexts.length;\n      let index = -1;\n      while (++index < len) {\n        const context = contexts[index];\n        context.window.complete();\n        context.subscription.unsubscribe();\n      }\n    }\n    super._complete();\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _unsubscribe() {\n    const { contexts } = this;\n    this.contexts = null;\n    if (contexts) {\n      const len = contexts.length;\n      let index = -1;\n      while (++index < len) {\n        const context = contexts[index];\n        context.window.unsubscribe();\n        context.subscription.unsubscribe();\n      }\n    }\n  }\n\n  notifyNext(outerValue: any, innerValue: any,\n             outerIndex: number, innerIndex: number,\n             innerSub: InnerSubscriber<T, any>): void {\n\n    if (outerValue === this.openings) {\n      let closingNotifier;\n      try {\n        const { closingSelector } = this;\n        closingNotifier = closingSelector(innerValue);\n      } catch (e) {\n        return this.error(e);\n      }\n\n      const window = new Subject<T>();\n      const subscription = new Subscription();\n      const context = { window, subscription };\n      this.contexts.push(context);\n      const innerSubscription = subscribeToResult(this, closingNotifier, context as any);\n\n      if (innerSubscription.closed) {\n        this.closeWindow(this.contexts.length - 1);\n      } else {\n        (<any>innerSubscription).context = context;\n        subscription.add(innerSubscription);\n      }\n\n      this.destination.next(window);\n    } else {\n      this.closeWindow(this.contexts.indexOf(outerValue));\n    }\n  }\n\n  notifyError(err: any): void {\n    this.error(err);\n  }\n\n  notifyComplete(inner: Subscription): void {\n    if (inner !== this.openSubscription) {\n      this.closeWindow(this.contexts.indexOf((<any> inner).context));\n    }\n  }\n\n  private closeWindow(index: number): void {\n    if (index === -1) {\n      return;\n    }\n\n    const { contexts } = this;\n    const context = contexts[index];\n    const { window, subscription } = context;\n    contexts.splice(index, 1);\n    window.complete();\n    subscription.unsubscribe();\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { Subject } from '../Subject';\nimport { Subscription } from '../Subscription';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { OperatorFunction } from '../types';\n\n/**\n * Branch out the source Observable values as a nested Observable using a\n * factory function of closing Observables to determine when to start a new\n * window.\n *\n * <span class=\"informal\">It's like {@link bufferWhen}, but emits a nested\n * Observable instead of an array.</span>\n *\n * ![](windowWhen.png)\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits connected, non-overlapping windows.\n * It emits the current window and opens a new one whenever the Observable\n * produced by the specified `closingSelector` function emits an item. The first\n * window is opened immediately when subscribing to the output Observable.\n *\n * ## Example\n * Emit only the first two clicks events in every window of [1-5] random seconds\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { windowWhen, map, mergeAll, take } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const result = clicks.pipe(\n *   windowWhen(() => interval(1000 + Math.random() * 4000)),\n *   map(win => win.pipe(take(2))),     // each window has at most 2 emissions\n *   mergeAll()                         // flatten the Observable-of-Observables\n * );\n * result.subscribe(x => console.log(x));\n * ```\n *\n * @see {@link window}\n * @see {@link windowCount}\n * @see {@link windowTime}\n * @see {@link windowToggle}\n * @see {@link bufferWhen}\n *\n * @param {function(): Observable} closingSelector A function that takes no\n * arguments and returns an Observable that signals (on either `next` or\n * `complete`) when to close the previous window and start a new one.\n * @return {Observable<Observable<T>>} An observable of windows, which in turn\n * are Observables.\n * @method windowWhen\n * @owner Observable\n */\nexport function windowWhen<T>(closingSelector: () => Observable<any>): OperatorFunction<T, Observable<T>> {\n  return function windowWhenOperatorFunction(source: Observable<T>) {\n    return source.lift(new WindowOperator<T>(closingSelector));\n  };\n}\n\nclass WindowOperator<T> implements Operator<T, Observable<T>> {\n  constructor(private closingSelector: () => Observable<any>) {\n  }\n\n  call(subscriber: Subscriber<Observable<T>>, source: any): any {\n    return source.subscribe(new WindowSubscriber(subscriber, this.closingSelector));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WindowSubscriber<T> extends OuterSubscriber<T, any> {\n  private window?: Subject<T>;\n  private closingNotification?: Subscription;\n\n  constructor(protected destination: Subscriber<Observable<T>>,\n              private closingSelector: () => Observable<any>) {\n    super(destination);\n    this.openWindow();\n  }\n\n  notifyNext(_outerValue: T, _innerValue: any,\n             _outerIndex: number, _innerIndex: number,\n             innerSub: InnerSubscriber<T, any>): void {\n    this.openWindow(innerSub);\n  }\n\n  notifyError(error: any): void {\n    this._error(error);\n  }\n\n  notifyComplete(innerSub: InnerSubscriber<T, any>): void {\n    this.openWindow(innerSub);\n  }\n\n  protected _next(value: T): void {\n    this.window!.next(value);\n  }\n\n  protected _error(err: any): void {\n    this.window!.error(err);\n    this.destination.error(err);\n    this.unsubscribeClosingNotification();\n  }\n\n  protected _complete(): void {\n    this.window!.complete();\n    this.destination.complete();\n    this.unsubscribeClosingNotification();\n  }\n\n  private unsubscribeClosingNotification(): void {\n    if (this.closingNotification) {\n      this.closingNotification.unsubscribe();\n    }\n  }\n\n  private openWindow(innerSub: InnerSubscriber<T, any> | null = null): void {\n    if (innerSub) {\n      this.remove(innerSub);\n      innerSub.unsubscribe();\n    }\n\n    const prevWindow = this.window;\n    if (prevWindow) {\n      prevWindow.complete();\n    }\n\n    const window = this.window = new Subject<T>();\n    this.destination.next(window);\n\n    let closingNotifier;\n    try {\n      const { closingSelector } = this;\n      closingNotifier = closingSelector();\n    } catch (e) {\n      this.destination.error(e);\n      this.window.error(e);\n      return;\n    }\n    this.add(this.closingNotification = subscribeToResult(this, closingNotifier));\n  }\n}\n","import { Operator } from '../Operator';\nimport { Subscriber } from '../Subscriber';\nimport { Observable } from '../Observable';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';\n\n/* tslint:disable:max-line-length */\nexport function withLatestFrom<T, R>(project: (v1: T) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, R>(source2: O2, project: (v1: T, v2: ObservedValueOf<O2>) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, R>(v2: O2, v3: O3, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, v5: O5, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>, v6: ObservedValueOf<O6>) => R): OperatorFunction<T, R>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>>(source2: O2): OperatorFunction<T, [T, ObservedValueOf<O2>]>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(v2: O2, v3: O3): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>]>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>]>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4, v5: O5): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>]>;\nexport function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4, v5: O5, v6: O6): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>, ObservedValueOf<O6>]>;\nexport function withLatestFrom<T, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R>;\nexport function withLatestFrom<T, R>(array: ObservableInput<any>[]): OperatorFunction<T, R>;\nexport function withLatestFrom<T, R>(array: ObservableInput<any>[], project: (...values: Array<any>) => R): OperatorFunction<T, R>;\n\n/* tslint:enable:max-line-length */\n\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 * ![](withLatestFrom.png)\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\n * On every click event, emit an array with the latest timer event plus the click event\n * ```ts\n * import { fromEvent, interval } from 'rxjs';\n * import { withLatestFrom } from 'rxjs/operators';\n *\n * const clicks = fromEvent(document, 'click');\n * const timer = interval(1000);\n * const result = clicks.pipe(withLatestFrom(timer));\n * result.subscribe(x => console.log(x));\n * ```\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.pipe(withLatestFrom(b, c), map(([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 */\nexport function withLatestFrom<T, R>(...args: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R> {\n  return (source: Observable<T>) => {\n    let project: any;\n    if (typeof args[args.length - 1] === 'function') {\n      project = args.pop();\n    }\n    const observables = <Observable<any>[]>args;\n    return source.lift(new WithLatestFromOperator(observables, project));\n  };\n}\n\nclass WithLatestFromOperator<T, R> implements Operator<T, R> {\n  constructor(private observables: Observable<any>[],\n              private project?: (...values: any[]) => Observable<R>) {\n  }\n\n  call(subscriber: Subscriber<R>, source: any): any {\n    return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nclass WithLatestFromSubscriber<T, R> extends OuterSubscriber<T, R> {\n  private values: any[];\n  private toRespond: number[] = [];\n\n  constructor(destination: Subscriber<R>,\n              private observables: Observable<any>[],\n              private project?: (...values: any[]) => Observable<R>) {\n    super(destination);\n    const len = observables.length;\n    this.values = new Array(len);\n\n    for (let i = 0; i < len; i++) {\n      this.toRespond.push(i);\n    }\n\n    for (let i = 0; i < len; i++) {\n      let observable = observables[i];\n      this.add(subscribeToResult<T, R>(this, observable, undefined, i));\n    }\n  }\n\n  notifyNext(_outerValue: T, innerValue: R,\n             outerIndex: number): void {\n    this.values[outerIndex] = innerValue;\n    const toRespond = this.toRespond;\n    if (toRespond.length > 0) {\n      const found = toRespond.indexOf(outerIndex);\n      if (found !== -1) {\n        toRespond.splice(found, 1);\n      }\n    }\n  }\n\n  notifyComplete() {\n    // noop\n  }\n\n  protected _next(value: T) {\n    if (this.toRespond.length === 0) {\n      const args = [value, ...this.values];\n      if (this.project) {\n        this._tryProject(args);\n      } else {\n        this.destination.next!(args);\n      }\n    }\n  }\n\n  private _tryProject(args: any[]) {\n    let result: any;\n    try {\n      result = this.project!.apply(this, args);\n    } catch (err) {\n      this.destination.error!(err);\n      return;\n    }\n    this.destination.next!(result);\n  }\n}\n","import { zip as zipStatic } from '../observable/zip';\nimport { Observable } from '../Observable';\nimport { ObservableInput, OperatorFunction } from '../types';\n\n/* tslint:disable:max-line-length */\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, R>(project: (v1: T) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, R>(v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): OperatorFunction<T, R> ;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2>(v2: ObservableInput<T2>): OperatorFunction<T, [T, T2]>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): OperatorFunction<T, [T, T2, T3]>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): OperatorFunction<T, [T, T2, T3, T4]>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): OperatorFunction<T, [T, T2, T3, T4, T5]>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): OperatorFunction<T, [T, T2, T3, T4, T5, T6]> ;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, R>(...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, R>(array: Array<ObservableInput<T>>): OperatorFunction<T, R>;\n/** @deprecated Deprecated in favor of static zip. */\nexport function zip<T, TOther, R>(array: Array<ObservableInput<TOther>>, project: (v1: T, ...values: Array<TOther>) => R): OperatorFunction<T, R>;\n/* tslint:enable:max-line-length */\n\n/**\n * @deprecated Deprecated in favor of static {@link zip}.\n */\nexport function zip<T, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R> {\n  return function zipOperatorFunction(source: Observable<T>) {\n    return source.lift.call(zipStatic<R>(source, ...observables));\n  };\n}","import { ZipOperator } from '../observable/zip';\nimport { Observable } from '../Observable';\nimport { OperatorFunction, ObservableInput } from '../types';\n\nexport function zipAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;\nexport function zipAll<T>(): OperatorFunction<any, T[]>;\nexport function zipAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;\nexport function zipAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;\n\nexport function zipAll<T, R>(project?: (...values: Array<any>) => R): OperatorFunction<T, R> {\n  return (source: Observable<T>) => source.lift(new ZipOperator(project));\n}\n","\n/* Operator exports */\nexport { audit } from '../internal/operators/audit';\nexport { auditTime } from '../internal/operators/auditTime';\nexport { buffer } from '../internal/operators/buffer';\nexport { bufferCount } from '../internal/operators/bufferCount';\nexport { bufferTime } from '../internal/operators/bufferTime';\nexport { bufferToggle } from '../internal/operators/bufferToggle';\nexport { bufferWhen } from '../internal/operators/bufferWhen';\nexport { catchError } from '../internal/operators/catchError';\nexport { combineAll } from '../internal/operators/combineAll';\nexport { combineLatest } from '../internal/operators/combineLatest';\nexport { concat } from '../internal/operators/concat';\nexport { concatAll } from '../internal/operators/concatAll';\nexport { concatMap } from '../internal/operators/concatMap';\nexport { concatMapTo } from '../internal/operators/concatMapTo';\nexport { count } from '../internal/operators/count';\nexport { debounce } from '../internal/operators/debounce';\nexport { debounceTime } from '../internal/operators/debounceTime';\nexport { defaultIfEmpty } from '../internal/operators/defaultIfEmpty';\nexport { delay } from '../internal/operators/delay';\nexport { delayWhen } from '../internal/operators/delayWhen';\nexport { dematerialize } from '../internal/operators/dematerialize';\nexport { distinct } from '../internal/operators/distinct';\nexport { distinctUntilChanged } from '../internal/operators/distinctUntilChanged';\nexport { distinctUntilKeyChanged } from '../internal/operators/distinctUntilKeyChanged';\nexport { elementAt } from '../internal/operators/elementAt';\nexport { endWith } from '../internal/operators/endWith';\nexport { every } from '../internal/operators/every';\nexport { exhaust } from '../internal/operators/exhaust';\nexport { exhaustMap } from '../internal/operators/exhaustMap';\nexport { expand } from '../internal/operators/expand';\nexport { filter } from '../internal/operators/filter';\nexport { finalize } from '../internal/operators/finalize';\nexport { find } from '../internal/operators/find';\nexport { findIndex } from '../internal/operators/findIndex';\nexport { first } from '../internal/operators/first';\nexport { groupBy } from '../internal/operators/groupBy';\nexport { ignoreElements } from '../internal/operators/ignoreElements';\nexport { isEmpty } from '../internal/operators/isEmpty';\nexport { last } from '../internal/operators/last';\nexport { map } from '../internal/operators/map';\nexport { mapTo } from '../internal/operators/mapTo';\nexport { materialize } from '../internal/operators/materialize';\nexport { max } from '../internal/operators/max';\nexport { merge } from '../internal/operators/merge';\nexport { mergeAll } from '../internal/operators/mergeAll';\nexport { mergeMap, flatMap } from '../internal/operators/mergeMap';\nexport { mergeMapTo } from '../internal/operators/mergeMapTo';\nexport { mergeScan } from '../internal/operators/mergeScan';\nexport { min } from '../internal/operators/min';\nexport { multicast } from '../internal/operators/multicast';\nexport { observeOn } from '../internal/operators/observeOn';\nexport { onErrorResumeNext } from '../internal/operators/onErrorResumeNext';\nexport { pairwise } from '../internal/operators/pairwise';\nexport { partition } from '../internal/operators/partition';\nexport { pluck } from '../internal/operators/pluck';\nexport { publish } from '../internal/operators/publish';\nexport { publishBehavior } from '../internal/operators/publishBehavior';\nexport { publishLast } from '../internal/operators/publishLast';\nexport { publishReplay } from '../internal/operators/publishReplay';\nexport { race } from '../internal/operators/race';\nexport { reduce } from '../internal/operators/reduce';\nexport { repeat } from '../internal/operators/repeat';\nexport { repeatWhen } from '../internal/operators/repeatWhen';\nexport { retry } from '../internal/operators/retry';\nexport { retryWhen } from '../internal/operators/retryWhen';\nexport { refCount } from '../internal/operators/refCount';\nexport { sample } from '../internal/operators/sample';\nexport { sampleTime } from '../internal/operators/sampleTime';\nexport { scan } from '../internal/operators/scan';\nexport { sequenceEqual } from '../internal/operators/sequenceEqual';\nexport { share } from '../internal/operators/share';\nexport { shareReplay } from '../internal/operators/shareReplay';\nexport { single } from '../internal/operators/single';\nexport { skip } from '../internal/operators/skip';\nexport { skipLast } from '../internal/operators/skipLast';\nexport { skipUntil } from '../internal/operators/skipUntil';\nexport { skipWhile } from '../internal/operators/skipWhile';\nexport { startWith } from '../internal/operators/startWith';\nexport { subscribeOn } from '../internal/operators/subscribeOn';\nexport { switchAll } from '../internal/operators/switchAll';\nexport { switchMap } from '../internal/operators/switchMap';\nexport { switchMapTo } from '../internal/operators/switchMapTo';\nexport { take } from '../internal/operators/take';\nexport { takeLast } from '../internal/operators/takeLast';\nexport { takeUntil } from '../internal/operators/takeUntil';\nexport { takeWhile } from '../internal/operators/takeWhile';\nexport { tap } from '../internal/operators/tap';\nexport { throttle } from '../internal/operators/throttle';\nexport { throttleTime } from '../internal/operators/throttleTime';\nexport { throwIfEmpty } from '../internal/operators/throwIfEmpty';\nexport { timeInterval } from '../internal/operators/timeInterval';\nexport { timeout } from '../internal/operators/timeout';\nexport { timeoutWith } from '../internal/operators/timeoutWith';\nexport { timestamp } from '../internal/operators/timestamp';\nexport { toArray } from '../internal/operators/toArray';\nexport { window } from '../internal/operators/window';\nexport { windowCount } from '../internal/operators/windowCount';\nexport { windowTime } from '../internal/operators/windowTime';\nexport { windowToggle } from '../internal/operators/windowToggle';\nexport { windowWhen } from '../internal/operators/windowWhen';\nexport { withLatestFrom } from '../internal/operators/withLatestFrom';\nexport { zip } from '../internal/operators/zip';\nexport { zipAll } from '../internal/operators/zipAll';\n","module.exports = (__webpack_require__(3))(20);","module.exports = (__webpack_require__(3))(44);","module.exports = (__webpack_require__(3))(402);","module.exports = (__webpack_require__(3))(451);","import { OAuth2Provider } from \"./utils/oauth\";\n\n\nexport type DeploymentType = \"Development\" | \"Staging\" | \"Production\";\n\n\nexport interface ServerOptions {\n    currencyCode: string;\n    freeMode: boolean;\n    deploymentType: DeploymentType;\n    oAuthConfigs: {\n        [P in OAuth2Provider]?: {\n            authorizeUri: string;\n            clientId: string;\n            provider: OAuth2Provider;\n            redirectUri: string;\n        };\n    };\n    publishedDataHost: string;\n    stripePublicApiKey: string;\n    uri: string;\n}\n\n\nconst defaultOptions: ServerOptions = {\n    currencyCode: \"cad\",\n    deploymentType: \"Staging\",\n    freeMode: false,\n    oAuthConfigs: {\n        [OAuth2Provider.TrimbleConnect]: {\n            authorizeUri: \"https://identity-stg.trimble.com/i/oauth2/authorize\",\n            clientId: \"ZthTWnWfrkRR6kfn6rT9hhk0_qMa\",\n            provider: OAuth2Provider.TrimbleConnect,\n            redirectUri: \"http://localhost:3000/loginredirect\"\n        }\n    },\n    publishedDataHost: \"static.construction.ai\",\n    stripePublicApiKey: \"pk_test_TYooMQauvdEDq54NiTphI7jx\",\n    uri: \"https://app.construction.ai/\"\n};\n\n\nlet serverOptions = defaultOptions;\n\n\nexport function setServerOptions(newServerOptions: ServerOptions): void {\n    serverOptions = newServerOptions;\n}\n\n\nexport function getServerOptions(): ServerOptions {\n    return serverOptions;\n}\n","import { parse, stringify } from \"qs\";\nimport * as Rx from \"rxjs\";\nimport { map } from \"rxjs/operators\";\n\n\n/**\n * The set of all possible OAuth2 providers.\n */\nexport enum OAuth2Provider {\n    TrimbleConnect = \"TrimbleConnect\",\n    Google = \"Google\",\n    Procore = \"Procore\"\n}\n\n\nexport interface OAuth2LoginResultBase {\n    success: boolean;\n}\n\nexport interface OAuth2LoginResultSuccess {\n    success: true;\n    authorizationCode: string;\n}\n\nexport interface OAuth2LoginResultFailure {\n    success: false;\n    error: string;\n    errorMessage?: string;\n}\n\nexport type OAuth2LoginResult = OAuth2LoginResultFailure | OAuth2LoginResultSuccess;\n\nexport type OAuth2LoginResultWithProvider = OAuth2LoginResult & {\n    provider: OAuth2Provider;\n};\n\n\nfunction isOAuth2LoginResult(obj: any): obj is OAuth2LoginResult {\n    return obj && typeof obj.success === \"boolean\"\n        && (typeof obj.authorizationCode === \"string\" || typeof obj.error === \"string\");\n}\n\n\n/** Construct and return an OAuth2 authorization URI. */\nexport function createAuthorizationUri(authorizeUri: string, clientId: string, redirectUri: string, provider: OAuth2Provider): string {\n    const state = \"bacon\";\n    const scope = provider === OAuth2Provider.TrimbleConnect ? [ \"openid\", \"Construction_AI\" ]\n        : provider === OAuth2Provider.Google ? [\"email\", \"profile\"]\n        : undefined;\n    const tenantDomain = provider === OAuth2Provider.TrimbleConnect\n        ? \"trimble.com\"\n        : undefined;\n    const prompt = provider === OAuth2Provider.Google\n        ? \"consent\"\n        : undefined;\n    const queryParams = {\n        client_id: clientId,\n        redirect_uri: redirectUri,\n        response_type: \"code\",\n        state: state,\n        scope: scope ? scope.join(\" \") : undefined,\n        access_type: \"offline\",\n        prompt,\n        tenantDomain\n    };\n\n    const serializedParams = stringify(queryParams);\n\n    return `${authorizeUri}${authorizeUri.indexOf(\"?\") < 0 ? \"?\" : \"&\"}${serializedParams}`;\n}\n\n\ninterface LoginWithAUth2Options {\n    authorizeUri: string;\n    clientId: string;\n    provider: OAuth2Provider;\n    redirectUri: string;\n}\n\n\n/**\n * Attempt to log in using OAuth2 by opening a popup window with the authorization URL.\n *\n * The redirect URL should forward the result to the main window by calling\n * \"sendResultMessage\".\n */\nexport function loginWithOAuth2(options: LoginWithAUth2Options): Rx.Observable<OAuth2LoginResultWithProvider> {\n    return new Rx.Observable<OAuth2LoginResult>(subscriber => {\n        let cleanup = () => { return; };\n\n        function receivePopupMessage(event: MessageEvent): void {\n            if (event.origin === window.location.origin) {\n                cleanup();\n                if (isOAuth2LoginResult(event.data)) {\n                    subscriber.next(event.data);\n                } else {\n                    subscriber.next({\n                        success: false,\n                        error: \"Got invalid message.\"\n                    });\n                }\n                subscriber.complete();\n            }\n        }\n\n        const authorizationUri = createAuthorizationUri(options.authorizeUri, options.clientId, options.redirectUri, options.provider);\n        const popup = window.open(authorizationUri, \"_blank\", \"width=600,height=600\");\n        window.addEventListener(\"message\", receivePopupMessage, false);\n        const pollTimer = window.setInterval(() => {\n            if (!popup || popup.closed !== false) {\n                cleanup();\n                subscriber.next({\n                    success: false,\n                    error: \"Closed popup\",\n                    errorMessage: \"Login dialog was closed.\"\n                });\n                subscriber.complete();\n            }\n        }, 200);\n\n        cleanup = () => {\n            window.removeEventListener(\"message\", receivePopupMessage, false);\n            window.clearInterval(pollTimer);\n            if (popup && !popup.closed) {\n                popup.close();\n            }\n        };\n\n        return () => {\n            cleanup();\n        };\n    }).pipe(map(result => ({\n        ...result,\n        provider: options.provider\n    })));\n}\n\n\n/**\n * Attempts to send the result of an OAuth2 login to the parent window.\n */\nexport function sendResultMessage(location: Location): void {\n    // TODO possibility: oauthErrorCode, oauthErrorMsg\n\n    const params = parse(location.search, { ignoreQueryPrefix: true });\n    const result: OAuth2LoginResult = params.error\n        ? {\n            success: false,\n            error: params.error,\n            errorMessage: params.error_description\n        }\n        : params.code\n            ? {\n                success: true,\n                authorizationCode: params.code\n            }\n            : {\n                success: false,\n                error: `Could not find code or error in URL ${location}`,\n                params\n            } as any;\n\n    if (window.opener) {\n        window.opener.postMessage(result, window.location.origin);\n    }\n}\n","import * as React from \"react\";\n\nimport { ThreeDots } from \"./ThreeDots\";\n\n\nexport interface PleaseWaitProps {\n    children: string | (string | undefined)[];\n}\n\n\nexport function PleaseWait(props: PleaseWaitProps): JSX.Element {\n    return <p className=\"always-visible\">{props.children}&nbsp;&nbsp;&nbsp;<ThreeDots color=\"#597AFF\" height={12} width={48}></ThreeDots></p>;\n}\n","module.exports = (__webpack_require__(3))(140);","import { AbortController } from \"abort-controller\";\nimport { addTask, fetch } from \"domain-task\";\nimport { Observable } from \"rxjs\";\n\nimport { windowIfDefined } from \"./window\";\n\n\ndeclare global {\n    interface Window {\n        AbortController?: any;\n    }\n}\n\n\nfunction getAbortController(): AbortController {\n    if (windowIfDefined && windowIfDefined.AbortController) {\n        return new windowIfDefined.AbortController();\n    } else {\n        return new AbortController();\n    }\n}\n\n\nexport function createFetchStream<T>(url: string | Request, init?: RequestInit): Observable<T> {\n    return new Observable<T>(subscriber => {\n        const controller = getAbortController();\n        const fetchTask = fetch(\n            url, {\n                ...init,\n                signal: controller.signal\n            })\n            .then(response => {\n                if (response.ok) {\n                    return (response.json() as Promise<T>)\n                        .then(planData => {\n                            subscriber.next(planData);\n                            subscriber.complete();\n                        });\n                }\n\n                return (response.text() as Promise<string>)\n                    .then(errorString => {\n                        throw new Error(errorString);\n                    });\n            })\n            .catch(error => subscriber.error(error));\n\n        addTask(fetchTask);\n\n        return () => {\n            controller.abort();\n        };\n    });\n}\n\n","declare var global: Window | undefined;\n\n\nexport const windowIfDefined = global as Window || null;\n","module.exports = (__webpack_require__(3))(358);","module.exports = (__webpack_require__(3))(3);","module.exports = (__webpack_require__(3))(281);","module.exports = (__webpack_require__(3))(274);","module.exports = (__webpack_require__(3))(296);","import { createMatchSelector, LocationChangeAction, LOCATION_CHANGE, RouterRootState } from \"connected-react-router\";\nimport { Action, Reducer } from \"redux\";\nimport { combineEpics, StateObservable } from \"redux-observable\";\nimport * as Rx from \"rxjs\";\nimport { catchError, flatMap, map, switchMap } from \"rxjs/operators\";\n\nimport { viewPlanPath } from \"../routes\";\nimport { createFetchStream } from \"../utils/fetch\";\nimport { actionCreator, ofType, ActionsUnion, ActionTypes } from \"../utils/state\";\n\nimport { stringify } from \"qs\";\nimport { TrimbleProject } from \"../components/TrimbleProjectList\";\nimport { ApplicationState } from \"./index\";\n\n\n// -----------------\n// State\n\nexport interface PlansState {\n    errorText?: string;\n    isLoading: boolean;\n    isPaying: boolean;\n    currentPlanGuid?: string;\n    plans: {\n        [guid: string]: PlanData\n    };\n}\n\nexport interface PlanData {\n    available: boolean;\n    costDisplay: string;\n    costInCents: number;\n    crossSectionData: CrossSectionPlanData;\n    featurePages: FeaturePageData[];\n    free: boolean;\n    guid: string;\n    layeredPages: LayeredPageData[];\n    nameWithoutExtension: string;\n    nothing: boolean;\n    paid: boolean;\n    spotPages: SpotPageData[];\n    tableData: TablePlanData;\n}\n\nexport interface FeaturePageData {\n    featureCount: number;\n    featuresIdentified: FeatureInformation[];\n    pageNumber: number;\n    pdfOutputFile: string;\n}\n\nexport interface LayeredPageData {\n    dxfOutputFile: string;\n    pageNumber: number;\n    pdfOutputFile: string;\n}\n\nexport interface SpotPageData {\n    dxfOutputFile: string;\n    layerCount: number;\n    pageNumber: number;\n    pdfOutputFile: string;\n    spotsConfident: number;\n    spotsFound: number;\n    spotsUncertain: number;\n    spotsUnmatched: number;\n    timeSaved: string;\n    timeSavedInSeconds: number;\n    vectorCount: number;\n}\n\nexport interface TablePlanData {\n    excelOutputFile: string;\n    pdfOutputFile: string;\n    tableCount: number;\n}\n\nexport interface CrossSectionPlanData {\n    dxfOutputFile: string;\n    crossSectionCount: number;\n}\n\nexport interface FeatureInformation {\n    name: string;\n    count: number;\n}\n\nexport const initialState: PlansState = {\n    plans: {},\n    isLoading: false,\n    isPaying: false\n};\n\n\n// -----------------\n// Actions\n\nexport enum PlanActionType {\n    CLEAR_ERROR = \"@@plans/CLEAR_ERROR\",\n    LOAD_PLAN = \"@@plans/LOAD_PLAN\",\n    PAY_FOR_PLAN = \"@@plans/PAY_FOR_PLAN\",\n    PAYMENT_ERROR = \"@@plans/PAYMENT_ERROR\",\n    RECEIVE_PLAN_DATA = \"@@plans/RECEIVE_PLAN_DATA\",\n    SET_CURRENT_PLAN = \"@@plans/SET_CURRENT_PLAN\",\n    USE_CACHED_PLAN_DATA = \"@@plans/USE_CACHED_PLAN_DATA\"\n}\n\nexport namespace PlanActions {\n    export interface LoadPlan {\n        guid: string;\n    }\n    export interface PayForPlan {\n        email: string;\n        guid: string;\n        selectedProject?: TrimbleProject;\n        stripeToken: string;\n    }\n    export interface PaymentError {\n        error: string;\n    }\n    export interface ReceivePlan {\n        planData: PlanData;\n    }\n    export interface SetCurrentPlan {\n        guid: string;\n    }\n\n    export const clearError = actionCreator(PlanActionType.CLEAR_ERROR).empty();\n    export const loadPlan = actionCreator(PlanActionType.LOAD_PLAN).withPayload<LoadPlan>();\n    export const payForPlan = actionCreator(PlanActionType.PAY_FOR_PLAN).withPayload<PayForPlan>();\n    export const paymentError = actionCreator(PlanActionType.PAYMENT_ERROR).withPayload<PaymentError>();\n    export const receivePlan = actionCreator(PlanActionType.RECEIVE_PLAN_DATA).withPayload<ReceivePlan>();\n    export const setCurrentPlan = actionCreator(PlanActionType.SET_CURRENT_PLAN).withPayload<SetCurrentPlan>();\n    export const useCachedPlan = actionCreator(PlanActionType.USE_CACHED_PLAN_DATA).empty();\n}\n\nexport type AnyPlanAction = ActionsUnion<typeof PlanActions>;\nexport type PlanActions = ActionTypes<typeof PlanActions>;\n\n\n// -----------------\n// Epic\n\ntype PlanEpic = (action$: Rx.Observable<AnyPlanAction | LocationChangeAction>, store: StateObservable<ApplicationState>) => Rx.Observable<AnyPlanAction>;\n\nconst loadPlanEpic: PlanEpic = action$ => action$.pipe(\n    ofType(PlanActionType.LOAD_PLAN),\n    switchMap(action => createFetchStream<PlanData>(`api/plans/get/${action.payload.guid}`)\n        .pipe(\n            map(planData => PlanActions.receivePlan({ planData }))\n        )));\n\nconst paymentEpic: PlanEpic = action$ => action$.pipe(\n    ofType(PlanActionType.PAY_FOR_PLAN),\n    flatMap(action => createFetchStream<PlanData>(`/api/plans/pay/${action.payload.guid}`, {\n            method: \"POST\",\n            headers: {\"Content-Type\": \"application/x-www-form-urlencoded\"},\n            body: stringify({\n                stripeToken: action.payload.stripeToken,\n                stripeEmail: action.payload.email,\n                selectedFolderId: action.payload.selectedProject && action.payload.selectedProject.rootFolderId\n            })\n        })\n        .pipe(\n            map(planData => {\n                return PlanActions.receivePlan({ planData });\n            }),\n            catchError(error => {\n                return Rx.of(PlanActions.paymentError({ error: error.message }));\n            })\n        )));\n\nconst viewPlanMatcher = createMatchSelector<RouterRootState, { guid: string }>(viewPlanPath);\nconst selectGuidEpic: PlanEpic = action$ => action$.pipe(\n    ofType(LOCATION_CHANGE),\n    flatMap(action => {\n        const viewPlanMatch = viewPlanMatcher({ router: action.payload });\n\n        return viewPlanMatch\n            ? Rx.of(PlanActions.setCurrentPlan({ guid: viewPlanMatch.params.guid }))\n            : Rx.empty();\n    }));\n\nconst switchPlanEpic: PlanEpic = (action$, store) => action$.pipe(\n    ofType(PlanActionType.SET_CURRENT_PLAN),\n    switchMap(action => store.value.plans.plans[action.payload.guid]\n        ? Rx.empty()\n        : Rx.of(PlanActions.loadPlan(action.payload))));\n\nexport const planEpic = combineEpics(loadPlanEpic, paymentEpic, selectGuidEpic, switchPlanEpic);\n\n\n// ----------------\n// Reducer\n\n\nexport const reducer: Reducer<PlansState> = (state: PlansState = initialState, incomingAction: Action) => {\n    const action = incomingAction as AnyPlanAction | LocationChangeAction;\n    switch (action.type) {\n        case PlanActionType.CLEAR_ERROR:\n            return {\n                ...state,\n                errorText: undefined,\n                isPaying: false\n            };\n        case PlanActionType.PAY_FOR_PLAN:\n            return {\n                ...state,\n                isPaying: true\n            };\n        case PlanActionType.PAYMENT_ERROR:\n            return {\n                ...state,\n                errorText: action.payload.error\n            };\n        case PlanActionType.RECEIVE_PLAN_DATA:\n            return {\n                ...state,\n                plans: {\n                    ...state.plans,\n                    [action.payload.planData.guid]: action.payload.planData\n                },\n                isLoading: false,\n                isPaying: false\n            };\n        case PlanActionType.SET_CURRENT_PLAN:\n            return state.currentPlanGuid === action.payload.guid\n                ? state\n                : {\n                    ...state,\n                    currentPlanGuid: action.payload.guid,\n                    isLoading: !state.plans[action.payload.guid],\n                    isPaying: false\n                };\n    }\n\n    return state;\n};\n","module.exports = (__webpack_require__(3))(444);","import { Action, ActionCreatorsMapObject } from \"redux\";\nimport { ofType as originalOfType } from \"redux-observable\";\nimport { Observable } from \"rxjs\";\n\n\n/**\n * Action with a discriminated type and a payload.\n */\nexport interface PayloadAction<T extends string, P> extends Action<T> {\n    payload: P;\n}\n\n/**\n * Action with a discriminated type, payload, and metadata.\n */\nexport interface PayloadMetaAction<T extends string, P, M> extends PayloadAction<T, P> {\n    meta: M;\n}\n\n/**\n * Generates a type union from an object containing action creators.\n */\nexport type ActionsUnion<A extends ActionCreatorsMapObject> = ReturnType<A[keyof A]>;\n\n/**\n * Generates a type mapping of individual action names to their concrete types.\n */\nexport type ActionTypes<A extends ActionCreatorsMapObject> = { [K in keyof A]: ReturnType<A[K]> };\n\nexport interface EmptyActionCreator<T extends string, R = Action<T>> {\n    /**\n     * Creates an empty action.\n     */\n    (): R;\n}\n\nexport interface PayloadActionCreator<T extends string, P, R = PayloadAction<T, P>> {\n    /**\n     * Creates an action with the given payload.\n     *\n     * @param payload\n     *     Data to deliver with the action.\n     */\n    (payload: P): R;\n}\n\nexport interface PayloadMetaActionCreator<T extends string, P, M, R = PayloadMetaAction<T, P, M>> {\n    /**\n     * Creates an action with the given payload and metadata.\n     *\n     * @param payload\n     *     Data to deliver with the action.\n     * @param meta\n     *     Metadata needed for processing the action.\n     */\n    (payload: P, meta: M): R;\n}\n\n/**\n * For a given action type, allows generating various action creator functions.\n */\nexport interface ActionCreatorFactory<T extends string> {\n    /**\n     * Action creator with just a discriminated type and no payload.\n     */\n    empty(): EmptyActionCreator<T>;\n\n    /**\n     * Action creator with a discriminated type and payload.\n     */\n    withPayload<P>(): PayloadActionCreator<T, P>;\n\n    /**\n     * Action creator with a discriminated type, payload, and metadata.\n     */\n    withPayloadAndMeta<P, M>(): PayloadMetaActionCreator<T, P, M>;\n}\n\n/**\n * Returns an action creator factory for the given discriminated type.\n */\nexport function actionCreator<T extends string>(type: T): ActionCreatorFactory<T> {\n    if (typeof type !== \"string\") {\n        throw new Error(`actionCreator: expected \"type\" to be a string, instead got \"${typeof type}\".`);\n    }\n\n    function empty(): () => Action<T> {\n        return () => ({ type });\n    }\n\n    function withPayload<P>(): (payload: P) => PayloadAction<T, P> {\n        return payload => ({ type, payload });\n    }\n\n    function withPayloadAndMeta<P, M>(): (payload: P, meta: M) => PayloadMetaAction<T, P, M> {\n        return (payload, meta) => ({ type, payload, meta });\n    }\n\n    return {\n        empty,\n        withPayload,\n        withPayloadAndMeta\n    };\n}\n\n/**\n * Helper type to automatically narrow the actions in the returned observable from `ofType`.\n */\nexport type FilteredOfType = <A extends Action, K extends string>(\n    ...key: K[]\n) => (source: Observable<A>) => Observable<Extract<A, { type: K }>>;\n\n/**\n * Re-exported `ofType` from \"redux-observable\", but with type narrowing based on the provided type keys.\n */\nexport const ofType: FilteredOfType = originalOfType;\n","import * as React from \"react\";\nimport { ConnectedLoginButton } from \"./LoginButton\";\n\nimport { buildVersion } from \"../version\";\n\n\ninterface LayoutProps {\n    skipUser?: boolean;\n    children: React.ReactNode[];\n}\n\n\nexport function Layout(props: LayoutProps): JSX.Element {\n    return <div className=\"root-container\">\n        <header>\n            <a href=\"/\"><img src=\"/static/logo-150.png\" alt=\"Construction AI\" width=\"150\" height=\"150\" /></a>\n        </header>\n        <div className=\"main-content\">\n            {props.skipUser\n                ? props.children\n                : [\n                    <ConnectedLoginButton key=\"login-button\"></ConnectedLoginButton>,\n                    ...props.children\n                ] }\n        </div>\n        <footer>\n            <a href=\"http://www.construction.ai/privacy/\">Privacy</a>\n            <a href=\"http://www.construction.ai/terms-of-service/\">Terms of Service</a>\n            <a href=\"http://www.construction.ai/contact-us/\">Contact</a>\n            {buildVersion}\n        </footer>\n    </div>;\n}\n","'use strict';\n\nvar replace = String.prototype.replace;\nvar percentTwenties = /%20/g;\n\nvar Format = {\n    RFC1738: 'RFC1738',\n    RFC3986: 'RFC3986'\n};\n\nmodule.exports = {\n    'default': Format.RFC3986,\n    formatters: {\n        RFC1738: function (value) {\n            return replace.call(value, percentTwenties, '+');\n        },\n        RFC3986: function (value) {\n            return String(value);\n        }\n    },\n    RFC1738: Format.RFC1738,\n    RFC3986: Format.RFC3986\n};\n","import { Action, Reducer } from \"redux\";\nimport { combineEpics, StateObservable } from \"redux-observable\";\nimport * as Rx from \"rxjs\";\nimport { catchError, flatMap, ignoreElements, map, switchMap, take, tap } from \"rxjs/operators\";\n\nimport { createFetchStream } from \"../utils/fetch\";\nimport { loginWithOAuth2, OAuth2Provider } from \"../utils/oauth\";\nimport { actionCreator, ofType, ActionsUnion, ActionTypes } from \"../utils/state\";\nimport { loadUserState, removeUserState, saveUserState } from \"../utils/userState\";\n\nimport { getServerOptions } from \"../serverOptions\";\nimport { ApplicationState } from \"./index\";\n\n\n// -----------------\n// State\n\nexport interface UserProfile {\n    clientToken: string;\n    email: string;\n    provider: OAuth2Provider;\n    username: string;\n}\n\nexport interface UserState {\n    profile: UserProfile | null;\n    isLoggingIn: boolean;\n    loginEnabled: boolean;\n    loginError?: string;\n}\n\nexport const initialState: UserState = {\n    profile: null,\n    isLoggingIn: false,\n    loginEnabled: false\n};\n\n\n// -----------------\n// Actions\n\nexport interface LoginResultBase {\n    success: boolean;\n}\n\nexport interface LoginResultSuccess {\n    success: true;\n    clientToken: string;\n    email: string;\n    provider: OAuth2Provider;\n    username: string;\n}\n\nexport interface LoginResultFailure {\n    success: false;\n    error: string;\n}\n\nexport type LoginResult = LoginResultFailure | LoginResultSuccess;\n\nexport enum UserActionType {\n    ENABLE_LOGINS = \"@@user/ENABLE_LOGINS\",\n    LOAD_USER_STATE = \"@@user/LOAD_USER_STATE\",\n    LOGIN_RESULT = \"@@user/LOGIN_RESULT\",\n    LOGIN_START = \"@@user/LOGIN_START\",\n    LOGOUT = \"@@user/LOGOUT\",\n    LOGOUT_ACTUAL = \"@@user/LOGOUT_ACTUAL\"\n}\n\nexport namespace UserActions {\n    export const enableLogins = actionCreator(UserActionType.ENABLE_LOGINS).empty();\n    export const loadUser = actionCreator(UserActionType.LOAD_USER_STATE).empty();\n    export const loginResult = actionCreator(UserActionType.LOGIN_RESULT).withPayload<LoginResult>();\n    export const loginStart = actionCreator(UserActionType.LOGIN_START).withPayload<OAuth2Provider>();\n    export const logout = actionCreator(UserActionType.LOGOUT).empty();\n    export const logoutActual = actionCreator(UserActionType.LOGOUT_ACTUAL).empty();\n}\n\nexport type AnyUserAction = ActionsUnion<typeof UserActions>;\nexport type UserActions = ActionTypes<typeof UserActions>;\n\n\n// -----------------\n// Epic\n\ntype UserEpic = (action$: Rx.Observable<AnyUserAction>, store: StateObservable<ApplicationState>) => Rx.Observable<AnyUserAction>;\n\nexport const loadUserStateEpic: UserEpic = action$ => action$.pipe(\n    ofType(UserActionType.LOAD_USER_STATE),\n    switchMap(() => {\n        const savedState = loadUserState();\n\n        if (!savedState) {\n            return Rx.empty();\n        }\n\n        return createFetchStream<LoginResult>(`api/auth/verify/${savedState.clientToken}`, { method: \"POST\" })\n            .pipe(\n                map(result => result && result.success\n                    ? UserActions.loginResult(result)\n                    : UserActions.logoutActual()),\n                catchError(() => Rx.empty()));\n    }));\n\nexport const loginEpic: UserEpic = action$ => action$.pipe(\n    ofType(UserActionType.LOGIN_START),\n    switchMap(action => {\n        const serverOptions = getServerOptions();\n        const selectedLoginOptions = serverOptions.oAuthConfigs[action.payload];\n        if (!selectedLoginOptions) {\n            return Rx.of(UserActions.loginResult({ success: false, error: \"Attempting to login with invalid provider\" }));\n        }\n        return loginWithOAuth2(selectedLoginOptions)\n            .pipe(\n                take(1),\n                flatMap(result => {\n                    return result.success\n                        ? createFetchStream<LoginResult>(`api/auth/login/${result.provider}/${result.authorizationCode}`, { method: \"POST\" })\n                            .pipe(\n                                take(1)\n                            )\n                        : Rx.of<LoginResult>({\n                            success: false,\n                            error: result.errorMessage || result.error\n                        });\n                }),\n                tap(result => {\n                    if (result.success) {\n                        saveUserState({\n                            username: result.username,\n                            email: result.email,\n                            clientToken: result.clientToken\n                        });\n                    }\n                }),\n                map(result => UserActions.loginResult(result)),\n                catchError(err => {\n                    console.log(\"Got unknown error:\", err);\n                    return Rx.of(UserActions.loginResult({ success: false, error: \"Unknown error occurred\" }));\n                })\n            );\n    }));\n\nexport const logoutEpic: UserEpic = action$ => action$.pipe(\n    ofType(UserActionType.LOGOUT),\n    switchMap(() => Rx.concat(\n        createFetchStream<never>(`api/auth/logout`, { method: \"POST\" })\n            .pipe(\n                ignoreElements(),\n                catchError(() => Rx.empty())),\n        Rx.of(UserActions.logoutActual()))));\n\nexport const userEpic = combineEpics(loadUserStateEpic, logoutEpic, loginEpic);\n\n\n// ----------------\n// Reducer\n\nexport const reducer: Reducer<UserState> = (state: UserState = initialState, incomingAction: Action) => {\n    const action = incomingAction as AnyUserAction;\n    switch (action.type) {\n        case UserActionType.ENABLE_LOGINS:\n            return state.loginEnabled\n                ? state\n                : {\n                    ...state,\n                    loginEnabled: true\n                };\n        case UserActionType.LOGIN_RESULT:\n            return {\n                profile: action.payload.success ? {\n                    clientToken: action.payload.clientToken,\n                    email: action.payload.email,\n                    provider: action.payload.provider,\n                    username: action.payload.username\n                } : null,\n                isLoggingIn: false,\n                loginEnabled: state.loginEnabled,\n                loginError: action.payload.success ? undefined : action.payload.error\n            };\n        case UserActionType.LOGIN_START:\n            return {\n                profile: state.profile,\n                isLoggingIn: true,\n                loginEnabled: state.loginEnabled\n            };\n        case UserActionType.LOGOUT_ACTUAL:\n            removeUserState();\n            return {\n                profile: null,\n                isLoggingIn: false,\n                loginEnabled: state.loginEnabled\n            };\n    }\n\n    return state;\n};\n","module.exports = (__webpack_require__(3))(126);","module.exports = (__webpack_require__(3))(66);","module.exports = (__webpack_require__(3))(19);","module.exports = (__webpack_require__(3))(162);","module.exports = (__webpack_require__(3))(362);","module.exports = (__webpack_require__(3))(272);","module.exports = (__webpack_require__(3))(147);","module.exports = (__webpack_require__(3))(92);","module.exports = (__webpack_require__(3))(453);","import * as React from \"react\";\nimport { Route, Switch } from \"react-router-dom\";\n\nimport { ConnectedHome } from \"./components/Home\";\nimport { NotFound } from \"./components/NotFound\";\nimport { OAuth2Redirect } from \"./components/OAuth2Redirect\";\nimport { ConnectedViewPlan } from \"./components/ViewPlan\";\n\n\nexport const viewPlanPath = \"/view/:guid\";\n\nexport const routes = <Switch>\n        <Route exact path=\"/\" component={ ConnectedHome } />\n        <Route exact path=\"/loginredirect\" component={ OAuth2Redirect } />\n        <Route path={viewPlanPath} component={ ConnectedViewPlan } />\n        <Route component={ NotFound } />\n    </Switch>;\n","module.exports = (__webpack_require__(3))(450);","import { push } from \"connected-react-router\";\nimport { Action, Reducer } from \"redux\";\nimport { StateObservable } from \"redux-observable\";\nimport * as Rx from \"rxjs\";\nimport { catchError, filter, flatMap, switchMap, take, takeUntil } from \"rxjs/operators\";\n\nimport { actionCreator, ofType, ActionsUnion, ActionTypes } from \"../utils/state\";\n\nimport { createFetchStream } from \"../utils/fetch\";\nimport { createQueueStream } from \"../utils/messageQueue\";\nimport { AnyAction, ApplicationState } from \"./index\";\nimport { PlanActions, PlanData } from \"./plans\";\n\n\n// -----------------\n// State\n\nexport interface UploadState {\n    errorText?: string;\n    uploadMessage?: string;\n    isUploading: boolean;\n}\n\nexport const initialState: UploadState = { isUploading: false };\n\n\n// -----------------\n// Actions\n\nexport enum UploadActionType {\n    CANCEL = \"@@upload/CANCEL\",\n    CLEAR_ERROR = \"@@upload/CLEAR_ERROR\",\n    UPLOAD_ERROR = \"@@upload/UPLOAD_ERROR\",\n    UPLOAD_FINISHED = \"@@upload/UPLOAD_FINISHED\",\n    UPLOAD_PLAN = \"@@upload/UPLOAD_PLAN\",\n    UPLOAD_STATUS = \"@@upload/UPLOAD_STATUS\"\n}\n\nexport namespace UploadActions {\n    export interface UploadError {\n        error: string;\n    }\n    export interface UploadStatus {\n        status: string;\n    }\n    export interface UploadFinished {\n        planData: PlanData;\n    }\n    export interface UploadPlan {\n        file: File;\n        filename: string;\n    }\n\n    export const cancelUpload = actionCreator(UploadActionType.CANCEL).empty();\n    export const clearError = actionCreator(UploadActionType.CLEAR_ERROR).empty();\n    export const uploadError = actionCreator(UploadActionType.UPLOAD_ERROR).withPayload<UploadError>();\n    export const uploadFinished = actionCreator(UploadActionType.UPLOAD_FINISHED).withPayload<UploadFinished>();\n    export const uploadPlan = actionCreator(UploadActionType.UPLOAD_PLAN).withPayload<UploadPlan>();\n    export const uploadStatus = actionCreator(UploadActionType.UPLOAD_STATUS).withPayload<UploadStatus>();\n}\n\nexport type AnyUploadAction = ActionsUnion<typeof UploadActions>;\nexport type UploadActions = ActionTypes<typeof UploadActions>;\n\n\n// -----------------\n// Epic\n\ntype UploadEpic = (action$: Rx.Observable<AnyUploadAction>, store: StateObservable<ApplicationState>) => Rx.Observable<AnyAction>;\n\ninterface UploadResult {\n    guid: string;\n    messageQueue: string;\n}\n\ninterface UploadMessageComplete {\n    complete: true;\n    message: string;\n    planData: PlanData;\n}\n\ninterface UploadMessageStatus {\n    complete: false;\n    error?: boolean;\n    message: string;\n    planData: PlanData;\n}\n\ntype UploadMessage = UploadMessageComplete | UploadMessageStatus;\n\nexport const uploadEpic: UploadEpic = action$ => action$.pipe(\n    ofType(UploadActionType.UPLOAD_PLAN),\n    switchMap(action => {\n        const data = new FormData();\n        data.append(\"file\", action.payload.file, action.payload.filename);\n\n        return createFetchStream<UploadResult>(\"/api/plans/uploadPlan\",\n            {\n                method: \"POST\",\n                body: data\n            })\n            .pipe(\n                take(1),\n                switchMap(uploadResult =>\n                    createQueueStream<UploadMessage>(uploadResult.messageQueue)),\n                takeUntil(action$.pipe(filter(a => a.type === UploadActionType.CANCEL || a.type === UploadActionType.UPLOAD_ERROR || a.type === UploadActionType.UPLOAD_FINISHED))),\n                flatMap(message => message.complete\n                    ? [\n                        UploadActions.uploadFinished({ planData: message.planData }),\n                        PlanActions.receivePlan({ planData: message.planData }),\n                        push(`/view/${message.planData.guid}`)\n                    ]\n                    : message.error\n                        ? [ UploadActions.uploadError({ error: message.message }) ]\n                        : [ UploadActions.uploadStatus({ status: message.message }) ]),\n                catchError(error =>\n                    Rx.of(UploadActions.uploadError({ error: error.message })))\n            );\n    }));\n\n\n// ----------------\n// Reducer\n\nexport const reducer: Reducer<UploadState> = (state: UploadState = initialState, incomingAction: Action) => {\n    const action = incomingAction as AnyUploadAction;\n    switch (action.type) {\n        case UploadActionType.CANCEL:\n        case UploadActionType.CLEAR_ERROR:\n        case UploadActionType.UPLOAD_FINISHED:\n            return {\n                isUploading: false\n            };\n        case UploadActionType.UPLOAD_ERROR:\n            return {\n                errorText: action.payload.error,\n                isUploading: false\n            };\n        case UploadActionType.UPLOAD_STATUS:\n            return {\n                uploadMessage: action.payload.status,\n                isUploading: true\n            };\n        case UploadActionType.UPLOAD_PLAN:\n            return {\n                uploadMessage: `Uploading ${action.payload.filename}`,\n                isUploading: true\n            };\n    }\n\n    // TODO handle the fact that this breaks the switch above...\n    return state;\n};\n","'use strict';\n\nvar stringify = require('./stringify');\nvar parse = require('./parse');\nvar formats = require('./formats');\n\nmodule.exports = {\n    formats: formats,\n    parse: parse,\n    stringify: stringify\n};\n","'use strict';\n\nvar formats = require('./formats');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar hexTable = (function () {\n    var array = [];\n    for (var i = 0; i < 256; ++i) {\n        array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());\n    }\n\n    return array;\n}());\n\nvar compactQueue = function compactQueue(queue) {\n    while (queue.length > 1) {\n        var item = queue.pop();\n        var obj = item.obj[item.prop];\n\n        if (isArray(obj)) {\n            var compacted = [];\n\n            for (var j = 0; j < obj.length; ++j) {\n                if (typeof obj[j] !== 'undefined') {\n                    compacted.push(obj[j]);\n                }\n            }\n\n            item.obj[item.prop] = compacted;\n        }\n    }\n};\n\nvar arrayToObject = function arrayToObject(source, options) {\n    var obj = options && options.plainObjects ? Object.create(null) : {};\n    for (var i = 0; i < source.length; ++i) {\n        if (typeof source[i] !== 'undefined') {\n            obj[i] = source[i];\n        }\n    }\n\n    return obj;\n};\n\nvar merge = function merge(target, source, options) {\n    /* eslint no-param-reassign: 0 */\n    if (!source) {\n        return target;\n    }\n\n    if (typeof source !== 'object') {\n        if (isArray(target)) {\n            target.push(source);\n        } else if (target && typeof target === 'object') {\n            if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {\n                target[source] = true;\n            }\n        } else {\n            return [target, source];\n        }\n\n        return target;\n    }\n\n    if (!target || typeof target !== 'object') {\n        return [target].concat(source);\n    }\n\n    var mergeTarget = target;\n    if (isArray(target) && !isArray(source)) {\n        mergeTarget = arrayToObject(target, options);\n    }\n\n    if (isArray(target) && isArray(source)) {\n        source.forEach(function (item, i) {\n            if (has.call(target, i)) {\n                var targetItem = target[i];\n                if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {\n                    target[i] = merge(targetItem, item, options);\n                } else {\n                    target.push(item);\n                }\n            } else {\n                target[i] = item;\n            }\n        });\n        return target;\n    }\n\n    return Object.keys(source).reduce(function (acc, key) {\n        var value = source[key];\n\n        if (has.call(acc, key)) {\n            acc[key] = merge(acc[key], value, options);\n        } else {\n            acc[key] = value;\n        }\n        return acc;\n    }, mergeTarget);\n};\n\nvar assign = function assignSingleSource(target, source) {\n    return Object.keys(source).reduce(function (acc, key) {\n        acc[key] = source[key];\n        return acc;\n    }, target);\n};\n\nvar decode = function (str, decoder, charset) {\n    var strWithoutPlus = str.replace(/\\+/g, ' ');\n    if (charset === 'iso-8859-1') {\n        // unescape never throws, no try...catch needed:\n        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n    }\n    // utf-8\n    try {\n        return decodeURIComponent(strWithoutPlus);\n    } catch (e) {\n        return strWithoutPlus;\n    }\n};\n\nvar encode = function encode(str, defaultEncoder, charset, kind, format) {\n    // This code was originally written by Brian White (mscdex) for the io.js core querystring library.\n    // It has been adapted here for stricter adherence to RFC 3986\n    if (str.length === 0) {\n        return str;\n    }\n\n    var string = str;\n    if (typeof str === 'symbol') {\n        string = Symbol.prototype.toString.call(str);\n    } else if (typeof str !== 'string') {\n        string = String(str);\n    }\n\n    if (charset === 'iso-8859-1') {\n        return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {\n            return '%26%23' + parseInt($0.slice(2), 16) + '%3B';\n        });\n    }\n\n    var out = '';\n    for (var i = 0; i < string.length; ++i) {\n        var c = string.charCodeAt(i);\n\n        if (\n            c === 0x2D // -\n            || c === 0x2E // .\n            || c === 0x5F // _\n            || c === 0x7E // ~\n            || (c >= 0x30 && c <= 0x39) // 0-9\n            || (c >= 0x41 && c <= 0x5A) // a-z\n            || (c >= 0x61 && c <= 0x7A) // A-Z\n            || (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )\n        ) {\n            out += string.charAt(i);\n            continue;\n        }\n\n        if (c < 0x80) {\n            out = out + hexTable[c];\n            continue;\n        }\n\n        if (c < 0x800) {\n            out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]);\n            continue;\n        }\n\n        if (c < 0xD800 || c >= 0xE000) {\n            out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]);\n            continue;\n        }\n\n        i += 1;\n        c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));\n        out += hexTable[0xF0 | (c >> 18)]\n            + hexTable[0x80 | ((c >> 12) & 0x3F)]\n            + hexTable[0x80 | ((c >> 6) & 0x3F)]\n            + hexTable[0x80 | (c & 0x3F)];\n    }\n\n    return out;\n};\n\nvar compact = function compact(value) {\n    var queue = [{ obj: { o: value }, prop: 'o' }];\n    var refs = [];\n\n    for (var i = 0; i < queue.length; ++i) {\n        var item = queue[i];\n        var obj = item.obj[item.prop];\n\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; ++j) {\n            var key = keys[j];\n            var val = obj[key];\n            if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {\n                queue.push({ obj: obj, prop: key });\n                refs.push(val);\n            }\n        }\n    }\n\n    compactQueue(queue);\n\n    return value;\n};\n\nvar isRegExp = function isRegExp(obj) {\n    return Object.prototype.toString.call(obj) === '[object RegExp]';\n};\n\nvar isBuffer = function isBuffer(obj) {\n    if (!obj || typeof obj !== 'object') {\n        return false;\n    }\n\n    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n};\n\nvar combine = function combine(a, b) {\n    return [].concat(a, b);\n};\n\nvar maybeMap = function maybeMap(val, fn) {\n    if (isArray(val)) {\n        var mapped = [];\n        for (var i = 0; i < val.length; i += 1) {\n            mapped.push(fn(val[i]));\n        }\n        return mapped;\n    }\n    return fn(val);\n};\n\nmodule.exports = {\n    arrayToObject: arrayToObject,\n    assign: assign,\n    combine: combine,\n    compact: compact,\n    decode: decode,\n    encode: encode,\n    isBuffer: isBuffer,\n    isRegExp: isRegExp,\n    maybeMap: maybeMap,\n    merge: merge\n};\n","export const buildVersion = \"v33\";\n","import * as React from \"react\";\nimport Helmet from \"react-helmet\";\n\nimport { Layout } from \"./Layout\";\n\n\nexport function NotFound(): JSX.Element {\n    return <Layout skipUser={true}>\n        <Helmet>\n            <title>404 File Not Found</title>\n        </Helmet>\n        <h2>404 - File not found</h2>\n        <p>The file you selected could not be found; please try again.</p>\n    </Layout>;\n}\n","module.exports = (__webpack_require__(3))(397);","module.exports = (__webpack_require__(3))(294);","module.exports = (__webpack_require__(3))(61);","module.exports = (__webpack_require__(3))(163);","module.exports = (__webpack_require__(3))(271);","module.exports = (__webpack_require__(3))(363);","module.exports = (__webpack_require__(3))(273);","module.exports = (__webpack_require__(3))(54);","module.exports = (__webpack_require__(3))(292);","module.exports = (__webpack_require__(3))(45);","module.exports = (__webpack_require__(3))(133);","module.exports = (__webpack_require__(3))(278);","module.exports = (__webpack_require__(3))(127);","import { ConnectedRouter } from \"connected-react-router\";\nimport { createBrowserHistory } from \"history\";\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport { AppContainer } from \"react-hot-loader\";\nimport { Provider } from \"react-redux\";\nimport { ajax } from \"rxjs/ajax\";\n\nimport { configureStore } from \"./configureStore\";\nimport * as RoutesModule from \"./routes\";\nimport { getServerOptions, setServerOptions } from \"./serverOptions\";\nimport { ApplicationState } from \"./store\";\nimport { UserActions } from \"./store/user\";\nimport { buildVersion } from \"./version\";\n\n\nlet routes = RoutesModule.routes;\n\n// Create browser history to use in the Redux store\nconst baseUrl = document.getElementsByTagName(\"base\")[0].getAttribute(\"href\")!;\nconst history = createBrowserHistory({ basename: baseUrl });\n\n// Get the application-wide store instance, prepopulating with state from the server where available.\nsetServerOptions((window as any).serverOptions);\nconst initialState = (window as any).initialReduxState as ApplicationState;\nconst store = configureStore(history, initialState);\n\nfunction renderApp(): void {\n    // This code starts up the React app when it runs in a browser. It sets up the routing configuration\n    // and injects the app into a DOM element.\n    ReactDOM.hydrate(\n        <AppContainer>\n            <Provider store={ store }>\n                <ConnectedRouter history={ history } children={ routes } />\n            </Provider>\n        </AppContainer>,\n        document.getElementById(\"react-app\")\n    );\n\n    if (getServerOptions().oAuthConfigs.Google || getServerOptions().oAuthConfigs.TrimbleConnect) {\n        store.dispatch(UserActions.enableLogins());\n        store.dispatch(UserActions.loadUser());\n    }\n\n    ajax({\n        url: \"api/version\",\n        responseType: \"text\"\n    }).subscribe(\n        response => {\n            if (buildVersion !== response.response) {\n                location.reload(true);\n            }\n        }\n    );\n}\n\nrenderApp();\n\n// Allow Hot Module Replacement\nif (module.hot) {\n    module.hot.accept(\"./routes\", () => {\n        // Justification: this is needed for hot reloading\n        // tslint:disable-next-line:no-require-imports\n        routes = require<typeof RoutesModule>(\"./routes\").routes;\n        renderApp();\n    });\n}\n","module.exports = (__webpack_require__(3))(34);","module.exports = (__webpack_require__(3))(440);","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./dist/react-hot-loader.production.min.js');\n} else if (process.env.NODE_ENV === 'test') {\n  module.exports = require('./dist/react-hot-loader.production.min.js');\n} else if (typeof window === 'undefined') {\n  // this is just server environment\n  module.exports = require('./dist/react-hot-loader.production.min.js');\n} else if (!module.hot) {\n  module.exports = require('./dist/react-hot-loader.production.min.js');\n  module.exports.AppContainer.warnAboutHMRDisabled = true;\n  module.exports.hot.shouldWrapWithAppContainer = true;\n} else {\n  var evalAllowed = false;\n  try {\n    eval('evalAllowed = true');\n  } catch (e) {\n    // eval not allowed due to CSP\n  }\n\n  // RHL needs setPrototypeOf to operate Component inheritance, and eval to patch methods\n  var jsFeaturesPresent = !!Object.setPrototypeOf;\n\n  if (!jsFeaturesPresent || !evalAllowed) {\n    // we are not in prod mode, but RHL could not be activated\n    console.warn('React-Hot-Loader is not supported in this environment.');\n    module.exports = require('./dist/react-hot-loader.production.min.js');\n  } else {\n    module.exports = window.reactHotLoaderGlobal = require('./dist/react-hot-loader.development.js');\n  }\n}\n","\"use strict\";function _interopDefault(e){return e&&\"object\"==typeof e&&\"default\"in e?e.default:e}Object.defineProperty(exports,\"__esModule\",{value:!0});var React=_interopDefault(require(\"react\"));function AppContainer(e){return AppContainer.warnAboutHMRDisabled&&(AppContainer.warnAboutHMRDisabled=!0,console.error(\"React-Hot-Loader: misconfiguration detected, using production version in not production environment.\"),console.error(\"React-Hot-Loader: Hot Module Replacement is not enabled.\")),React.Children.only(e.children)}AppContainer.warnAboutHMRDisabled=!1;var hot=function e(){return e.shouldWrapWithAppContainer?function(e){return function(n){return React.createElement(AppContainer,null,React.createElement(e,n))}}:function(e){return e}};hot.shouldWrapWithAppContainer=!1;var areComponentsEqual=function(e,n){return e===n},setConfig=function(){},cold=function(e){return e},configureComponent=function(){};exports.AppContainer=AppContainer,exports.hot=hot,exports.areComponentsEqual=areComponentsEqual,exports.setConfig=setConfig,exports.cold=cold,exports.configureComponent=configureComponent;\n","import { routerMiddleware } from \"connected-react-router\";\nimport { History } from \"history\";\nimport { applyMiddleware, compose, createStore, Store } from \"redux\";\nimport { createEpicMiddleware } from \"redux-observable\";\nimport { BehaviorSubject } from \"rxjs\";\nimport { switchMap } from \"rxjs/operators\";\n\nimport * as StoreModule from \"./store\";\nimport { windowIfDefined } from \"./utils/window\";\n\n\ndeclare global {\n    interface Window {\n        __REDUX_DEVTOOLS_EXTENSION_COMPOSE__?: <R>(...funcs: Function[]) => (...args: any[]) => R;\n    }\n}\n\n\nexport function configureStore(history: History, initialState?: StoreModule.ApplicationState): Store<StoreModule.ApplicationState> {\n    // if devTools is installed, connect to it\n    const composeEnhancers = (windowIfDefined && windowIfDefined.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || compose;\n\n    const epicMiddleware = createEpicMiddleware<StoreModule.AnyAction, StoreModule.AnyAction, StoreModule.ApplicationState>();\n    const store = createStore(\n        StoreModule.createRootReducer(history),\n        <any>(initialState || StoreModule.rootInitialState),\n        composeEnhancers(\n            applyMiddleware(\n                epicMiddleware,\n                routerMiddleware(history))\n        )\n    );\n\n    const epic$ = new BehaviorSubject<StoreModule.RootEpic>(StoreModule.rootEpic);\n    // Every time a new epic is given to epic$ it\n    // will unsubscribe from the previous one then\n    // call and subscribe to the new one because of\n    // how switchMap works\n    const hotReloadingEpic: StoreModule.RootEpic = (action$, store$) =>\n        epic$.pipe(\n            switchMap(epic => epic(action$, store$, undefined))\n        );\n\n    epicMiddleware.run(hotReloadingEpic);\n\n    // Enable Webpack hot module replacement for reducers\n    if (module.hot) {\n        module.hot.accept(\"./store\", () => {\n            // Justification: this is needed for hot reloading\n            // tslint:disable-next-line:no-require-imports\n            const nextStoreModule = require<typeof StoreModule>(\"./store\");\n            store.replaceReducer(nextStoreModule.createRootReducer(history));\n            epic$.next(nextStoreModule.rootEpic);\n        });\n    }\n\n    return store;\n}\n","import { connectRouter, RouterAction, RouterState } from \"connected-react-router\";\nimport { History } from \"history\";\nimport { combineReducers } from \"redux\";\nimport { combineEpics, Epic } from \"redux-observable\";\n\nimport * as Plans from \"./plans\";\nimport * as Upload from \"./upload\";\nimport * as User from \"./user\";\n\n\n// -----------------\n// State\n\nexport interface ApplicationState {\n    plans: Plans.PlansState;\n    router?: RouterState;\n    upload: Upload.UploadState;\n    user: User.UserState;\n}\n\nexport const rootInitialState: ApplicationState = {\n    plans: Plans.initialState,\n    upload: Upload.initialState,\n    user: User.initialState\n};\n\n\n// -----------------\n// Actions\n\nexport type AnyAction = Plans.AnyPlanAction\n    | Upload.AnyUploadAction\n    | User.AnyUserAction\n    | RouterAction;\n\n\n// -----------------\n// Epic\n\nexport type RootEpic = Epic<AnyAction, AnyAction, ApplicationState>;\n\nexport const rootEpic: RootEpic = combineEpics(\n    Plans.planEpic,\n    Upload.uploadEpic,\n    User.userEpic\n);\n\n\n// ----------------\n// Reducer\n\nexport const createRootReducer = (history: History) => combineReducers<ApplicationState>({\n    plans: Plans.reducer,\n    router: <any>connectRouter(history),\n    upload: Upload.reducer,\n    user: User.reducer\n});\n","import * as React from \"react\";\nimport Helmet from \"react-helmet\";\nimport { connect, DispatchProp } from \"react-redux\";\nimport { RouteComponentProps } from \"react-router-dom\";\n\nimport { AnyAction, ApplicationState }  from \"../store\";\nimport { UploadActions, UploadState } from \"../store/upload\";\n\nimport { Layout } from \"./Layout\";\nimport { PleaseWait } from \"./PleaseWait\";\n\n\ntype HomeProps =\n    UploadState\n    & RouteComponentProps<void>\n    & DispatchProp<AnyAction>;\n\n\nfunction Home(props: HomeProps): JSX.Element {\n    const buttonHandler = React.useCallback(() => {\n        const filenameElement = document.getElementById(\"filename\") as HTMLInputElement;\n        if (filenameElement) {\n            filenameElement.click();\n        }\n        return false;\n    }, []);\n    const hiddenFileHandler = React.useCallback(() => {\n        const filenameElement = document.getElementById(\"filename\") as HTMLInputElement;\n\n        const files = filenameElement && filenameElement.files;\n        if (files) {\n            props.dispatch(UploadActions.uploadPlan({\n                file: files[0],\n                filename: files[0].name\n            }));\n        }\n\n        return false;\n    }, [props.dispatch]);\n    const cancelUpload = React.useCallback(\n        () => props.dispatch(UploadActions.cancelUpload()),\n        [props.dispatch]);\n    const clearError = React.useCallback(\n        () => props.dispatch(UploadActions.clearError()),\n        [props.dispatch]);\n\n\n    return <Layout>\n        <Helmet>\n            <title>PDF to Point Cloud Survey Conversion</title>\n        </Helmet>\n        <h2>PDF to Point Cloud Survey Conversion</h2>\n        <p>Upload a PDF of a vectorized <i>survey</i> and get a 3D Point Cloud in DXF instantly.</p>\n        {props.isUploading ? renderUploadingProgress(props.uploadMessage, cancelUpload)\n            : props.errorText ? renderError(props.errorText, clearError)\n            : renderUploadForm(buttonHandler, hiddenFileHandler)\n        }\n    </Layout>;\n}\n\n\nfunction renderUploadingProgress(uploadMessage: string | undefined, cancelUpload: () => void): JSX.Element {\n    return <div>\n        <PleaseWait>{uploadMessage || \"\"}</PleaseWait>\n        <p><a className=\"link\" onClick={cancelUpload}>Cancel</a></p>\n    </div>;\n}\n\n\nfunction renderError(errorText: string, clearError: () => void): JSX.Element {\n    return <p>Error encountered on upload: \"{errorText}\" <a className=\"link\" onClick={clearError}>Try again?</a></p>;\n}\n\n\nfunction renderUploadForm(buttonHandler: () => boolean, hiddenFileHandler: () => boolean): JSX.Element {\n    return <form encType=\"multipart/form-data\" action=\"/api/plans/uploadPlan\" method=\"post\">\n        <div className=\"sqs-button-wrapper\">\n            <a className=\"sqs-button\" onClick={buttonHandler}>Upload Survey PDF</a>\n        </div>\n        <input className=\"hidden\" type=\"file\" accept=\".pdf\" name=\"file\" id=\"filename\"\n            onChange={hiddenFileHandler} autoComplete=\"off\"/>\n    </form>;\n}\n\n\nexport const ConnectedHome = connect(\n    (state: ApplicationState) => state.upload\n)(Home);\n","module.exports = (__webpack_require__(3))(400);","module.exports = (__webpack_require__(3))(415);","import { SQSClient, ReceiveMessageResult, ReceiveMessageCommand, DeleteMessageCommand } from \"@aws-sdk/client-sqs\";\nimport { empty, from, of, Observable } from \"rxjs\";\nimport { delay, flatMap, repeatWhen, tap } from \"rxjs/operators\";\n\n\nfunction makeReceiveRequest(sqs: SQSClient, command: ReceiveMessageCommand): Observable<ReceiveMessageResult> {\n    return new Observable<ReceiveMessageResult>(subscriber => {\n        sqs.send(command, (err, data) => {\n            if (err) {\n                subscriber.error(err);\n            } else {\n                subscriber.next(data);\n                subscriber.complete();\n            }\n        });\n    });\n}\n\n\nfunction makeDeleteRequest(sqs: SQSClient, command: DeleteMessageCommand): void {\n    sqs.send(command, () => {\n        // don't care\n    });\n}\n\n\nexport function createQueueStream<T>(queueUrl: string): Observable<T> {\n    const receiveCommand = new ReceiveMessageCommand({\n        QueueUrl: queueUrl,\n        MaxNumberOfMessages: 1,\n        WaitTimeSeconds: 20\n    });\n\n    const sqs = new SQSClient({\n        credentials: {\n            accessKeyId: \"AKIASKVBAY6HWMKXVAJX\",\n            secretAccessKey: \"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\"\n        },\n        region: \"ca-central-1\"\n    });\n\n    return makeReceiveRequest(sqs, receiveCommand)\n        .pipe(\n            flatMap(result => result.Messages\n                ? from(result.Messages)\n                : empty()\n            ),\n            tap(message => {\n                if (message.ReceiptHandle) {\n                    makeDeleteRequest(sqs, new DeleteMessageCommand({\n                        QueueUrl: queueUrl,\n                        ReceiptHandle: message.ReceiptHandle\n                    }));\n                }\n            }),\n            flatMap(message => message.Body\n                ? of(JSON.parse(message.Body) as T)\n                : empty()\n            ),\n            repeatWhen(completed => completed.pipe(delay(100)))\n        );\n}\n","module.exports = (__webpack_require__(3))(367);","import * as React from \"react\";\nimport { connect, DispatchProp } from \"react-redux\";\n\nimport { getServerOptions } from \"../serverOptions\";\nimport { AnyAction, ApplicationState }  from \"../store\";\nimport { UserActions, UserState } from \"../store/user\";\nimport { OAuth2Provider } from \"../utils/oauth\";\nimport { GoogleButton } from \"./GoogleButton\";\nimport { PleaseWait } from \"./PleaseWait\";\n\n\ntype LoginButtonProps =\n    UserState\n    & DispatchProp<AnyAction>;\n\n\nfunction LoginButton(props: LoginButtonProps): JSX.Element {\n    const serverOptions = getServerOptions();\n    const logout = React.useCallback(\n        () => props.dispatch(UserActions.logout()),\n        [props.dispatch]);\n    const loginStartGoogle = React.useCallback(\n        () => props.dispatch(UserActions.loginStart(OAuth2Provider.Google)),\n        [props.dispatch]);\n    const loginStartProcore = React.useCallback(\n        () => props.dispatch(UserActions.loginStart(OAuth2Provider.Procore)),\n        [props.dispatch]);\n    const loginStartTrimble = React.useCallback(\n        () => props.dispatch(UserActions.loginStart(OAuth2Provider.TrimbleConnect)),\n        [props.dispatch]);\n\n    const loginOptions = <>\n        {serverOptions.oAuthConfigs.Google && <GoogleButton onClick={loginStartGoogle} size={32}></GoogleButton>}\n        {serverOptions.oAuthConfigs.TrimbleConnect && serverOptions.oAuthConfigs.Google && \" or \"}\n        {serverOptions.oAuthConfigs.TrimbleConnect && <a className=\"link\" onClick={loginStartTrimble}>Trimble Connect</a>}\n        {serverOptions.oAuthConfigs.Procore && (serverOptions.oAuthConfigs.Google || serverOptions.oAuthConfigs.TrimbleConnect) && \" or \"}\n        {serverOptions.oAuthConfigs.Procore && <a className=\"link\" onClick={loginStartProcore}>Procore</a>}\n    </>;\n\n    return props.loginEnabled\n        ? props.profile\n            ? <p>Hello {props.profile.username} ({props.profile.provider}) <a className=\"link\" onClick={logout}>Logout</a></p>\n            : props.isLoggingIn\n                ? <PleaseWait>Login in progress</PleaseWait>\n                : props.loginError\n                    ? <p>Error: {props.loginError} Try again with {loginOptions}?</p>\n                    : <p>Login with {loginOptions}</p>\n        : <div className=\"hidden\"></div>;\n}\n\n\nexport const ConnectedLoginButton = connect(\n    (state: ApplicationState) => state.user\n)(LoginButton);\n","'use strict';\n\nvar utils = require('./utils');\nvar formats = require('./formats');\nvar has = Object.prototype.hasOwnProperty;\n\nvar arrayPrefixGenerators = {\n    brackets: function brackets(prefix) {\n        return prefix + '[]';\n    },\n    comma: 'comma',\n    indices: function indices(prefix, key) {\n        return prefix + '[' + key + ']';\n    },\n    repeat: function repeat(prefix) {\n        return prefix;\n    }\n};\n\nvar isArray = Array.isArray;\nvar push = Array.prototype.push;\nvar pushToArray = function (arr, valueOrArray) {\n    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n};\n\nvar toISO = Date.prototype.toISOString;\n\nvar defaultFormat = formats['default'];\nvar defaults = {\n    addQueryPrefix: false,\n    allowDots: false,\n    charset: 'utf-8',\n    charsetSentinel: false,\n    delimiter: '&',\n    encode: true,\n    encoder: utils.encode,\n    encodeValuesOnly: false,\n    format: defaultFormat,\n    formatter: formats.formatters[defaultFormat],\n    // deprecated\n    indices: false,\n    serializeDate: function serializeDate(date) {\n        return toISO.call(date);\n    },\n    skipNulls: false,\n    strictNullHandling: false\n};\n\nvar isNonNullishPrimitive = function isNonNullishPrimitive(v) {\n    return typeof v === 'string'\n        || typeof v === 'number'\n        || typeof v === 'boolean'\n        || typeof v === 'symbol'\n        || typeof v === 'bigint';\n};\n\nvar stringify = function stringify(\n    object,\n    prefix,\n    generateArrayPrefix,\n    strictNullHandling,\n    skipNulls,\n    encoder,\n    filter,\n    sort,\n    allowDots,\n    serializeDate,\n    format,\n    formatter,\n    encodeValuesOnly,\n    charset\n) {\n    var obj = object;\n    if (typeof filter === 'function') {\n        obj = filter(prefix, obj);\n    } else if (obj instanceof Date) {\n        obj = serializeDate(obj);\n    } else if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        obj = utils.maybeMap(obj, function (value) {\n            if (value instanceof Date) {\n                return serializeDate(value);\n            }\n            return value;\n        });\n    }\n\n    if (obj === null) {\n        if (strictNullHandling) {\n            return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;\n        }\n\n        obj = '';\n    }\n\n    if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n        if (encoder) {\n            var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);\n            return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];\n        }\n        return [formatter(prefix) + '=' + formatter(String(obj))];\n    }\n\n    var values = [];\n\n    if (typeof obj === 'undefined') {\n        return values;\n    }\n\n    var objKeys;\n    if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        // we need to join elements in\n        objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : undefined }];\n    } else if (isArray(filter)) {\n        objKeys = filter;\n    } else {\n        var keys = Object.keys(obj);\n        objKeys = sort ? keys.sort(sort) : keys;\n    }\n\n    for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n        var value = typeof key === 'object' && key.value !== undefined ? key.value : obj[key];\n\n        if (skipNulls && value === null) {\n            continue;\n        }\n\n        var keyPrefix = isArray(obj)\n            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(prefix, key) : prefix\n            : prefix + (allowDots ? '.' + key : '[' + key + ']');\n\n        pushToArray(values, stringify(\n            value,\n            keyPrefix,\n            generateArrayPrefix,\n            strictNullHandling,\n            skipNulls,\n            encoder,\n            filter,\n            sort,\n            allowDots,\n            serializeDate,\n            format,\n            formatter,\n            encodeValuesOnly,\n            charset\n        ));\n    }\n\n    return values;\n};\n\nvar normalizeStringifyOptions = function normalizeStringifyOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (opts.encoder !== null && opts.encoder !== undefined && typeof opts.encoder !== 'function') {\n        throw new TypeError('Encoder has to be a function.');\n    }\n\n    var charset = opts.charset || defaults.charset;\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n\n    var format = formats['default'];\n    if (typeof opts.format !== 'undefined') {\n        if (!has.call(formats.formatters, opts.format)) {\n            throw new TypeError('Unknown format option provided.');\n        }\n        format = opts.format;\n    }\n    var formatter = formats.formatters[format];\n\n    var filter = defaults.filter;\n    if (typeof opts.filter === 'function' || isArray(opts.filter)) {\n        filter = opts.filter;\n    }\n\n    return {\n        addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,\n        allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,\n        encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,\n        encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,\n        encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n        filter: filter,\n        format: format,\n        formatter: formatter,\n        serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,\n        skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,\n        sort: typeof opts.sort === 'function' ? opts.sort : null,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (object, opts) {\n    var obj = object;\n    var options = normalizeStringifyOptions(opts);\n\n    var objKeys;\n    var filter;\n\n    if (typeof options.filter === 'function') {\n        filter = options.filter;\n        obj = filter('', obj);\n    } else if (isArray(options.filter)) {\n        filter = options.filter;\n        objKeys = filter;\n    }\n\n    var keys = [];\n\n    if (typeof obj !== 'object' || obj === null) {\n        return '';\n    }\n\n    var arrayFormat;\n    if (opts && opts.arrayFormat in arrayPrefixGenerators) {\n        arrayFormat = opts.arrayFormat;\n    } else if (opts && 'indices' in opts) {\n        arrayFormat = opts.indices ? 'indices' : 'repeat';\n    } else {\n        arrayFormat = 'indices';\n    }\n\n    var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];\n\n    if (!objKeys) {\n        objKeys = Object.keys(obj);\n    }\n\n    if (options.sort) {\n        objKeys.sort(options.sort);\n    }\n\n    for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n\n        if (options.skipNulls && obj[key] === null) {\n            continue;\n        }\n        pushToArray(keys, stringify(\n            obj[key],\n            key,\n            generateArrayPrefix,\n            options.strictNullHandling,\n            options.skipNulls,\n            options.encode ? options.encoder : null,\n            options.filter,\n            options.sort,\n            options.allowDots,\n            options.serializeDate,\n            options.format,\n            options.formatter,\n            options.encodeValuesOnly,\n            options.charset\n        ));\n    }\n\n    var joined = keys.join(options.delimiter);\n    var prefix = options.addQueryPrefix === true ? '?' : '';\n\n    if (options.charsetSentinel) {\n        if (options.charset === 'iso-8859-1') {\n            // encodeURIComponent('&#10003;'), the \"numeric entity\" representation of a checkmark\n            prefix += 'utf8=%26%2310003%3B&';\n        } else {\n            // encodeURIComponent('✓')\n            prefix += 'utf8=%E2%9C%93&';\n        }\n    }\n\n    return joined.length > 0 ? prefix + joined : '';\n};\n","'use strict';\n\nvar utils = require('./utils');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar defaults = {\n    allowDots: false,\n    allowPrototypes: false,\n    arrayLimit: 20,\n    charset: 'utf-8',\n    charsetSentinel: false,\n    comma: false,\n    decoder: utils.decode,\n    delimiter: '&',\n    depth: 5,\n    ignoreQueryPrefix: false,\n    interpretNumericEntities: false,\n    parameterLimit: 1000,\n    parseArrays: true,\n    plainObjects: false,\n    strictNullHandling: false\n};\n\nvar interpretNumericEntities = function (str) {\n    return str.replace(/&#(\\d+);/g, function ($0, numberStr) {\n        return String.fromCharCode(parseInt(numberStr, 10));\n    });\n};\n\nvar parseArrayValue = function (val, options) {\n    if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {\n        return val.split(',');\n    }\n\n    return val;\n};\n\n// This is what browsers will submit when the ✓ character occurs in an\n// application/x-www-form-urlencoded body and the encoding of the page containing\n// the form is iso-8859-1, or when the submitted form has an accept-charset\n// attribute of iso-8859-1. Presumably also with other charsets that do not contain\n// the ✓ character, such as us-ascii.\nvar isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('&#10003;')\n\n// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.\nvar charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')\n\nvar parseValues = function parseQueryStringValues(str, options) {\n    var obj = {};\n    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, '') : str;\n    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;\n    var parts = cleanStr.split(options.delimiter, limit);\n    var skipIndex = -1; // Keep track of where the utf8 sentinel was found\n    var i;\n\n    var charset = options.charset;\n    if (options.charsetSentinel) {\n        for (i = 0; i < parts.length; ++i) {\n            if (parts[i].indexOf('utf8=') === 0) {\n                if (parts[i] === charsetSentinel) {\n                    charset = 'utf-8';\n                } else if (parts[i] === isoSentinel) {\n                    charset = 'iso-8859-1';\n                }\n                skipIndex = i;\n                i = parts.length; // The eslint settings do not allow break;\n            }\n        }\n    }\n\n    for (i = 0; i < parts.length; ++i) {\n        if (i === skipIndex) {\n            continue;\n        }\n        var part = parts[i];\n\n        var bracketEqualsPos = part.indexOf(']=');\n        var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;\n\n        var key, val;\n        if (pos === -1) {\n            key = options.decoder(part, defaults.decoder, charset, 'key');\n            val = options.strictNullHandling ? null : '';\n        } else {\n            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');\n            val = utils.maybeMap(\n                parseArrayValue(part.slice(pos + 1), options),\n                function (encodedVal) {\n                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');\n                }\n            );\n        }\n\n        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {\n            val = interpretNumericEntities(val);\n        }\n\n        if (part.indexOf('[]=') > -1) {\n            val = isArray(val) ? [val] : val;\n        }\n\n        if (has.call(obj, key)) {\n            obj[key] = utils.combine(obj[key], val);\n        } else {\n            obj[key] = val;\n        }\n    }\n\n    return obj;\n};\n\nvar parseObject = function (chain, val, options, valuesParsed) {\n    var leaf = valuesParsed ? val : parseArrayValue(val, options);\n\n    for (var i = chain.length - 1; i >= 0; --i) {\n        var obj;\n        var root = chain[i];\n\n        if (root === '[]' && options.parseArrays) {\n            obj = [].concat(leaf);\n        } else {\n            obj = options.plainObjects ? Object.create(null) : {};\n            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;\n            var index = parseInt(cleanRoot, 10);\n            if (!options.parseArrays && cleanRoot === '') {\n                obj = { 0: leaf };\n            } else if (\n                !isNaN(index)\n                && root !== cleanRoot\n                && String(index) === cleanRoot\n                && index >= 0\n                && (options.parseArrays && index <= options.arrayLimit)\n            ) {\n                obj = [];\n                obj[index] = leaf;\n            } else {\n                obj[cleanRoot] = leaf;\n            }\n        }\n\n        leaf = obj;\n    }\n\n    return leaf;\n};\n\nvar parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {\n    if (!givenKey) {\n        return;\n    }\n\n    // Transform dot notation to bracket notation\n    var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, '[$1]') : givenKey;\n\n    // The regex chunks\n\n    var brackets = /(\\[[^[\\]]*])/;\n    var child = /(\\[[^[\\]]*])/g;\n\n    // Get the parent\n\n    var segment = options.depth > 0 && brackets.exec(key);\n    var parent = segment ? key.slice(0, segment.index) : key;\n\n    // Stash the parent if it exists\n\n    var keys = [];\n    if (parent) {\n        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties\n        if (!options.plainObjects && has.call(Object.prototype, parent)) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n\n        keys.push(parent);\n    }\n\n    // Loop through children appending to the array until we hit depth\n\n    var i = 0;\n    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {\n        i += 1;\n        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n        keys.push(segment[1]);\n    }\n\n    // If there's a remainder, just add whatever is left\n\n    if (segment) {\n        keys.push('[' + key.slice(segment.index) + ']');\n    }\n\n    return parseObject(keys, val, options, valuesParsed);\n};\n\nvar normalizeParseOptions = function normalizeParseOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {\n        throw new TypeError('Decoder has to be a function.');\n    }\n\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n    var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;\n\n    return {\n        allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,\n        allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,\n        arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,\n        decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,\n        delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n        // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n        depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,\n        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n        interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n        parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,\n        parseArrays: opts.parseArrays !== false,\n        plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (str, opts) {\n    var options = normalizeParseOptions(opts);\n\n    if (str === '' || str === null || typeof str === 'undefined') {\n        return options.plainObjects ? Object.create(null) : {};\n    }\n\n    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;\n    var obj = options.plainObjects ? Object.create(null) : {};\n\n    // Iterate over the keys and setup the new object\n\n    var keys = Object.keys(tempObj);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');\n        obj = utils.merge(obj, newObj, options);\n    }\n\n    return utils.compact(obj);\n};\n","import { windowIfDefined } from \"./window\";\n\n\nexport interface SavedUserState {\n    username: string;\n    email: string;\n    clientToken: string;\n}\n\nconst userStateKey = \"userState\";\n\nexport function loadUserState(): SavedUserState | undefined {\n    const userStateJson = windowIfDefined && window.localStorage.getItem(userStateKey);\n    if (userStateJson) {\n        try {\n            const parsedData = JSON.parse(userStateJson) as Partial<SavedUserState>;\n            return parsedData.username && parsedData.email &&  parsedData.clientToken\n                ? {\n                    username: parsedData.username,\n                    email: parsedData.email,\n                    clientToken: parsedData.clientToken\n                }\n                : undefined;\n        }\n        catch {\n            // if it is not parsable, remove it\n            removeUserState();\n        }\n    }\n\n    return undefined;\n}\n\nexport function removeUserState(): void {\n    if (windowIfDefined) {\n        windowIfDefined.localStorage.removeItem(userStateKey);\n    }\n}\n\nexport function saveUserState(state: SavedUserState): void {\n    if (windowIfDefined) {\n        windowIfDefined.localStorage.setItem(userStateKey, JSON.stringify(state));\n    }\n}\n","import * as React from \"react\";\nimport { GoogleLogo } from \"./GoogleLogo\";\n\n\nexport interface GoogleButtonProps {\n    onClick: () => void;\n    size: number;\n}\n\n\nexport function GoogleButton(props: GoogleButtonProps): JSX.Element {\n    const pixelSize = props.size / 32.0;\n    const buttonStyle: React.CSSProperties = {\n        lineHeight: 0,\n        padding: 0,\n        background: \"#FFFFFF\",\n        display: \"inline-flex\"\n    };\n    const spanStyle: React.CSSProperties = {\n        marginLeft: `${pixelSize*16}px`,\n        marginRight: `${pixelSize*8}px`,\n        fontFamily: \"Roboto\",\n        fontSize: `${pixelSize*14}px`,\n        color: \"#8A8A8A\",\n        // verticalAlign: \"bottom\",\n        lineHeight: `${pixelSize*36}px`,\n        marginBottom: `-${pixelSize*8}px`\n    }\n    return <button onClick={props.onClick} style={buttonStyle}>\n        <GoogleLogo size={pixelSize*18} margin={`${pixelSize*8}px`}></GoogleLogo>\n        <span style={spanStyle}>Google</span>\n    </button>;\n}\n","import * as React from \"react\";\n\n\nexport interface GoogleLogoProps {\n    size: number;\n    margin?: string;\n}\n\n\nexport function GoogleLogo(props: GoogleLogoProps): JSX.Element {\n    return <svg\n        width={props.size}\n        height={props.size}\n        style={{\n            margin: props.margin\n        }}\n        viewBox=\"0 0 4.7624998 4.7624998\"\n        version=\"1.1\"\n        xmlns=\"http://www.w3.org/2000/svg\"\n    >\n        <g id=\"layer1\" transform=\"translate(-51.201225,-74.165142)\">\n            <path\n                d=\"m 55.868475,76.600511 c 0,-0.168852 -0.01515,-0.33121 -0.04329,-0.487074 H 53.58248 v 0.921111 h 1.281545 c -0.0552,0.297656 -0.222971,0.549853 -0.475167,0.718705 v 0.597477 h 0.769577 c 0.450272,-0.414554 0.710045,-1.02502 0.710045,-1.750219 z\"\n                id=\"Shape\"\n                fill=\"#4285f4\"\n                fillRule=\"evenodd\"\n                stroke=\"none\"\n                strokeWidth=\"0.264583\" />\n            <path\n                d=\"m 53.582475,78.927642 c 0.642937,0 1.181966,-0.21323 1.575955,-0.576912 l -0.769577,-0.597477 c -0.21323,0.142875 -0.485992,0.227301 -0.806378,0.227301 -0.620207,0 -1.145165,-0.418884 -1.332418,-0.981725 h -0.795554 v 0.616961 c 0.391824,0.778236 1.19712,1.311852 2.127972,1.311852 z\"\n                id=\"path43\"\n                fill=\"#34a853\"\n                fillRule=\"evenodd\"\n                stroke=\"none\"\n                strokeWidth=\"0.264583\" />\n            <path\n                d=\"m 52.250057,76.998829 c -0.04762,-0.142875 -0.07468,-0.295491 -0.07468,-0.452437 0,-0.156946 0.02706,-0.309563 0.07468,-0.452438 v -0.61696 h -0.795554 c -0.161275,0.321469 -0.253278,0.685151 -0.253278,1.069398 0,0.384247 0.092,0.747929 0.253278,1.069398 z\"\n                id=\"path45\"\n                fill=\"#fbbc05\"\n                fillRule=\"evenodd\"\n                stroke=\"none\"\n                strokeWidth=\"0.264583\" />\n            <path\n                d=\"m 53.582475,75.11223 c 0.349611,0 0.663503,0.120145 0.910287,0.356105 l 0.682986,-0.682986 c -0.412389,-0.384247 -0.951418,-0.620207 -1.593273,-0.620207 -0.930852,0 -1.736148,0.533616 -2.127972,1.311852 l 0.795554,0.61696 c 0.187253,-0.56284 0.712211,-0.981724 1.332418,-0.981724 z\"\n                id=\"path47\"\n                fill=\"#ea4335\"\n                fillRule=\"evenodd\"\n                stroke=\"none\"\n                strokeWidth=\"0.264583\" />\n        </g>\n    </svg>;\n}\n","import * as React from \"react\";\n\n\nexport interface ThreeDotsProps {\n    color: string;\n    height: number;\n    width: number;\n}\n\n\nexport function ThreeDots(props: ThreeDotsProps): JSX.Element {\n    return <svg\n        width={props.width}\n        height={props.height}\n        viewBox=\"0 0 120 30\"\n        xmlns=\"http://www.w3.org/2000/svg\"\n        fill={props.color}\n    >\n        <circle cx=\"15\" cy=\"15\" r=\"15\">\n        <animate\n            attributeName=\"r\"\n            from=\"15\"\n            to=\"15\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\"15;9;15\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        <animate\n            attributeName=\"fillOpacity\"\n            from=\"1\"\n            to=\"1\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\"1;.5;1\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        </circle>\n        <circle cx=\"60\" cy=\"15\" r=\"9\" attributeName=\"fillOpacity\" from=\"1\" to=\"0.3\">\n        <animate\n            attributeName=\"r\"\n            from=\"9\"\n            to=\"9\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\"9;15;9\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        <animate\n            attributeName=\"fillOpacity\"\n            from=\"0.5\"\n            to=\"0.5\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\".5;1;.5\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        </circle>\n        <circle cx=\"105\" cy=\"15\" r=\"15\">\n        <animate\n            attributeName=\"r\"\n            from=\"15\"\n            to=\"15\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\"15;9;15\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        <animate\n            attributeName=\"fillOpacity\"\n            from=\"1\"\n            to=\"1\"\n            begin=\"0s\"\n            dur=\"0.8s\"\n            values=\"1;.5;1\"\n            calcMode=\"linear\"\n            repeatCount=\"indefinite\"\n        />\n        </circle>\n    </svg>;\n}\n","import * as React from \"react\";\n\nimport { sendResultMessage } from \"../utils/oauth\";\nimport { windowIfDefined } from \"../utils/window\";\n\n\nexport function OAuth2Redirect(): JSX.Element {\n    React.useEffect(() => {\n        if (windowIfDefined && windowIfDefined.location) {\n            sendResultMessage(windowIfDefined.location);\n        }\n    });\n\n    return <h2>\n        Completing login...\n    </h2>;\n}\n","import * as React from \"react\";\nimport Helmet from \"react-helmet\";\nimport { connect, DispatchProp } from \"react-redux\";\nimport { NavLink } from \"react-router-dom\";\n\nimport { getServerOptions, ServerOptions } from \"../serverOptions\";\nimport { AnyAction, ApplicationState }  from \"../store\";\nimport { PlansState, PlanActions, PlanData } from \"../store/plans\";\nimport { UserProfile, UserState } from \"../store/user\";\nimport { OAuth2Provider } from \"../utils/oauth\";\n\nimport { StripeSubmitCallback } from \"./CheckoutForm\";\nimport { CheckoutFormContainer } from \"./CheckoutFormContainer\";\nimport { LayeredDetailList } from \"./LayeredDetailList\";\nimport { Layout } from \"./Layout\";\nimport { NotFound } from \"./NotFound\";\nimport { PlanDetailList } from \"./PlanDetailList\";\nimport { PleaseWait } from \"./PleaseWait\";\nimport { TrimbleProject } from \"./TrimbleProjectList\";\n\n\ntype ViewPlanProps = PlansState\n    & UserState\n    & DispatchProp<AnyAction>;\n\n\nfunction ViewPlan(props: ViewPlanProps): JSX.Element {\n    const serverOptions = getServerOptions();\n    const planData = props.plans[props.currentPlanGuid || \"\"];\n    React.useEffect(() => {\n        if (serverOptions.freeMode && props.currentPlanGuid && props.profile && planData && !planData.available) {\n            props.dispatch(PlanActions.loadPlan({ guid: props.currentPlanGuid }));\n        }\n    }, [props.currentPlanGuid, props.profile]);\n\n    const stripeSubmitCallback = React.useCallback((stripeToken: string, email: string, selectedProject?: TrimbleProject): void => {\n        props.dispatch(PlanActions.payForPlan({\n            email,\n            guid: props.currentPlanGuid || \"\",\n            selectedProject,\n            stripeToken\n        }));\n\n    }, [props.dispatch, props.currentPlanGuid]);\n\n    if (props.isLoading) {\n        return renderLoading();\n    }\n\n    if (planData) {\n        if (planData.nothing) {\n            if (planData.available) {\n                return renderNothing(planData, serverOptions, props.profile);\n            } else {\n                return renderNothingLoginRequired(planData);\n            }\n        } else if (serverOptions.freeMode) {\n            if (planData.available) {\n                return renderFreeMode(planData, serverOptions, props.profile);\n            } else {\n                return renderFreeModeLoginRequired(planData, serverOptions);\n            }\n        } else if (planData.free) {\n            return renderFree(planData, serverOptions);\n        } else if (planData.paid) {\n            return renderPaid(planData, serverOptions);\n        } else {\n            return renderUnpaid(props, planData, serverOptions, stripeSubmitCallback);\n        }\n    } else {\n        return <NotFound></NotFound>;\n    }\n}\n\n\nfunction countSpots(planData: PlanData, confidentOnly: boolean = false): number {\n    return planData.spotPages.reduce((sum, page) => sum + (confidentOnly ? page.spotsConfident : page.spotsFound), 0);\n}\n\n\nfunction renderFree(planData: PlanData, serverOptions: ServerOptions): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Results for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Point Cloud Conversion Summary</h2>\n        <p>\n        We found only {countSpots(planData, true)} spot elevations and {planData.tableData.tableCount} legends, so this one is on us!\n        </p>\n        <p>\n        Here's a quick summary:\n        </p>\n        <PlanDetailList planData={planData} serverOptions={serverOptions}></PlanDetailList>\n        <ResultsFooter></ResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderFreeMode(planData: PlanData, serverOptions: ServerOptions, profile: UserProfile | null): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Results for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Point Cloud Conversion Summary</h2>\n        <p>\n        Congratulations{(profile ? ` ${profile.username}` : \"\")}, Construction AI fully converted {countSpots(planData, true)} spot elevations and {planData.tableData.tableCount} legends from \"{planData.nameWithoutExtension}.pdf\".\n        </p>\n        <p>\n        Here's a quick summary:\n        </p>\n        <PlanDetailList planData={planData} serverOptions={serverOptions}></PlanDetailList>\n        <ResultsFooter></ResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderFreeModeLoginRequired(planData: PlanData, serverOptions: ServerOptions): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Preview for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Point Cloud Conversion Summary</h2>\n        <p>\n        Congratulations, Construction AI fully converted {countSpots(planData, true)} spot elevations and {planData.tableData.tableCount} legends from \"{planData.nameWithoutExtension}.pdf\".\n        All you have to do to see the results is log in!\n        </p>\n        <p>\n        Here's a quick summary:\n        </p>\n        <PlanDetailList planData={planData} serverOptions={serverOptions}></PlanDetailList>\n        <ResultsFooter></ResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderLoading(): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Loading...</title>\n        </Helmet>\n        <h2>Loading...</h2>\n        <PleaseWait>Please wait while the results load</PleaseWait>\n    </Layout>;\n}\n\n\nfunction renderNothing(planData: PlanData, serverOptions: ServerOptions, profile: UserProfile | null): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Results for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Let’s Try Again!</h2>\n        <p>\n        Hi{(profile ? ` ${profile.username}` : \"\")},\n        </p>\n        <p>\n        It looks like we may have had trouble converting \"{planData.nameWithoutExtension}.pdf\" into a point cloud. There are a few reasons why this may have been:\n        </p>\n        <ol>\n        <li key=\"not-vectors\">If the spot elevations aren’t vectors (polylines) we’re unable to process them.</li>\n        <li key=\"raster\">If the file is raster (like a scanned document) we’re also unable to do a conversion.</li>\n        <li key=\"shrug\">It could also just be one of those things, and we’d love to help get you the data you need. Please <a href=\"https://www.construction.ai/contact-us\">email us</a> and we’ll see what we can do to help you.</li>\n        </ol>\n        <p>\n        In the meantime, feel free to download these output files:\n        </p>\n        <LayeredDetailList planData={planData} serverOptions={serverOptions}></LayeredDetailList>\n        <NoResultsFooter></NoResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderNothingLoginRequired(planData: PlanData): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Results for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Let’s Try Again!</h2>\n        <p>\n        Hi,\n        </p>\n        <p>\n        It looks like we may have had trouble converting \"{planData.nameWithoutExtension}.pdf\" into a point cloud. There are a few reasons why this may have been:\n        </p>\n        <ol>\n        <li key=\"not-vectors\">If the spot elevations aren’t vectors (polylines) we’re unable to process them.</li>\n        <li key=\"raster\">If the file is raster (like a scanned document) we’re also unable to do a conversion.</li>\n        <li key=\"shrug\">It could also just be one of those things, and we’d love to help get you the data you need. Please <a href=\"https://www.construction.ai/contact-us\">email us</a> and we’ll see what we can do to help you.</li>\n        </ol>\n        <p>\n        In the meantime, if you log in you can download a layered output file.\n        </p>\n        <NoResultsFooter></NoResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderPaid(planData: PlanData, serverOptions: ServerOptions): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Results for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Point Cloud Conversion Summary</h2>\n        <p>\n        Congratulations, Construction AI fully converted {countSpots(planData, true)} spot elevations and {planData.tableData.tableCount} legends from \"{planData.nameWithoutExtension}.pdf\".\n        </p>\n        <p>\n        Here's a quick summary:\n        </p>\n        <PlanDetailList planData={planData} serverOptions={serverOptions}></PlanDetailList>\n        <ResultsFooter></ResultsFooter>\n    </Layout>;\n}\n\n\nfunction renderUnpaid(props: ViewPlanProps, planData: PlanData, serverOptions: ServerOptions, stripeSubmitCallback: StripeSubmitCallback): JSX.Element {\n    return <Layout>\n        <Helmet>\n            <title>Preview for {planData.nameWithoutExtension}.pdf</title>\n        </Helmet>\n        <h2>Point Cloud Conversion Summary</h2>\n        <p>\n        Congratulations, Construction AI fully converted {countSpots(planData, true)} spot elevations and {planData.tableData.tableCount} legends from \"{planData.nameWithoutExtension}.pdf\".\n        </p>\n        <p>\n        Here's a quick summary:\n        </p>\n        <PlanDetailList planData={planData} serverOptions={serverOptions}></PlanDetailList>\n        <CheckoutFormContainer\n            costDisplay={planData.costDisplay}\n            currencyCode={serverOptions.currencyCode}\n            email={props.profile && props.profile.email}\n            isTrimbleEmail={!!props.profile && props.profile.provider === OAuth2Provider.TrimbleConnect}\n            isPaying={props.isPaying}\n            onSubmit={stripeSubmitCallback}\n            errorText={props.errorText}\n            clearError={() => props.dispatch(PlanActions.clearError())} />\n        <NoResultsFooter></NoResultsFooter>\n    </Layout>;\n}\n\nfunction NoResultsFooter(): JSX.Element {\n    return <p>\n        Or, do you have another survey to try? Go ahead: <NavLink exact to={\"/\"}>upload another plan</NavLink>!\n    </p>;\n}\n\nfunction ResultsFooter(): JSX.Element {\n    return <p>\n        Got even more work to do? Go ahead: <NavLink exact to={\"/\"}>upload another plan</NavLink>!\n        <br></br>\n        Not what you expected? We’d like to hear about it! <a href=\"https://www.construction.ai/contact-us\">Contact us here</a>.\n    </p>;\n}\n\n\nexport const ConnectedViewPlan = connect(\n    (state: ApplicationState) => ({\n        ...state.plans,\n        ...state.user\n    })\n)(ViewPlan);\n","import { Elements } from \"@stripe/react-stripe-js\";\nimport { Stripe } from \"@stripe/stripe-js\";\nimport * as React from \"react\";\n\nimport { getServerOptions } from \"../serverOptions\";\n\nimport { CheckoutForm, CheckoutFormProps } from \"./CheckoutForm\";\n\n\ntype CheckoutFormContainerProps = CheckoutFormProps;\n\n\nexport function CheckoutFormContainer(props: CheckoutFormContainerProps): JSX.Element {\n    const serverOptions = getServerOptions();\n    const [stripeInstance, setStripeInstance] = React.useState<Stripe | null>(null);\n    React.useEffect(() => {\n        if (!stripeInstance) {\n            // tslint:disable-next-line: no-require-imports\n            require(\"@stripe/stripe-js\")\n                .loadStripe(serverOptions.stripePublicApiKey)\n                .then((stripe: Stripe) => {\n                    setStripeInstance(stripe);\n                });\n        }\n    }, [serverOptions, stripeInstance]);\n\n    return <Elements stripe={stripeInstance}>\n        <CheckoutForm {...props} />\n    </Elements>;\n}\n","import { useElements, useStripe, CardElement } from \"@stripe/react-stripe-js\";\nimport { Stripe, StripeElements } from \"@stripe/stripe-js\";\nimport * as classnames from \"classnames\";\nimport * as React from \"react\";\n\nimport { Button } from \"./Button\";\nimport { Checkbox } from \"./Checkbox\";\nimport { PleaseWait } from \"./PleaseWait\";\nimport { Textbox } from \"./Textbox\";\nimport { TrimbleProject, TrimbleProjectList } from \"./TrimbleProjectList\";\n\n\nexport type StripeSubmitCallback = (stripeToken: string, email: string, selectedProject?: TrimbleProject) => void;\n\nexport interface CheckoutFormProps {\n    clearError: () => void;\n    costDisplay: string;\n    currencyCode: string;\n    email: string | null;\n    errorText?: string;\n    isPaying: boolean;\n    isTrimbleEmail: boolean;\n    onSubmit: StripeSubmitCallback;\n}\n\n\nexport function CheckoutForm(props: CheckoutFormProps): JSX.Element {\n    const [useTrimble, setUseTrimble] = React.useState(false);\n    const [typedEmail, setTypedEmail] = React.useState<string>();\n    const [selectedProject, setSelectedProject] = React.useState<TrimbleProject>();\n    const [waitingForStripe, setWaitingForStripe] = React.useState(false);\n    const [internalErrorText, setInternalErrorText] = React.useState<string>();\n    const clearErrorCallback = React.useCallback(() => {\n        if (internalErrorText) {\n            setInternalErrorText(undefined);\n        } else {\n            props.clearError();\n        }\n    }, [internalErrorText, props.clearError]);\n\n    const stripe = useStripe();\n    const stripeElements = useElements();\n\n    const submitCallback = React.useCallback(\n        createCallback(\n            props.email || typedEmail,\n            useTrimble,\n            selectedProject,\n            stripe,\n            stripeElements,\n            props.onSubmit,\n            setWaitingForStripe,\n            setInternalErrorText),\n        [props.email, typedEmail, useTrimble, selectedProject, stripe, stripeElements, setWaitingForStripe, setInternalErrorText]);\n\n    const classes = classnames([\n        \"checkout\",\n        props.isPaying || props.errorText || waitingForStripe ? \"checkout--disabled\" : undefined\n    ]);\n\n    const errorText = internalErrorText || props.errorText;\n    const button = errorText || props.isPaying || waitingForStripe\n        ? undefined\n        : <Button onClick={submitCallback}>Pay {props.costDisplay} {props.currencyCode}</Button>;\n    const status = errorText\n        ? <p className=\"always-visible\">Error encountered on payment: \"{errorText}\" <a className=\"link\" onClick={clearErrorCallback}>Try again?</a></p>\n        : props.isPaying || waitingForStripe\n            ? <PleaseWait>Processing payment of {props.costDisplay} {props.currencyCode}</PleaseWait>\n            : undefined;\n\n    return <div>\n        <div className={classes} >\n            <p>To purchase, please provide the following information:</p>\n            <CardElement></CardElement>\n            {!props.email && <Textbox label=\"Email\" id=\"email\" value={typedEmail} onChange={setTypedEmail} type=\"email\"></Textbox>}\n            {props.email && props.isTrimbleEmail && <Checkbox checked={useTrimble} id=\"saveToTrimble\" onChange={setUseTrimble} >Save to Trimble Connect</Checkbox>}\n            {props.email && useTrimble && <TrimbleProjectList onSelection={setSelectedProject} selectedProject={selectedProject} />}\n            {button}\n        </div>\n        {status}\n    </div>;\n}\n\n\ntype SetState<S> = React.Dispatch<React.SetStateAction<S>>;\n\n\nfunction createCallback(\n    email: string | undefined,\n    useTrimble: boolean,\n    selectedProject: TrimbleProject | undefined,\n    stripe: Stripe | null,\n    stripeElements: StripeElements | null,\n    onSubmit: StripeSubmitCallback,\n    setWaitingForStripe: SetState<boolean>,\n    setInternalErrorText: SetState<string | undefined>): () => void {\n    return () => {\n        if (!stripe || !stripeElements) {\n            // this shouldn't happen\n            console.error(\"Got null stripe object.\");\n            return;\n        }\n\n        const cardElement = stripeElements.getElement(CardElement);\n\n        if (!cardElement) {\n            // this shouldn't happen\n            console.error(\"Got null stripe CardElement object.\");\n            return;\n        }\n\n        if (!email) {\n            setInternalErrorText(\"Email must be specified.\");\n            return;\n        }\n\n        if (useTrimble && !selectedProject) {\n            setInternalErrorText(\"Please select a project.\");\n            return;\n        }\n\n        setWaitingForStripe(true);\n\n        stripe\n            .createToken(cardElement)\n            .then(result => {\n                if (result.token) {\n                    onSubmit(result.token.id, email, selectedProject);\n                    setWaitingForStripe(false);\n                } else {\n                    setWaitingForStripe(false);\n                    if (result.error) {\n                        setInternalErrorText(result.error.message);\n                    } else {\n                        setInternalErrorText(\"Failed to get token from Stripe\");\n                    }\n                }\n            })\n            .catch(error => {\n                console.error(\"Got unexpected error: \", error);\n                setWaitingForStripe(false);\n                setInternalErrorText(`Failed to get token from Stripe: ${error}`);\n            });\n    };\n}\n","module.exports = (__webpack_require__(3))(401);","import * as React from \"react\";\n\n\nexport interface ButtonProps {\n    id?: string;\n    onClick: () => void;\n    children: string | string[];\n}\n\n\nexport function Button(props: ButtonProps): JSX.Element {\n    return <button\n        id={props.id}\n        onClick={props.onClick}\n        className=\"construction-ai-button\"><span>{props.children}</span></button>;\n}\n","import * as React from \"react\";\n\n\nexport interface CheckboxProps {\n    checked: boolean;\n    id: string;\n    onChange: (checked: boolean) => void;\n    children: string | string[];\n}\n\n\nexport function Checkbox(props: CheckboxProps): JSX.Element {\n    const checkboxHandler = React.useCallback((event: React.ChangeEvent<HTMLInputElement>) => {\n        props.onChange(event.target.checked);\n    }, [props.onChange]);\n\n    return <label htmlFor={props.id} className=\"construction-ai-checkbox\">\n        <input type=\"checkbox\" id={props.id} checked={props.checked} onChange={checkboxHandler} className=\"custom\" />\n        {props.children}\n    </label>;\n}\n","import * as React from \"react\";\n\n\nexport interface TextboxProps {\n    id: string;\n    label: string;\n    onChange: (newValue?: string) => void;\n    type: string;\n    value?: string;\n}\n\n\nexport function Textbox(props: TextboxProps): JSX.Element {\n    const textboxHandler = React.useCallback((event: React.ChangeEvent<HTMLInputElement>) => {\n        props.onChange(event.target.value);\n    }, [props.onChange]);\n\n    return <p>{props.label}: <input type={props.type} id={props.id} value={props.value} onChange={textboxHandler}/></p>;\n}\n","import * as React from \"react\";\n\nimport { createFetchStream } from \"../utils/fetch\";\n\nimport { Picklist } from \"./Picklist\";\nimport { PleaseWait } from \"./PleaseWait\";\n\n\nexport interface TrimbleProject {\n    id: string;\n    name: string;\n    rootFolderId: string;\n}\n\n\nexport interface TrimbleProjectListProps {\n    id?: string;\n    onSelection: (selectedProject?: TrimbleProject) => void;\n    selectedProject?: TrimbleProject;\n}\n\n\nexport function TrimbleProjectList(props: TrimbleProjectListProps): JSX.Element {\n    const [projects, setProjects] = React.useState<TrimbleProject[]>();\n    React.useEffect(() => {\n        createFetchStream<TrimbleProject[]>(`api/trimble/get/projects`)\n            .subscribe(\n                loadedProjects => {\n                    if (loadedProjects && loadedProjects.length) {\n                        props.onSelection(loadedProjects[0]);\n                    }\n                    setProjects(loadedProjects || []);\n                },\n                _err => {\n                    // TODO do something!\n                }\n            );\n    }, []);\n\n    return projects\n        ? <Picklist id={props.id} items={projects} onSelection={props.onSelection} selectedItem={props.selectedProject}></Picklist>\n        : <PleaseWait>Loading project list</PleaseWait>;\n}\n","import * as React from \"react\";\n\n\nexport interface PicklistItem {\n    id: string;\n    name: string;\n}\n\n\nexport interface PicklistProps<TItem extends PicklistItem> {\n    id?: string;\n    items: TItem[];\n    onSelection: (selectedItem?: TItem) => void;\n    selectedItem?: TItem;\n}\n\n\n\nexport function Picklist<TItem extends PicklistItem>(props: PicklistProps<TItem>): JSX.Element {\n    const picklistHandler = React.useCallback((event: React.ChangeEvent<HTMLSelectElement>) => {\n        props.onSelection(props.items.find(i => i.id === event.target.value));\n    }, [props.onSelection]);\n\n    return <select id={props.id} value={props.selectedItem && props.selectedItem.id} onChange={picklistHandler} className=\"construction-ai-picklist\">\n        {props.items.map(p => <option value={p.id} className=\"construction-ai-picklist-option\">{p.name}</option>)}\n    </select>;\n}\n","module.exports = (__webpack_require__(3))(399);","import * as React from \"react\";\n\nimport { ServerOptions } from \"../serverOptions\";\nimport { PlanData } from \"../store/plans\";\n\n\ninterface LayeredDetailListProps {\n    planData: PlanData;\n    serverOptions: ServerOptions;\n}\n\n\nexport function LayeredDetailList({ planData, serverOptions }: LayeredDetailListProps): JSX.Element {\n    const outputAvailable = planData.available;\n\n    return <ul>\n        <li key=\"original-input\">Original input PDF used is <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${planData.nameWithoutExtension}.pdf`}>{planData.nameWithoutExtension}.pdf</a></li>\n\n        {outputAvailable && planData.layeredPages\n            .map(page => {\n                return <li key={`layers-${page.pageNumber}`}>Layered output for page {page.pageNumber}:\n                    <ul key={`spot-output-${page.pageNumber}`}>\n                        <li key={`dxf-output-layers-${page.pageNumber}`}>DXF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${page.dxfOutputFile}`}>Download</a></li>\n                        <li key={`pdf-output-layers-${page.pageNumber}`}>PDF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${page.pdfOutputFile}`}>Download</a></li>\n                    </ul>\n                </li>\n            })}\n    </ul>;\n}\n","import * as React from \"react\";\n\nimport { ServerOptions } from \"../serverOptions\";\nimport { FeaturePageData, PlanData, SpotPageData } from \"../store/plans\";\n\n\ninterface PlanDetailListProps {\n    planData: PlanData;\n    serverOptions: ServerOptions;\n}\n\n\nexport function PlanDetailList({ planData, serverOptions }: PlanDetailListProps): JSX.Element {\n    const outputAvailable = planData.available;\n    const needToPay = !outputAvailable && !serverOptions.freeMode;\n    const showDetails = !planData.paid;\n    const featureCount = planData.featurePages.reduce((sum, page) => sum + page.featureCount, 0);\n    const featureTypes: { [featureType: string]: boolean } = {};\n    const featuresByPage: { [pageNumber: number]: FeaturePageData } = {};\n    for (const featurePage of planData.featurePages) {\n        for (const feature of featurePage.featuresIdentified) {\n            if (feature.count > 0) {\n                featureTypes[feature.name.toLocaleLowerCase()] = true;\n            }\n        }\n        if (featurePage.featureCount > 0) {\n            featuresByPage[featurePage.pageNumber] = featurePage;\n        }\n    }\n    const tableData = planData.tableData;\n    const tablesFound = tableData && tableData.tableCount > 0;\n    const crossSectionData = planData.crossSectionData;\n    const crossSectionsFound = crossSectionData && crossSectionData.crossSectionCount > 0;\n    const spotsByPage: { [pageNumber: number]: SpotPageData } = {};\n    for (const spotPage of planData.spotPages) {\n        if (spotPage.spotsFound > 0) {\n            spotsByPage[spotPage.pageNumber] = spotPage;\n        }\n    }\n    const spotsFound = planData.spotPages.reduce((sum, page) => sum + page.spotsFound, 0) > 0;\n    const spotsConfident = planData.spotPages.reduce((sum, page) => sum + page.spotsConfident, 0);\n    const spotsUncertain = planData.spotPages.reduce((sum, page) => sum + page.spotsUncertain, 0);\n    const spotsUnmatched = planData.spotPages.reduce((sum, page) => sum + page.spotsUnmatched, 0);\n    const layers = planData.spotPages.reduce((sum, page) => sum + page.layerCount, 0);\n    const vectors = planData.spotPages.reduce((sum, page) => sum + page.vectorCount, 0);\n\n    return <ul>\n        <li key=\"original-input\">the original input PDF used is <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${planData.nameWithoutExtension}.pdf`}>{planData.nameWithoutExtension}.pdf</a></li>\n\n        {showDetails && spotsFound && <li key=\"confident\"><b>{spotsConfident}</b> spot elevations with fully x,y,z coordinates converted to DXF 3D.</li>}\n        {showDetails && spotsFound && <li key=\"less-confident\"><b>{spotsUncertain}</b> possible spot elevations with x,y,z coordinates converted to DXF in 3D.</li>}\n        {showDetails && spotsFound && <li key=\"unmatched\"><b>{spotsUnmatched}</b> coordinates found with x,y values converted to DXF.</li>}\n\n        {showDetails && <li key=\"layers\"><b>{layers}</b> new layers created and converted to DXF.</li>}\n        {showDetails && featureCount > 0 && <li key=\"feature-counts\"><b>{featureCount}</b> objects of interest found and printed to summary PDF.</li>}\n        {showDetails && <li key=\"vectors\"><b>{vectors}</b> vectors (polylines) extracted.</li>}\n\n        {showDetails && tablesFound && <li key=\"table-counts\"><b>{tableData.tableCount}</b> legends found.</li>}\n\n        {showDetails && crossSectionsFound && <li key=\"cross-section-counts\"><b>{crossSectionData.crossSectionCount}</b> cross section plots found.</li>}\n\n        {needToPay && <li key=\"cost\"><b>{planData.costDisplay}</b> {serverOptions.currencyCode} to purchase DXF (and summary PDF).</li>}\n\n        {outputAvailable && (spotsFound || featureCount > 0) && planData.spotPages\n            .map(page => {\n                return <li key={`spots-${page.pageNumber}`}>Results for page {page.pageNumber}:\n                    <ul key={`spot-output-${page.pageNumber}`}>\n                        <li key={`spot-count-${page.pageNumber}`}><b>{page.spotsConfident}</b> spot elevations found.</li>\n                        <li key={`dxf-output-spots-${page.pageNumber}`}>DXF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${page.dxfOutputFile}`}>Download</a></li>\n                        <li key={`pdf-output-spots-${page.pageNumber}`}>PDF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${page.pdfOutputFile}`}>Download</a></li>\n                    </ul>\n                </li>\n            })}\n\n        {outputAvailable && tablesFound && <li key=\"excel-output-tables\">Tables Excel output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${tableData.excelOutputFile}`}>Download</a></li>}\n        {outputAvailable && tablesFound && <li key=\"pdf-output-tables\">Tables PDF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${tableData.pdfOutputFile}`}>Download</a></li>}\n\n        {outputAvailable && crossSectionsFound && <li key=\"dxf-output-cross-sections\">Cross sections DXF output file: <a href={`https://${serverOptions.publishedDataHost}/published/${planData.guid}/${crossSectionData.dxfOutputFile}`}>Download</a></li>}\n    </ul>;\n}\n","import { root } from '../../util/root';\nimport { Observable } from '../../Observable';\nimport { Subscriber } from '../../Subscriber';\nimport { TeardownLogic } from '../../types';\nimport { map } from '../../operators/map';\n\nexport interface AjaxRequest {\n  url?: string;\n  body?: any;\n  user?: string;\n  async?: boolean;\n  method?: string;\n  headers?: Object;\n  timeout?: number;\n  password?: string;\n  hasContent?: boolean;\n  crossDomain?: boolean;\n  withCredentials?: boolean;\n  createXHR?: () => XMLHttpRequest;\n  progressSubscriber?: Subscriber<any>;\n  responseType?: string;\n}\n\nfunction getCORSRequest(): XMLHttpRequest {\n  if (root.XMLHttpRequest) {\n    return new root.XMLHttpRequest();\n  } else if (!!root.XDomainRequest) {\n    return new root.XDomainRequest();\n  } else {\n    throw new Error('CORS is not supported by your browser');\n  }\n}\n\nfunction getXMLHttpRequest(): XMLHttpRequest {\n  if (root.XMLHttpRequest) {\n    return new root.XMLHttpRequest();\n  } else {\n    let progId: string;\n    try {\n      const progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];\n      for (let i = 0; i < 3; i++) {\n        try {\n          progId = progIds[i];\n          if (new root.ActiveXObject(progId)) {\n            break;\n          }\n        } catch (e) {\n          //suppress exceptions\n        }\n      }\n      return new root.ActiveXObject(progId);\n    } catch (e) {\n      throw new Error('XMLHttpRequest is not supported by your browser');\n    }\n  }\n}\n\nexport interface AjaxCreationMethod {\n  (urlOrRequest: string | AjaxRequest): Observable<AjaxResponse>;\n  get(url: string, headers?: Object): Observable<AjaxResponse>;\n  post(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;\n  put(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;\n  patch(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;\n  delete(url: string, headers?: Object): Observable<AjaxResponse>;\n  getJSON<T>(url: string, headers?: Object): Observable<T>;\n}\n\nexport function ajaxGet(url: string, headers: Object = null) {\n  return new AjaxObservable<AjaxResponse>({ method: 'GET', url, headers });\n}\n\nexport function ajaxPost(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {\n  return new AjaxObservable<AjaxResponse>({ method: 'POST', url, body, headers });\n}\n\nexport function ajaxDelete(url: string, headers?: Object): Observable<AjaxResponse> {\n  return new AjaxObservable<AjaxResponse>({ method: 'DELETE', url, headers });\n}\n\nexport function ajaxPut(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {\n  return new AjaxObservable<AjaxResponse>({ method: 'PUT', url, body, headers });\n}\n\nexport function ajaxPatch(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {\n  return new AjaxObservable<AjaxResponse>({ method: 'PATCH', url, body, headers });\n}\n\nconst mapResponse = map((x: AjaxResponse, index: number) => x.response);\n\nexport function ajaxGetJSON<T>(url: string, headers?: Object): Observable<T> {\n  return mapResponse(\n    new AjaxObservable<AjaxResponse>({\n      method: 'GET',\n      url,\n      responseType: 'json',\n      headers\n    })\n  );\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nexport class AjaxObservable<T> extends Observable<T> {\n  /**\n   * Creates an observable for an Ajax request with either a request object with\n   * url, headers, etc or a string for a URL.\n   *\n   * ## Example\n   * ```ts\n   * import { ajax } from 'rxjs/ajax';\n *\n   * const source1 = ajax('/products');\n   * const source2 = ajax({ url: 'products', method: 'GET' });\n   * ```\n   *\n   * @param {string|Object} request Can be one of the following:\n   *   A string of the URL to make the Ajax call.\n   *   An object with the following properties\n   *   - url: URL of the request\n   *   - body: The body of the request\n   *   - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE\n   *   - async: Whether the request is async\n   *   - headers: Optional headers\n   *   - crossDomain: true if a cross domain request, else false\n   *   - createXHR: a function to override if you need to use an alternate\n   *   XMLHttpRequest implementation.\n   *   - resultSelector: a function to use to alter the output value type of\n   *   the Observable. Gets {@link AjaxResponse} as an argument.\n   * @return {Observable} An observable sequence containing the XMLHttpRequest.\n   * @static true\n   * @name ajax\n   * @owner Observable\n   * @nocollapse\n  */\n  static create: AjaxCreationMethod = (() => {\n    const create: any = (urlOrRequest: string | AjaxRequest) => {\n      return new AjaxObservable(urlOrRequest);\n    };\n\n    create.get = ajaxGet;\n    create.post = ajaxPost;\n    create.delete = ajaxDelete;\n    create.put = ajaxPut;\n    create.patch = ajaxPatch;\n    create.getJSON = ajaxGetJSON;\n\n    return <AjaxCreationMethod>create;\n  })();\n\n  private request: AjaxRequest;\n\n  constructor(urlOrRequest: string | AjaxRequest) {\n    super();\n\n    const request: AjaxRequest = {\n      async: true,\n      createXHR: function(this: AjaxRequest) {\n        return this.crossDomain ? getCORSRequest() : getXMLHttpRequest();\n      },\n      crossDomain: true,\n      withCredentials: false,\n      headers: {},\n      method: 'GET',\n      responseType: 'json',\n      timeout: 0\n    };\n\n    if (typeof urlOrRequest === 'string') {\n      request.url = urlOrRequest;\n    } else {\n      for (const prop in urlOrRequest) {\n        if (urlOrRequest.hasOwnProperty(prop)) {\n          request[prop] = urlOrRequest[prop];\n        }\n      }\n    }\n\n    this.request = request;\n  }\n\n  /** @deprecated This is an internal implementation detail, do not use. */\n  _subscribe(subscriber: Subscriber<T>): TeardownLogic {\n    return new AjaxSubscriber(subscriber, this.request);\n  }\n}\n\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nexport class AjaxSubscriber<T> extends Subscriber<Event> {\n  private xhr: XMLHttpRequest;\n  private done: boolean = false;\n\n  constructor(destination: Subscriber<T>, public request: AjaxRequest) {\n    super(destination);\n\n    const headers = request.headers = request.headers || {};\n\n    // force CORS if requested\n    if (!request.crossDomain && !this.getHeader(headers, 'X-Requested-With')) {\n      headers['X-Requested-With'] = 'XMLHttpRequest';\n    }\n\n    // ensure content type is set\n    let contentTypeHeader = this.getHeader(headers, 'Content-Type');\n    if (!contentTypeHeader && !(root.FormData && request.body instanceof root.FormData) && typeof request.body !== 'undefined') {\n      headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';\n    }\n\n    // properly serialize body\n    request.body = this.serializeBody(request.body, this.getHeader(request.headers, 'Content-Type'));\n\n    this.send();\n  }\n\n  next(e: Event): void {\n    this.done = true;\n    const { xhr, request, destination } = this;\n    let result;\n    try {\n      result = new AjaxResponse(e, xhr, request);\n    } catch (err) {\n      return destination.error(err);\n    }\n    destination.next(result);\n  }\n\n  private send(): void {\n    const {\n      request,\n      request: { user, method, url, async, password, headers, body }\n    } = this;\n    try {\n      const xhr = this.xhr = request.createXHR();\n\n      // set up the events before open XHR\n      // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest\n      // You need to add the event listeners before calling open() on the request.\n      // Otherwise the progress events will not fire.\n      this.setupEvents(xhr, request);\n      // open XHR\n      if (user) {\n        xhr.open(method, url, async, user, password);\n      } else {\n        xhr.open(method, url, async);\n      }\n\n      // timeout, responseType and withCredentials can be set once the XHR is open\n      if (async) {\n        xhr.timeout = request.timeout;\n        xhr.responseType = request.responseType as any;\n      }\n\n      if ('withCredentials' in xhr) {\n        xhr.withCredentials = !!request.withCredentials;\n      }\n\n      // set headers\n      this.setHeaders(xhr, headers);\n\n      // finally send the request\n      if (body) {\n        xhr.send(body);\n      } else {\n        xhr.send();\n      }\n    } catch (err) {\n      this.error(err);\n    }\n  }\n\n  private serializeBody(body: any, contentType?: string) {\n    if (!body || typeof body === 'string') {\n      return body;\n    } else if (root.FormData && body instanceof root.FormData) {\n      return body;\n    }\n\n    if (contentType) {\n      const splitIndex = contentType.indexOf(';');\n      if (splitIndex !== -1) {\n        contentType = contentType.substring(0, splitIndex);\n      }\n    }\n\n    switch (contentType) {\n      case 'application/x-www-form-urlencoded':\n        return Object.keys(body).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(body[key])}`).join('&');\n      case 'application/json':\n        return JSON.stringify(body);\n      default:\n        return body;\n    }\n  }\n\n  private setHeaders(xhr: XMLHttpRequest, headers: Object) {\n    for (let key in headers) {\n      if (headers.hasOwnProperty(key)) {\n        xhr.setRequestHeader(key, headers[key]);\n      }\n    }\n  }\n\n  private getHeader(headers: {}, headerName: string): any {\n    for (let key in headers) {\n      if (key.toLowerCase() === headerName.toLowerCase()) {\n        return headers[key];\n      }\n    }\n\n    return undefined;\n  }\n\n  private setupEvents(xhr: XMLHttpRequest, request: AjaxRequest) {\n    const progressSubscriber = request.progressSubscriber;\n\n    function xhrTimeout(this: XMLHttpRequest, e: ProgressEvent): void {\n      const {subscriber, progressSubscriber, request } = (<any>xhrTimeout);\n      if (progressSubscriber) {\n        progressSubscriber.error(e);\n      }\n      let error;\n      try {\n        error = new AjaxTimeoutError(this, request); // TODO: Make betterer.\n      } catch (err) {\n        error = err;\n      }\n      subscriber.error(error);\n    }\n    xhr.ontimeout = xhrTimeout;\n    (<any>xhrTimeout).request = request;\n    (<any>xhrTimeout).subscriber = this;\n    (<any>xhrTimeout).progressSubscriber = progressSubscriber;\n    if (xhr.upload && 'withCredentials' in xhr) {\n      if (progressSubscriber) {\n        let xhrProgress: (e: ProgressEvent) => void;\n        xhrProgress = function(e: ProgressEvent) {\n          const { progressSubscriber } = (<any>xhrProgress);\n          progressSubscriber.next(e);\n        };\n        if (root.XDomainRequest) {\n          xhr.onprogress = xhrProgress;\n        } else {\n          xhr.upload.onprogress = xhrProgress;\n        }\n        (<any>xhrProgress).progressSubscriber = progressSubscriber;\n      }\n      let xhrError: (e: any) => void;\n      xhrError = function(this: XMLHttpRequest, e: ErrorEvent) {\n        const { progressSubscriber, subscriber, request } = (<any>xhrError);\n        if (progressSubscriber) {\n          progressSubscriber.error(e);\n        }\n        let error;\n        try {\n          error = new AjaxError('ajax error', this, request);\n        } catch (err) {\n          error = err;\n        }\n        subscriber.error(error);\n      };\n      xhr.onerror = xhrError;\n      (<any>xhrError).request = request;\n      (<any>xhrError).subscriber = this;\n      (<any>xhrError).progressSubscriber = progressSubscriber;\n    }\n\n    function xhrReadyStateChange(this: XMLHttpRequest, e: Event) {\n      return;\n    }\n    xhr.onreadystatechange = xhrReadyStateChange;\n    (<any>xhrReadyStateChange).subscriber = this;\n    (<any>xhrReadyStateChange).progressSubscriber = progressSubscriber;\n    (<any>xhrReadyStateChange).request = request;\n\n    function xhrLoad(this: XMLHttpRequest, e: Event) {\n      const { subscriber, progressSubscriber, request } = (<any>xhrLoad);\n      if (this.readyState === 4) {\n        // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)\n        let status: number = this.status === 1223 ? 204 : this.status;\n        let response: any = (this.responseType === 'text' ?  (\n          this.response || this.responseText) : this.response);\n\n        // fix status code when it is 0 (0 status is undocumented).\n        // Occurs when accessing file resources or on Android 4.1 stock browser\n        // while retrieving files from application cache.\n        if (status === 0) {\n          status = response ? 200 : 0;\n        }\n\n        // 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)\n        if (status < 400) {\n          if (progressSubscriber) {\n            progressSubscriber.complete();\n          }\n          subscriber.next(e);\n          subscriber.complete();\n        } else {\n          if (progressSubscriber) {\n            progressSubscriber.error(e);\n          }\n          let error;\n          try {\n            error = new AjaxError('ajax error ' + status, this, request);\n          } catch (err) {\n            error = err;\n          }\n          subscriber.error(error);\n        }\n      }\n    }\n    xhr.onload = xhrLoad;\n    (<any>xhrLoad).subscriber = this;\n    (<any>xhrLoad).progressSubscriber = progressSubscriber;\n    (<any>xhrLoad).request = request;\n  }\n\n  unsubscribe() {\n    const { done, xhr } = this;\n    if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {\n      xhr.abort();\n    }\n    super.unsubscribe();\n  }\n}\n\n/**\n * A normalized AJAX response.\n *\n * @see {@link ajax}\n *\n * @class AjaxResponse\n */\nexport class AjaxResponse {\n  /** @type {number} The HTTP status code */\n  status: number;\n\n  /** @type {string|ArrayBuffer|Document|object|any} The response data */\n  response: any;\n\n  /** @type {string} The raw responseText */\n  responseText: string;\n\n  /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */\n  responseType: string;\n\n  constructor(public originalEvent: Event, public xhr: XMLHttpRequest, public request: AjaxRequest) {\n    this.status = xhr.status;\n    this.responseType = xhr.responseType || request.responseType;\n    this.response = parseXhrResponse(this.responseType, xhr);\n  }\n}\n\nexport type AjaxErrorNames = 'AjaxError' | 'AjaxTimeoutError';\n\n/**\n * A normalized AJAX error.\n *\n * @see {@link ajax}\n *\n * @class AjaxError\n */\nexport interface AjaxError extends Error {\n  /** @type {XMLHttpRequest} The XHR instance associated with the error */\n  xhr: XMLHttpRequest;\n\n  /** @type {AjaxRequest} The AjaxRequest associated with the error */\n  request: AjaxRequest;\n\n  /** @type {number} The HTTP status code */\n  status: number;\n\n  /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */\n  responseType: string;\n\n  /** @type {string|ArrayBuffer|Document|object|any} The response data */\n  response: any;\n}\n\nexport interface AjaxErrorCtor {\n  new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;\n}\n\nconst AjaxErrorImpl = (() => {\n  function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {\n    Error.call(this);\n    this.message = message;\n    this.name = 'AjaxError';\n    this.xhr = xhr;\n    this.request = request;\n    this.status = xhr.status;\n    this.responseType = xhr.responseType || request.responseType;\n    this.response = parseXhrResponse(this.responseType, xhr);\n    return this;\n  }\n  AjaxErrorImpl.prototype = Object.create(Error.prototype);\n  return AjaxErrorImpl;\n})();\n\nexport const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any;\n\nfunction parseJson(xhr: XMLHttpRequest) {\n  // HACK(benlesh): TypeScript shennanigans\n  // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else clause.\n  if ('response' in (xhr as any)) {\n    //IE does not support json as responseType, parse it internally\n    return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');\n  } else {\n    return JSON.parse((xhr as any).responseText || 'null');\n  }\n}\n\nfunction parseXhrResponse(responseType: string, xhr: XMLHttpRequest) {\n  switch (responseType) {\n    case 'json':\n        return parseJson(xhr);\n      case 'xml':\n        return xhr.responseXML;\n      case 'text':\n      default:\n          // HACK(benlesh): TypeScript shennanigans\n          // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else sub-expression.\n          return  ('response' in (xhr as any)) ? xhr.response : xhr.responseText;\n  }\n}\n\nexport interface AjaxTimeoutError extends AjaxError {\n}\n\nexport interface AjaxTimeoutErrorCtor {\n  new(xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;\n}\n\nfunction AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {\n  AjaxError.call(this, 'ajax timeout', xhr, request);\n  this.name = 'AjaxTimeoutError';\n  return this;\n}\n\n/**\n * @see {@link ajax}\n *\n * @class AjaxTimeoutError\n */\nexport const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any;\n","export { ajax } from '../internal/observable/dom/ajax';\nexport { AjaxRequest, AjaxResponse, AjaxError, AjaxTimeoutError } from '../internal/observable/dom/AjaxObservable';\n"],"sourceRoot":""}