text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 457);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);var toSubscriber_1=__webpack_require__(160);var observable_1=__webpack_require__(27);var pipe_1=__webpack_require__(40);/**
   * A representation of any set of values over any amount of time. This is the most basic building block
   * of RxJS.
   *
   * @class Observable<T>
   */var Observable=function(){/**
       * @constructor
       * @param {Function} subscribe the function that is called when the Observable is
       * initially subscribed to. This function is given a Subscriber, to which new values
       * can be `next`ed, or an `error` method can be called to raise an error, or
       * `complete` can be called to notify of a successful completion.
       */function Observable(subscribe){this._isScalar=false;if(subscribe){this._subscribe=subscribe;}}/**
       * Creates a new Observable, with this Observable as the source, and the passed
       * operator defined as the new observable's operator.
       * @method lift
       * @param {Operator} operator the operator defining the operation to take on the observable
       * @return {Observable} a new observable with the Operator applied
       */Observable.prototype.lift=function(operator){var observable=new Observable();observable.source=this;observable.operator=operator;return observable;};/**
       * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.
       *
       * <span class="informal">Use it when you have all these Observables, but still nothing is happening.</span>
       *
       * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It
       * might be for example a function that you passed to a {@link create} static factory, but most of the time it is
       * a library implementation, which defines what and when will be emitted by an Observable. This means that calling
       * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often
       * thought.
       *
       * Apart from starting the execution of an Observable, this method allows you to listen for values
       * that an Observable emits, as well as for when it completes or errors. You can achieve this in two
       * following ways.
       *
       * The first way is creating an object that implements {@link Observer} interface. It should have methods
       * defined by that interface, but note that it should be just a regular JavaScript object, which you can create
       * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do
       * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also
       * that your object does not have to implement all methods. If you find yourself creating a method that doesn't
       * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will
       * be left uncaught.
       *
       * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.
       * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent
       * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,
       * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,
       * since `subscribe` recognizes these functions by where they were placed in function call. When it comes
       * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.
       *
       * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.
       * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean
       * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback
       * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.
       *
       * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.
       * It is an Observable itself that decides when these functions will be called. For example {@link of}
       * by default emits all its values synchronously. Always check documentation for how given Observable
       * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.
       *
       * @example <caption>Subscribe with an Observer</caption>
       * const sumObserver = {
       *   sum: 0,
       *   next(value) {
       *     console.log('Adding: ' + value);
       *     this.sum = this.sum + value;
       *   },
       *   error() { // We actually could just remove this method,
       *   },        // since we do not really care about errors right now.
       *   complete() {
       *     console.log('Sum equals: ' + this.sum);
       *   }
       * };
       *
       * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.
       * .subscribe(sumObserver);
       *
       * // Logs:
       * // "Adding: 1"
       * // "Adding: 2"
       * // "Adding: 3"
       * // "Sum equals: 6"
       *
       *
       * @example <caption>Subscribe with functions</caption>
       * let sum = 0;
       *
       * Rx.Observable.of(1, 2, 3)
       * .subscribe(
       *   function(value) {
       *     console.log('Adding: ' + value);
       *     sum = sum + value;
       *   },
       *   undefined,
       *   function() {
       *     console.log('Sum equals: ' + sum);
       *   }
       * );
       *
       * // Logs:
       * // "Adding: 1"
       * // "Adding: 2"
       * // "Adding: 3"
       * // "Sum equals: 6"
       *
       *
       * @example <caption>Cancel a subscription</caption>
       * const subscription = Rx.Observable.interval(1000).subscribe(
       *   num => console.log(num),
       *   undefined,
       *   () => console.log('completed!') // Will not be called, even
       * );                                // when cancelling subscription
       *
       *
       * setTimeout(() => {
       *   subscription.unsubscribe();
       *   console.log('unsubscribed!');
       * }, 2500);
       *
       * // Logs:
       * // 0 after 1s
       * // 1 after 2s
       * // "unsubscribed!" after 2.5s
       *
       *
       * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,
       *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed
       *  Observable.
       * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,
       *  the error will be thrown as unhandled.
       * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.
       * @return {ISubscription} a subscription reference to the registered handlers
       * @method subscribe
       */Observable.prototype.subscribe=function(observerOrNext,error,complete){var operator=this.operator;var sink=toSubscriber_1.toSubscriber(observerOrNext,error,complete);if(operator){operator.call(sink,this.source);}else{sink.add(this.source||!sink.syncErrorThrowable?this._subscribe(sink):this._trySubscribe(sink));}if(sink.syncErrorThrowable){sink.syncErrorThrowable=false;if(sink.syncErrorThrown){throw sink.syncErrorValue;}}return sink;};Observable.prototype._trySubscribe=function(sink){try{return this._subscribe(sink);}catch(err){sink.syncErrorThrown=true;sink.syncErrorValue=err;sink.error(err);}};/**
       * @method forEach
       * @param {Function} next a handler for each value emitted by the observable
       * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
       * @return {Promise} a promise that either resolves on observable completion or
       *  rejects with the handled error
       */Observable.prototype.forEach=function(next,PromiseCtor){var _this=this;if(!PromiseCtor){if(root_1.root.Rx&&root_1.root.Rx.config&&root_1.root.Rx.config.Promise){PromiseCtor=root_1.root.Rx.config.Promise;}else if(root_1.root.Promise){PromiseCtor=root_1.root.Promise;}}if(!PromiseCtor){throw new Error('no Promise impl found');}return new PromiseCtor(function(resolve,reject){// Must be declared in a separate statement to avoid a RefernceError when
  // accessing subscription below in the closure due to Temporal Dead Zone.
  var subscription;subscription=_this.subscribe(function(value){if(subscription){// if there is a subscription, then we can surmise
  // the next handling is asynchronous. Any errors thrown
  // need to be rejected explicitly and unsubscribe must be
  // called manually
  try{next(value);}catch(err){reject(err);subscription.unsubscribe();}}else{// if there is NO subscription, then we're getting a nexted
  // value synchronously during subscription. We can just call it.
  // If it errors, Observable's `subscribe` will ensure the
  // unsubscription logic is called, then synchronously rethrow the error.
  // After that, Promise will trap the error and send it
  // down the rejection path.
  next(value);}},reject,resolve);});};Observable.prototype._subscribe=function(subscriber){return this.source.subscribe(subscriber);};/**
       * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
       * @method Symbol.observable
       * @return {Observable} this instance of the observable
       */Observable.prototype[observable_1.observable]=function(){return this;};/* tslint:enable:max-line-length *//**
       * Used to stitch together functional operators into a chain.
       * @method pipe
       * @return {Observable} the Observable result of all of the operators having
       * been called in the order they were passed in.
       *
       * @example
       *
       * import { map, filter, scan } from 'rxjs/operators';
       *
       * Rx.Observable.interval(1000)
       *   .pipe(
       *     filter(x => x % 2 === 0),
       *     map(x => x + x),
       *     scan((acc, x) => acc + x)
       *   )
       *   .subscribe(x => console.log(x))
       */Observable.prototype.pipe=function(){var operations=[];for(var _i=0;_i<arguments.length;_i++){operations[_i-0]=arguments[_i];}if(operations.length===0){return this;}return pipe_1.pipeFromArray(operations)(this);};/* tslint:enable:max-line-length */Observable.prototype.toPromise=function(PromiseCtor){var _this=this;if(!PromiseCtor){if(root_1.root.Rx&&root_1.root.Rx.config&&root_1.root.Rx.config.Promise){PromiseCtor=root_1.root.Rx.config.Promise;}else if(root_1.root.Promise){PromiseCtor=root_1.root.Promise;}}if(!PromiseCtor){throw new Error('no Promise impl found');}return new PromiseCtor(function(resolve,reject){var value;_this.subscribe(function(x){return value=x;},function(err){return reject(err);},function(){return resolve(value);});});};// HACK: Since TypeScript inherits static properties too, we have to
  // fight against TypeScript here so Subject can have a different static create signature
  /**
       * Creates a new cold Observable by calling the Observable constructor
       * @static true
       * @owner Observable
       * @method create
       * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
       * @return {Observable} a new cold observable
       */Observable.create=function(subscribe){return new Observable(subscribe);};return Observable;}();exports.Observable=Observable;//# sourceMappingURL=Observable.js.map
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isFunction_1=__webpack_require__(25);var Subscription_1=__webpack_require__(5);var Observer_1=__webpack_require__(60);var rxSubscriber_1=__webpack_require__(26);/**
   * Implements the {@link Observer} interface and extends the
   * {@link Subscription} class. While the {@link Observer} is the public API for
   * consuming the values of an {@link Observable}, all Observers get converted to
   * a Subscriber, in order to provide Subscription-like capabilities such as
   * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
   * implementing operators, but it is rarely used as a public API.
   *
   * @class Subscriber<T>
   */var Subscriber=function(_super){__extends(Subscriber,_super);/**
       * @param {Observer|function(value: T): void} [destinationOrNext] A partially
       * defined Observer or a `next` callback function.
       * @param {function(e: ?any): void} [error] The `error` callback of an
       * Observer.
       * @param {function(): void} [complete] The `complete` callback of an
       * Observer.
       */function Subscriber(destinationOrNext,error,complete){_super.call(this);this.syncErrorValue=null;this.syncErrorThrown=false;this.syncErrorThrowable=false;this.isStopped=false;switch(arguments.length){case 0:this.destination=Observer_1.empty;break;case 1:if(!destinationOrNext){this.destination=Observer_1.empty;break;}if((typeof destinationOrNext==='undefined'?'undefined':_typeof(destinationOrNext))==='object'){if(destinationOrNext instanceof Subscriber){this.syncErrorThrowable=destinationOrNext.syncErrorThrowable;this.destination=destinationOrNext;this.destination.add(this);}else{this.syncErrorThrowable=true;this.destination=new SafeSubscriber(this,destinationOrNext);}break;}default:this.syncErrorThrowable=true;this.destination=new SafeSubscriber(this,destinationOrNext,error,complete);break;}}Subscriber.prototype[rxSubscriber_1.rxSubscriber]=function(){return this;};/**
       * A static factory for a Subscriber, given a (potentially partial) definition
       * of an Observer.
       * @param {function(x: ?T): void} [next] The `next` callback of an Observer.
       * @param {function(e: ?any): void} [error] The `error` callback of an
       * Observer.
       * @param {function(): void} [complete] The `complete` callback of an
       * Observer.
       * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)
       * Observer represented by the given arguments.
       */Subscriber.create=function(next,error,complete){var subscriber=new Subscriber(next,error,complete);subscriber.syncErrorThrowable=false;return subscriber;};/**
       * The {@link Observer} callback to receive notifications of type `next` from
       * the Observable, with a value. The Observable may call this method 0 or more
       * times.
       * @param {T} [value] The `next` value.
       * @return {void}
       */Subscriber.prototype.next=function(value){if(!this.isStopped){this._next(value);}};/**
       * The {@link Observer} callback to receive notifications of type `error` from
       * the Observable, with an attached {@link Error}. Notifies the Observer that
       * the Observable has experienced an error condition.
       * @param {any} [err] The `error` exception.
       * @return {void}
       */Subscriber.prototype.error=function(err){if(!this.isStopped){this.isStopped=true;this._error(err);}};/**
       * The {@link Observer} callback to receive a valueless notification of type
       * `complete` from the Observable. Notifies the Observer that the Observable
       * has finished sending push-based notifications.
       * @return {void}
       */Subscriber.prototype.complete=function(){if(!this.isStopped){this.isStopped=true;this._complete();}};Subscriber.prototype.unsubscribe=function(){if(this.closed){return;}this.isStopped=true;_super.prototype.unsubscribe.call(this);};Subscriber.prototype._next=function(value){this.destination.next(value);};Subscriber.prototype._error=function(err){this.destination.error(err);this.unsubscribe();};Subscriber.prototype._complete=function(){this.destination.complete();this.unsubscribe();};Subscriber.prototype._unsubscribeAndRecycle=function(){var _a=this,_parent=_a._parent,_parents=_a._parents;this._parent=null;this._parents=null;this.unsubscribe();this.closed=false;this.isStopped=false;this._parent=_parent;this._parents=_parents;return this;};return Subscriber;}(Subscription_1.Subscription);exports.Subscriber=Subscriber;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SafeSubscriber=function(_super){__extends(SafeSubscriber,_super);function SafeSubscriber(_parentSubscriber,observerOrNext,error,complete){_super.call(this);this._parentSubscriber=_parentSubscriber;var next;var context=this;if(isFunction_1.isFunction(observerOrNext)){next=observerOrNext;}else if(observerOrNext){next=observerOrNext.next;error=observerOrNext.error;complete=observerOrNext.complete;if(observerOrNext!==Observer_1.empty){context=Object.create(observerOrNext);if(isFunction_1.isFunction(context.unsubscribe)){this.add(context.unsubscribe.bind(context));}context.unsubscribe=this.unsubscribe.bind(this);}}this._context=context;this._next=next;this._error=error;this._complete=complete;}SafeSubscriber.prototype.next=function(value){if(!this.isStopped&&this._next){var _parentSubscriber=this._parentSubscriber;if(!_parentSubscriber.syncErrorThrowable){this.__tryOrUnsub(this._next,value);}else if(this.__tryOrSetError(_parentSubscriber,this._next,value)){this.unsubscribe();}}};SafeSubscriber.prototype.error=function(err){if(!this.isStopped){var _parentSubscriber=this._parentSubscriber;if(this._error){if(!_parentSubscriber.syncErrorThrowable){this.__tryOrUnsub(this._error,err);this.unsubscribe();}else{this.__tryOrSetError(_parentSubscriber,this._error,err);this.unsubscribe();}}else if(!_parentSubscriber.syncErrorThrowable){this.unsubscribe();throw err;}else{_parentSubscriber.syncErrorValue=err;_parentSubscriber.syncErrorThrown=true;this.unsubscribe();}}};SafeSubscriber.prototype.complete=function(){var _this=this;if(!this.isStopped){var _parentSubscriber=this._parentSubscriber;if(this._complete){var wrappedComplete=function wrappedComplete(){return _this._complete.call(_this._context);};if(!_parentSubscriber.syncErrorThrowable){this.__tryOrUnsub(wrappedComplete);this.unsubscribe();}else{this.__tryOrSetError(_parentSubscriber,wrappedComplete);this.unsubscribe();}}else{this.unsubscribe();}}};SafeSubscriber.prototype.__tryOrUnsub=function(fn,value){try{fn.call(this._context,value);}catch(err){this.unsubscribe();throw err;}};SafeSubscriber.prototype.__tryOrSetError=function(parent,fn,value){try{fn.call(this._context,value);}catch(err){parent.syncErrorValue=err;parent.syncErrorThrown=true;return true;}return false;};SafeSubscriber.prototype._unsubscribe=function(){var _parentSubscriber=this._parentSubscriber;this._context=null;this._parentSubscriber=null;_parentSubscriber.unsubscribe();};return SafeSubscriber;}(Subscriber);//# sourceMappingURL=Subscriber.js.map
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var OuterSubscriber=function(_super){__extends(OuterSubscriber,_super);function OuterSubscriber(){_super.apply(this,arguments);}OuterSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.destination.next(innerValue);};OuterSubscriber.prototype.notifyError=function(error,innerSub){this.destination.error(error);};OuterSubscriber.prototype.notifyComplete=function(innerSub){this.destination.complete();};return OuterSubscriber;}(Subscriber_1.Subscriber);exports.OuterSubscriber=OuterSubscriber;//# sourceMappingURL=OuterSubscriber.js.map
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);var isArrayLike_1=__webpack_require__(62);var isPromise_1=__webpack_require__(63);var isObject_1=__webpack_require__(58);var Observable_1=__webpack_require__(0);var iterator_1=__webpack_require__(15);var InnerSubscriber_1=__webpack_require__(169);var observable_1=__webpack_require__(27);function subscribeToResult(outerSubscriber,result,outerValue,outerIndex){var destination=new InnerSubscriber_1.InnerSubscriber(outerSubscriber,outerValue,outerIndex);if(destination.closed){return null;}if(result instanceof Observable_1.Observable){if(result._isScalar){destination.next(result.value);destination.complete();return null;}else{destination.syncErrorThrowable=true;return result.subscribe(destination);}}else if(isArrayLike_1.isArrayLike(result)){for(var i=0,len=result.length;i<len&&!destination.closed;i++){destination.next(result[i]);}if(!destination.closed){destination.complete();}}else if(isPromise_1.isPromise(result)){result.then(function(value){if(!destination.closed){destination.next(value);destination.complete();}},function(err){return destination.error(err);}).then(null,function(err){// Escaping the Promise trap: globally throw unhandled errors
  root_1.root.setTimeout(function(){throw err;});});return destination;}else if(result&&typeof result[iterator_1.iterator]==='function'){var iterator=result[iterator_1.iterator]();do{var item=iterator.next();if(item.done){destination.complete();break;}destination.next(item.value);if(destination.closed){break;}}while(true);}else if(result&&typeof result[observable_1.observable]==='function'){var obs=result[observable_1.observable]();if(typeof obs.subscribe!=='function'){destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));}else{return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber,outerValue,outerIndex));}}else{var value=isObject_1.isObject(result)?'an invalid object':"'"+result+"'";var msg="You provided "+value+" where a stream was expected."+' You can provide an Observable, Promise, Array, or Iterable.';destination.error(new TypeError(msg));}return null;}exports.subscribeToResult=subscribeToResult;//# sourceMappingURL=subscribeToResult.js.map
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var AsyncAction_1=__webpack_require__(20);var AsyncScheduler_1=__webpack_require__(21);/**
   *
   * Async Scheduler
   *
   * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
   *
   * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
   * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
   * in intervals.
   *
   * If you just want to "defer" task, that is to perform it right after currently
   * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),
   * better choice will be the {@link asap} scheduler.
   *
   * @example <caption>Use async scheduler to delay task</caption>
   * const task = () => console.log('it works!');
   *
   * Rx.Scheduler.async.schedule(task, 2000);
   *
   * // After 2 seconds logs:
   * // "it works!"
   *
   *
   * @example <caption>Use async scheduler to repeat task in intervals</caption>
   * function task(state) {
   *   console.log(state);
   *   this.schedule(state + 1, 1000); // `this` references currently executing Action,
   *                                   // which we reschedule with new state and delay
   * }
   *
   * Rx.Scheduler.async.schedule(task, 3000, 0);
   *
   * // Logs:
   * // 0 after 3s
   * // 1 after 4s
   * // 2 after 5s
   * // 3 after 6s
   *
   * @static true
   * @name async
   * @owner Scheduler
   */exports.async=new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);//# sourceMappingURL=async.js.map
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};var isArray_1=__webpack_require__(11);var isObject_1=__webpack_require__(58);var isFunction_1=__webpack_require__(25);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var UnsubscriptionError_1=__webpack_require__(59);/**
   * Represents a disposable resource, such as the execution of an Observable. A
   * Subscription has one important method, `unsubscribe`, that takes no argument
   * and just disposes the resource held by the subscription.
   *
   * Additionally, subscriptions may be grouped together through the `add()`
   * method, which will attach a child Subscription to the current Subscription.
   * When a Subscription is unsubscribed, all its children (and its grandchildren)
   * will be unsubscribed as well.
   *
   * @class Subscription
   */var Subscription=function(){/**
       * @param {function(): void} [unsubscribe] A function describing how to
       * perform the disposal of resources when the `unsubscribe` method is called.
       */function Subscription(unsubscribe){/**
           * A flag to indicate whether this Subscription has already been unsubscribed.
           * @type {boolean}
           */this.closed=false;this._parent=null;this._parents=null;this._subscriptions=null;if(unsubscribe){this._unsubscribe=unsubscribe;}}/**
       * Disposes the resources held by the subscription. May, for instance, cancel
       * an ongoing Observable execution or cancel any other type of work that
       * started when the Subscription was created.
       * @return {void}
       */Subscription.prototype.unsubscribe=function(){var hasErrors=false;var errors;if(this.closed){return;}var _a=this,_parent=_a._parent,_parents=_a._parents,_unsubscribe=_a._unsubscribe,_subscriptions=_a._subscriptions;this.closed=true;this._parent=null;this._parents=null;// null out _subscriptions first so any child subscriptions that attempt
  // to remove themselves from this subscription will noop
  this._subscriptions=null;var index=-1;var len=_parents?_parents.length:0;// if this._parent is null, then so is this._parents, and we
  // don't have to remove ourselves from any parent subscriptions.
  while(_parent){_parent.remove(this);// if this._parents is null or index >= len,
  // then _parent is set to null, and the loop exits
  _parent=++index<len&&_parents[index]||null;}if(isFunction_1.isFunction(_unsubscribe)){var trial=tryCatch_1.tryCatch(_unsubscribe).call(this);if(trial===errorObject_1.errorObject){hasErrors=true;errors=errors||(errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError?flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors):[errorObject_1.errorObject.e]);}}if(isArray_1.isArray(_subscriptions)){index=-1;len=_subscriptions.length;while(++index<len){var sub=_subscriptions[index];if(isObject_1.isObject(sub)){var trial=tryCatch_1.tryCatch(sub.unsubscribe).call(sub);if(trial===errorObject_1.errorObject){hasErrors=true;errors=errors||[];var err=errorObject_1.errorObject.e;if(err instanceof UnsubscriptionError_1.UnsubscriptionError){errors=errors.concat(flattenUnsubscriptionErrors(err.errors));}else{errors.push(err);}}}}}if(hasErrors){throw new UnsubscriptionError_1.UnsubscriptionError(errors);}};/**
       * Adds a tear down to be called during the unsubscribe() of this
       * Subscription.
       *
       * If the tear down being added is a subscription that is already
       * unsubscribed, is the same reference `add` is being called on, or is
       * `Subscription.EMPTY`, it will not be added.
       *
       * If this subscription is already in an `closed` state, the passed
       * tear down logic will be executed immediately.
       *
       * @param {TeardownLogic} teardown The additional logic to execute on
       * teardown.
       * @return {Subscription} Returns the Subscription used or created to be
       * added to the inner subscriptions list. This Subscription can be used with
       * `remove()` to remove the passed teardown logic from the inner subscriptions
       * list.
       */Subscription.prototype.add=function(teardown){if(!teardown||teardown===Subscription.EMPTY){return Subscription.EMPTY;}if(teardown===this){return this;}var subscription=teardown;switch(typeof teardown==='undefined'?'undefined':_typeof(teardown)){case'function':subscription=new Subscription(teardown);case'object':if(subscription.closed||typeof subscription.unsubscribe!=='function'){return subscription;}else if(this.closed){subscription.unsubscribe();return subscription;}else if(typeof subscription._addParent!=='function'/* quack quack */){var tmp=subscription;subscription=new Subscription();subscription._subscriptions=[tmp];}break;default:throw new Error('unrecognized teardown '+teardown+' added to Subscription.');}var subscriptions=this._subscriptions||(this._subscriptions=[]);subscriptions.push(subscription);subscription._addParent(this);return subscription;};/**
       * Removes a Subscription from the internal list of subscriptions that will
       * unsubscribe during the unsubscribe process of this Subscription.
       * @param {Subscription} subscription The subscription to remove.
       * @return {void}
       */Subscription.prototype.remove=function(subscription){var subscriptions=this._subscriptions;if(subscriptions){var subscriptionIndex=subscriptions.indexOf(subscription);if(subscriptionIndex!==-1){subscriptions.splice(subscriptionIndex,1);}}};Subscription.prototype._addParent=function(parent){var _a=this,_parent=_a._parent,_parents=_a._parents;if(!_parent||_parent===parent){// If we don't have a parent, or the new parent is the same as the
  // current parent, then set this._parent to the new parent.
  this._parent=parent;}else if(!_parents){// If there's already one parent, but not multiple, allocate an Array to
  // store the rest of the parent Subscriptions.
  this._parents=[parent];}else if(_parents.indexOf(parent)===-1){// Only add the new parent to the _parents list if it's not already there.
  _parents.push(parent);}};Subscription.EMPTY=function(empty){empty.closed=true;return empty;}(new Subscription());return Subscription;}();exports.Subscription=Subscription;function flattenUnsubscriptionErrors(errors){return errors.reduce(function(errs,err){return errs.concat(err instanceof UnsubscriptionError_1.UnsubscriptionError?err.errors:err);},[]);}//# sourceMappingURL=Subscription.js.map
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var Subscriber_1=__webpack_require__(1);var Subscription_1=__webpack_require__(5);var ObjectUnsubscribedError_1=__webpack_require__(28);var SubjectSubscription_1=__webpack_require__(61);var rxSubscriber_1=__webpack_require__(26);/**
   * @class SubjectSubscriber<T>
   */var SubjectSubscriber=function(_super){__extends(SubjectSubscriber,_super);function SubjectSubscriber(destination){_super.call(this,destination);this.destination=destination;}return SubjectSubscriber;}(Subscriber_1.Subscriber);exports.SubjectSubscriber=SubjectSubscriber;/**
   * @class Subject<T>
   */var Subject=function(_super){__extends(Subject,_super);function Subject(){_super.call(this);this.observers=[];this.closed=false;this.isStopped=false;this.hasError=false;this.thrownError=null;}Subject.prototype[rxSubscriber_1.rxSubscriber]=function(){return new SubjectSubscriber(this);};Subject.prototype.lift=function(operator){var subject=new AnonymousSubject(this,this);subject.operator=operator;return subject;};Subject.prototype.next=function(value){if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}if(!this.isStopped){var observers=this.observers;var len=observers.length;var copy=observers.slice();for(var i=0;i<len;i++){copy[i].next(value);}}};Subject.prototype.error=function(err){if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}this.hasError=true;this.thrownError=err;this.isStopped=true;var observers=this.observers;var len=observers.length;var copy=observers.slice();for(var i=0;i<len;i++){copy[i].error(err);}this.observers.length=0;};Subject.prototype.complete=function(){if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}this.isStopped=true;var observers=this.observers;var len=observers.length;var copy=observers.slice();for(var i=0;i<len;i++){copy[i].complete();}this.observers.length=0;};Subject.prototype.unsubscribe=function(){this.isStopped=true;this.closed=true;this.observers=null;};Subject.prototype._trySubscribe=function(subscriber){if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}else{return _super.prototype._trySubscribe.call(this,subscriber);}};Subject.prototype._subscribe=function(subscriber){if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}else if(this.hasError){subscriber.error(this.thrownError);return Subscription_1.Subscription.EMPTY;}else if(this.isStopped){subscriber.complete();return Subscription_1.Subscription.EMPTY;}else{this.observers.push(subscriber);return new SubjectSubscription_1.SubjectSubscription(this,subscriber);}};Subject.prototype.asObservable=function(){var observable=new Observable_1.Observable();observable.source=this;return observable;};Subject.create=function(destination,source){return new AnonymousSubject(destination,source);};return Subject;}(Observable_1.Observable);exports.Subject=Subject;/**
   * @class AnonymousSubject<T>
   */var AnonymousSubject=function(_super){__extends(AnonymousSubject,_super);function AnonymousSubject(destination,source){_super.call(this);this.destination=destination;this.source=source;}AnonymousSubject.prototype.next=function(value){var destination=this.destination;if(destination&&destination.next){destination.next(value);}};AnonymousSubject.prototype.error=function(err){var destination=this.destination;if(destination&&destination.error){this.destination.error(err);}};AnonymousSubject.prototype.complete=function(){var destination=this.destination;if(destination&&destination.complete){this.destination.complete();}};AnonymousSubject.prototype._subscribe=function(subscriber){var source=this.source;if(source){return this.source.subscribe(subscriber);}else{return Subscription_1.Subscription.EMPTY;}};return AnonymousSubject;}(Subject);exports.AnonymousSubject=AnonymousSubject;//# sourceMappingURL=Subject.js.map
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // typeof any so that it we don't have to cast when comparing a result to the error object
  exports.errorObject={e:{}};//# sourceMappingURL=errorObject.js.map
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var errorObject_1=__webpack_require__(7);var tryCatchTarget;function tryCatcher(){try{return tryCatchTarget.apply(this,arguments);}catch(e){errorObject_1.errorObject.e=e;return errorObject_1.errorObject;}}function tryCatch(fn){tryCatchTarget=fn;return tryCatcher;}exports.tryCatch=tryCatch;;//# sourceMappingURL=tryCatch.js.map
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(global) {// CommonJS / Node have global context exposed as "global" variable.
  // We don't want to include the whole node.d.ts this this compilation unit so we'll just fake
  // the global "global" var for now.
  var __window=typeof window!=='undefined'&&window;var __self=typeof self!=='undefined'&&typeof WorkerGlobalScope!=='undefined'&&self instanceof WorkerGlobalScope&&self;var __global=typeof global!=='undefined'&&global;var _root=__window||__global||__self;exports.root=_root;// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.
  // This is needed when used with angular/tsickle which inserts a goog.module statement.
  // Wrap in IIFE
  (function(){if(!_root){throw new Error('RxJS could not find any global context (window, self, global)');}})();//# sourceMappingURL=root.js.map
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(57)))
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function isScheduler(value){return value&&typeof value.schedule==='function';}exports.isScheduler=isScheduler;//# sourceMappingURL=isScheduler.js.map
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  exports.isArray=Array.isArray||function(x){return x&&typeof x.length==='number';};//# sourceMappingURL=isArray.js.map
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var ScalarObservable_1=__webpack_require__(42);var EmptyObservable_1=__webpack_require__(13);var isScheduler_1=__webpack_require__(10);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var ArrayObservable=function(_super){__extends(ArrayObservable,_super);function ArrayObservable(array,scheduler){_super.call(this);this.array=array;this.scheduler=scheduler;if(!scheduler&&array.length===1){this._isScalar=true;this.value=array[0];}}ArrayObservable.create=function(array,scheduler){return new ArrayObservable(array,scheduler);};/**
       * Creates an Observable that emits some values you specify as arguments,
       * immediately one after the other, and then emits a complete notification.
       *
       * <span class="informal">Emits the arguments you provide, then completes.
       * </span>
       *
       * <img src="./img/of.png" width="100%">
       *
       * This static operator is useful for creating a simple Observable that only
       * emits the arguments given, and the complete notification thereafter. It can
       * be used for composing with other Observables, such as with {@link concat}.
       * By default, it uses a `null` IScheduler, which means the `next`
       * notifications are sent synchronously, although with a different IScheduler
       * it is possible to determine when those notifications will be delivered.
       *
       * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>
       * var numbers = Rx.Observable.of(10, 20, 30);
       * var letters = Rx.Observable.of('a', 'b', 'c');
       * var interval = Rx.Observable.interval(1000);
       * var result = numbers.concat(letters).concat(interval);
       * result.subscribe(x => console.log(x));
       *
       * @see {@link create}
       * @see {@link empty}
       * @see {@link never}
       * @see {@link throw}
       *
       * @param {...T} values Arguments that represent `next` values to be emitted.
       * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
       * the emissions of the `next` notifications.
       * @return {Observable<T>} An Observable that emits each given input value.
       * @static true
       * @name of
       * @owner Observable
       */ArrayObservable.of=function(){var array=[];for(var _i=0;_i<arguments.length;_i++){array[_i-0]=arguments[_i];}var scheduler=array[array.length-1];if(isScheduler_1.isScheduler(scheduler)){array.pop();}else{scheduler=null;}var len=array.length;if(len>1){return new ArrayObservable(array,scheduler);}else if(len===1){return new ScalarObservable_1.ScalarObservable(array[0],scheduler);}else{return new EmptyObservable_1.EmptyObservable(scheduler);}};ArrayObservable.dispatch=function(state){var array=state.array,index=state.index,count=state.count,subscriber=state.subscriber;if(index>=count){subscriber.complete();return;}subscriber.next(array[index]);if(subscriber.closed){return;}state.index=index+1;this.schedule(state);};ArrayObservable.prototype._subscribe=function(subscriber){var index=0;var array=this.array;var count=array.length;var scheduler=this.scheduler;if(scheduler){return scheduler.schedule(ArrayObservable.dispatch,0,{array:array,index:index,count:count,subscriber:subscriber});}else{for(var i=0;i<count&&!subscriber.closed;i++){subscriber.next(array[i]);}subscriber.complete();}};return ArrayObservable;}(Observable_1.Observable);exports.ArrayObservable=ArrayObservable;//# sourceMappingURL=ArrayObservable.js.map
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var EmptyObservable=function(_super){__extends(EmptyObservable,_super);function EmptyObservable(scheduler){_super.call(this);this.scheduler=scheduler;}/**
       * Creates an Observable that emits no items to the Observer and immediately
       * emits a complete notification.
       *
       * <span class="informal">Just emits 'complete', and nothing else.
       * </span>
       *
       * <img src="./img/empty.png" width="100%">
       *
       * This static operator is useful for creating a simple Observable that only
       * emits the complete notification. It can be used for composing with other
       * Observables, such as in a {@link mergeMap}.
       *
       * @example <caption>Emit the number 7, then complete.</caption>
       * var result = Rx.Observable.empty().startWith(7);
       * result.subscribe(x => console.log(x));
       *
       * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>
       * var interval = Rx.Observable.interval(1000);
       * var result = interval.mergeMap(x =>
       *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()
       * );
       * result.subscribe(x => console.log(x));
       *
       * // Results in the following to the console:
       * // x is equal to the count on the interval eg(0,1,2,3,...)
       * // x will occur every 1000ms
       * // if x % 2 is equal to 1 print abc
       * // if x % 2 is not equal to 1 nothing will be output
       *
       * @see {@link create}
       * @see {@link never}
       * @see {@link of}
       * @see {@link throw}
       *
       * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
       * the emission of the complete notification.
       * @return {Observable} An "empty" Observable: emits only the complete
       * notification.
       * @static true
       * @name empty
       * @owner Observable
       */EmptyObservable.create=function(scheduler){return new EmptyObservable(scheduler);};EmptyObservable.dispatch=function(arg){var subscriber=arg.subscriber;subscriber.complete();};EmptyObservable.prototype._subscribe=function(subscriber){var scheduler=this.scheduler;if(scheduler){return scheduler.schedule(EmptyObservable.dispatch,0,{subscriber:subscriber});}else{subscriber.complete();}};return EmptyObservable;}(Observable_1.Observable);exports.EmptyObservable=EmptyObservable;//# sourceMappingURL=EmptyObservable.js.map
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ConnectableObservable_1=__webpack_require__(110);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits the results of invoking a specified selector on items
   * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.
   *
   * <img src="./img/multicast.png" width="100%">
   *
   * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through
   * which the source sequence's elements will be multicast to the selector function
   * or Subject to push source elements into.
   * @param {Function} [selector] - Optional selector function that can use the multicasted source stream
   * as many times as needed, without causing multiple subscriptions to the source stream.
   * Subscribers to the given source will receive all notifications of the source from the
   * time of the subscription forward.
   * @return {Observable} An Observable that emits the results of invoking the selector
   * on the items emitted by a `ConnectableObservable` that shares a single subscription to
   * the underlying stream.
   * @method multicast
   * @owner Observable
   */function multicast(subjectOrSubjectFactory,selector){return function multicastOperatorFunction(source){var subjectFactory;if(typeof subjectOrSubjectFactory==='function'){subjectFactory=subjectOrSubjectFactory;}else{subjectFactory=function subjectFactory(){return subjectOrSubjectFactory;};}if(typeof selector==='function'){return source.lift(new MulticastOperator(subjectFactory,selector));}var connectable=Object.create(source,ConnectableObservable_1.connectableObservableDescriptor);connectable.source=source;connectable.subjectFactory=subjectFactory;return connectable;};}exports.multicast=multicast;var MulticastOperator=function(){function MulticastOperator(subjectFactory,selector){this.subjectFactory=subjectFactory;this.selector=selector;}MulticastOperator.prototype.call=function(subscriber,source){var selector=this.selector;var subject=this.subjectFactory();var subscription=selector(subject).subscribe(subscriber);subscription.add(source.subscribe(subject));return subscription;};return MulticastOperator;}();exports.MulticastOperator=MulticastOperator;//# sourceMappingURL=multicast.js.map
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);function symbolIteratorPonyfill(root){var _Symbol=root.Symbol;if(typeof _Symbol==='function'){if(!_Symbol.iterator){_Symbol.iterator=_Symbol('iterator polyfill');}return _Symbol.iterator;}else{// [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)
  var Set_1=root.Set;if(Set_1&&typeof new Set_1()['@@iterator']==='function'){return'@@iterator';}var Map_1=root.Map;// required for compatability with es6-shim
  if(Map_1){var keys=Object.getOwnPropertyNames(Map_1.prototype);for(var i=0;i<keys.length;++i){var key=keys[i];// according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.
  if(key!=='entries'&&key!=='size'&&Map_1.prototype[key]===Map_1.prototype['entries']){return key;}}}return'@@iterator';}}exports.symbolIteratorPonyfill=symbolIteratorPonyfill;exports.iterator=symbolIteratorPonyfill(root_1.root);/**
   * @deprecated use iterator instead
   */exports.$$iterator=exports.iterator;//# sourceMappingURL=iterator.js.map
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var isScheduler_1=__webpack_require__(10);var of_1=__webpack_require__(64);var from_1=__webpack_require__(65);var concatAll_1=__webpack_require__(43);/* tslint:enable:max-line-length *//**
   * Creates an output Observable which sequentially emits all values from given
   * Observable and then moves on to the next.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * `concat` joins multiple Observables together, by subscribing to them one at a time and
   * merging their results into the output Observable. You can pass either an array of
   * Observables, or put them directly as arguments. Passing an empty array will result
   * in Observable that completes immediately.
   *
   * `concat` will subscribe to first input Observable and emit all its values, without
   * changing or affecting them in any way. When that Observable completes, it will
   * subscribe to then next Observable passed and, again, emit its values. This will be
   * repeated, until the operator runs out of Observables. When last input Observable completes,
   * `concat` will complete as well. At any given moment only one Observable passed to operator
   * emits values. If you would like to emit values from passed Observables concurrently, check out
   * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,
   * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.
   *
   * Note that if some input Observable never completes, `concat` will also never complete
   * and Observables following the one that did not complete will never be subscribed. On the other
   * hand, if some Observable simply completes immediately after it is subscribed, it will be
   * invisible for `concat`, which will just move on to the next Observable.
   *
   * If any Observable in chain errors, instead of passing control to the next Observable,
   * `concat` will error immediately as well. Observables that would be subscribed after
   * the one that emitted error, never will.
   *
   * If you pass to `concat` the same Observable many times, its stream of values
   * will be "replayed" on every subscription, which means you can repeat given Observable
   * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,
   * you can always use {@link repeat}.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = Rx.Observable.concat(timer, sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   *
   * @example <caption>Concatenate an array of 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   *
   * @example <caption>Concatenate the same Observable to repeat it</caption>
   * const timer = Rx.Observable.interval(1000).take(2);
   *
   * Rx.Observable.concat(timer, timer) // concating the same Observable!
   * .subscribe(
   *   value => console.log(value),
   *   err => {},
   *   () => console.log('...and it is done!')
   * );
   *
   * // Logs:
   * // 0 after 1s
   * // 1 after 2s
   * // 0 after 3s
   * // 1 after 4s
   * // "...and it is done!" also after 4s
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} input1 An input Observable to concatenate with others.
   * @param {ObservableInput} input2 An input Observable to concatenate with others.
   * More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @static true
   * @name concat
   * @owner Observable
   */function concat(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}if(observables.length===1||observables.length===2&&isScheduler_1.isScheduler(observables[1])){return from_1.from(observables[0]);}return concatAll_1.concatAll()(of_1.of.apply(void 0,observables));}exports.concat=concat;//# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);/**
   * Represents a push-based event or value that an {@link Observable} can emit.
   * This class is particularly useful for operators that manage notifications,
   * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
   * others. Besides wrapping the actual delivered value, it also annotates it
   * with metadata of, for instance, what type of push message it is (`next`,
   * `error`, or `complete`).
   *
   * @see {@link materialize}
   * @see {@link dematerialize}
   * @see {@link observeOn}
   *
   * @class Notification<T>
   */var Notification=function(){function Notification(kind,value,error){this.kind=kind;this.value=value;this.error=error;this.hasValue=kind==='N';}/**
       * Delivers to the given `observer` the value wrapped by this Notification.
       * @param {Observer} observer
       * @return
       */Notification.prototype.observe=function(observer){switch(this.kind){case'N':return observer.next&&observer.next(this.value);case'E':return observer.error&&observer.error(this.error);case'C':return observer.complete&&observer.complete();}};/**
       * Given some {@link Observer} callbacks, deliver the value represented by the
       * current Notification to the correctly corresponding callback.
       * @param {function(value: T): void} next An Observer `next` callback.
       * @param {function(err: any): void} [error] An Observer `error` callback.
       * @param {function(): void} [complete] An Observer `complete` callback.
       * @return {any}
       */Notification.prototype.do=function(next,error,complete){var kind=this.kind;switch(kind){case'N':return next&&next(this.value);case'E':return error&&error(this.error);case'C':return complete&&complete();}};/**
       * Takes an Observer or its individual callback functions, and calls `observe`
       * or `do` methods accordingly.
       * @param {Observer|function(value: T): void} nextOrObserver An Observer or
       * the `next` callback.
       * @param {function(err: any): void} [error] An Observer `error` callback.
       * @param {function(): void} [complete] An Observer `complete` callback.
       * @return {any}
       */Notification.prototype.accept=function(nextOrObserver,error,complete){if(nextOrObserver&&typeof nextOrObserver.next==='function'){return this.observe(nextOrObserver);}else{return this.do(nextOrObserver,error,complete);}};/**
       * Returns a simple Observable that just delivers the notification represented
       * by this Notification instance.
       * @return {any}
       */Notification.prototype.toObservable=function(){var kind=this.kind;switch(kind){case'N':return Observable_1.Observable.of(this.value);case'E':return Observable_1.Observable.throw(this.error);case'C':return Observable_1.Observable.empty();}throw new Error('unexpected notification kind value');};/**
       * A shortcut to create a Notification instance of the type `next` from a
       * given value.
       * @param {T} value The `next` value.
       * @return {Notification<T>} The "next" Notification representing the
       * argument.
       */Notification.createNext=function(value){if(typeof value!=='undefined'){return new Notification('N',value);}return Notification.undefinedValueNotification;};/**
       * A shortcut to create a Notification instance of the type `error` from a
       * given error.
       * @param {any} [err] The `error` error.
       * @return {Notification<T>} The "error" Notification representing the
       * argument.
       */Notification.createError=function(err){return new Notification('E',undefined,err);};/**
       * A shortcut to create a Notification instance of the type `complete`.
       * @return {Notification<any>} The valueless "complete" Notification.
       */Notification.createComplete=function(){return Notification.completeNotification;};Notification.completeNotification=new Notification('C');Notification.undefinedValueNotification=new Notification('N',undefined);return Notification;}();exports.Notification=Notification;//# sourceMappingURL=Notification.js.map
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link mergeAll}.</span>
   *
   * <img src="./img/mergeMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an Observable, and then merging those resulting Observables and
   * emitting the results of this merger.
   *
   * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>
   * var letters = Rx.Observable.of('a', 'b', 'c');
   * var result = letters.mergeMap(x =>
   *   Rx.Observable.interval(1000).map(i => x+i)
   * );
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // a0
   * // b0
   * // c0
   * // a1
   * // b1
   * // c1
   * // continues to list a,b,c with respective ascending integers
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link merge}
   * @see {@link mergeAll}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and merging the results of the Observables obtained
   * from this transformation.
   * @method mergeMap
   * @owner Observable
   */function mergeMap(project,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return function mergeMapOperatorFunction(source){if(typeof resultSelector==='number'){concurrent=resultSelector;resultSelector=null;}return source.lift(new MergeMapOperator(project,resultSelector,concurrent));};}exports.mergeMap=mergeMap;var MergeMapOperator=function(){function MergeMapOperator(project,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}this.project=project;this.resultSelector=resultSelector;this.concurrent=concurrent;}MergeMapOperator.prototype.call=function(observer,source){return source.subscribe(new MergeMapSubscriber(observer,this.project,this.resultSelector,this.concurrent));};return MergeMapOperator;}();exports.MergeMapOperator=MergeMapOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MergeMapSubscriber=function(_super){__extends(MergeMapSubscriber,_super);function MergeMapSubscriber(destination,project,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}_super.call(this,destination);this.project=project;this.resultSelector=resultSelector;this.concurrent=concurrent;this.hasCompleted=false;this.buffer=[];this.active=0;this.index=0;}MergeMapSubscriber.prototype._next=function(value){if(this.active<this.concurrent){this._tryNext(value);}else{this.buffer.push(value);}};MergeMapSubscriber.prototype._tryNext=function(value){var result;var index=this.index++;try{result=this.project(value,index);}catch(err){this.destination.error(err);return;}this.active++;this._innerSub(result,value,index);};MergeMapSubscriber.prototype._innerSub=function(ish,value,index){this.add(subscribeToResult_1.subscribeToResult(this,ish,value,index));};MergeMapSubscriber.prototype._complete=function(){this.hasCompleted=true;if(this.active===0&&this.buffer.length===0){this.destination.complete();}};MergeMapSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){if(this.resultSelector){this._notifyResultSelector(outerValue,innerValue,outerIndex,innerIndex);}else{this.destination.next(innerValue);}};MergeMapSubscriber.prototype._notifyResultSelector=function(outerValue,innerValue,outerIndex,innerIndex){var result;try{result=this.resultSelector(outerValue,innerValue,outerIndex,innerIndex);}catch(err){this.destination.error(err);return;}this.destination.next(result);};MergeMapSubscriber.prototype.notifyComplete=function(innerSub){var buffer=this.buffer;this.remove(innerSub);this.active--;if(buffer.length>0){this._next(buffer.shift());}else if(this.active===0&&this.hasCompleted){this.destination.complete();}};return MergeMapSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.MergeMapSubscriber=MergeMapSubscriber;//# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var isArray_1=__webpack_require__(11);function isNumeric(val){// parseFloat NaNs numeric-cast false positives (null|true|false|"")
  // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  // subtraction forces infinities to NaN
  // adding 1 corrects loss of precision from parseFloat (#15100)
  return!isArray_1.isArray(val)&&val-parseFloat(val)+1>=0;}exports.isNumeric=isNumeric;;//# sourceMappingURL=isNumeric.js.map
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var root_1=__webpack_require__(9);var Action_1=__webpack_require__(199);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var AsyncAction=function(_super){__extends(AsyncAction,_super);function AsyncAction(scheduler,work){_super.call(this,scheduler,work);this.scheduler=scheduler;this.work=work;this.pending=false;}AsyncAction.prototype.schedule=function(state,delay){if(delay===void 0){delay=0;}if(this.closed){return this;}// Always replace the current state with the new state.
  this.state=state;// Set the pending flag indicating that this action has been scheduled, or
  // has recursively rescheduled itself.
  this.pending=true;var id=this.id;var scheduler=this.scheduler;//
  // Important implementation note:
  //
  // Actions only execute once by default, unless rescheduled from within the
  // scheduled callback. This allows us to implement single and repeat
  // actions via the same code path, without adding API surface area, as well
  // as mimic traditional recursion but across asynchronous boundaries.
  //
  // However, JS runtimes and timers distinguish between intervals achieved by
  // serial `setTimeout` calls vs. a single `setInterval` call. An interval of
  // serial `setTimeout` calls can be individually delayed, which delays
  // scheduling the next `setTimeout`, and so on. `setInterval` attempts to
  // guarantee the interval callback will be invoked more precisely to the
  // interval period, regardless of load.
  //
  // Therefore, we use `setInterval` to schedule single and repeat actions.
  // If the action reschedules itself with the same delay, the interval is not
  // canceled. If the action doesn't reschedule, or reschedules with a
  // different delay, the interval will be canceled after scheduled callback
  // execution.
  //
  if(id!=null){this.id=this.recycleAsyncId(scheduler,id,delay);}this.delay=delay;// If this action has already an async Id, don't request a new one.
  this.id=this.id||this.requestAsyncId(scheduler,this.id,delay);return this;};AsyncAction.prototype.requestAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}return root_1.root.setInterval(scheduler.flush.bind(scheduler,this),delay);};AsyncAction.prototype.recycleAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If this action is rescheduled with the same delay time, don't clear the interval id.
  if(delay!==null&&this.delay===delay&&this.pending===false){return id;}// Otherwise, if the action's delay time is different from the current delay,
  // or the action has been rescheduled before it's executed, clear the interval id
  return root_1.root.clearInterval(id)&&undefined||undefined;};/**
       * Immediately executes this action and the `work` it contains.
       * @return {any}
       */AsyncAction.prototype.execute=function(state,delay){if(this.closed){return new Error('executing a cancelled action');}this.pending=false;var error=this._execute(state,delay);if(error){return error;}else if(this.pending===false&&this.id!=null){// Dequeue if the action didn't reschedule itself. Don't call
  // unsubscribe(), because the action could reschedule later.
  // For example:
  // ```
  // scheduler.schedule(function doWork(counter) {
  //   /* ... I'm a busy worker bee ... */
  //   var originalAction = this;
  //   /* wait 100ms before rescheduling the action */
  //   setTimeout(function () {
  //     originalAction.schedule(counter + 1);
  //   }, 100);
  // }, 1000);
  // ```
  this.id=this.recycleAsyncId(this.scheduler,this.id,null);}};AsyncAction.prototype._execute=function(state,delay){var errored=false;var errorValue=undefined;try{this.work(state);}catch(e){errored=true;errorValue=!!e&&e||new Error(e);}if(errored){this.unsubscribe();return errorValue;}};AsyncAction.prototype._unsubscribe=function(){var id=this.id;var scheduler=this.scheduler;var actions=scheduler.actions;var index=actions.indexOf(this);this.work=null;this.state=null;this.pending=false;this.scheduler=null;if(index!==-1){actions.splice(index,1);}if(id!=null){this.id=this.recycleAsyncId(scheduler,id,null);}this.delay=null;};return AsyncAction;}(Action_1.Action);exports.AsyncAction=AsyncAction;//# sourceMappingURL=AsyncAction.js.map
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Scheduler_1=__webpack_require__(200);var AsyncScheduler=function(_super){__extends(AsyncScheduler,_super);function AsyncScheduler(){_super.apply(this,arguments);this.actions=[];/**
           * A flag to indicate whether the Scheduler is currently executing a batch of
           * queued actions.
           * @type {boolean}
           */this.active=false;/**
           * An internal ID used to track the latest asynchronous task such as those
           * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and
           * others.
           * @type {any}
           */this.scheduled=undefined;}AsyncScheduler.prototype.flush=function(action){var actions=this.actions;if(this.active){actions.push(action);return;}var error;this.active=true;do{if(error=action.execute(action.state,action.delay)){break;}}while(action=actions.shift());// exhaust the scheduler queue
  this.active=false;if(error){while(action=actions.shift()){action.unsubscribe();}throw error;}};return AsyncScheduler;}(Scheduler_1.Scheduler);exports.AsyncScheduler=AsyncScheduler;//# sourceMappingURL=AsyncScheduler.js.map
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Applies a given `project` function to each value emitted by the source
   * Observable, and emits the resulting values as an Observable.
   *
   * <span class="informal">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),
   * it passes each source value through a transformation function to get
   * corresponding output values.</span>
   *
   * <img src="./img/map.png" width="100%">
   *
   * Similar to the well known `Array.prototype.map` function, this operator
   * applies a projection to each value and emits that projection in the output
   * Observable.
   *
   * @example <caption>Map every click to the clientX position of that click</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var positions = clicks.map(ev => ev.clientX);
   * positions.subscribe(x => console.log(x));
   *
   * @see {@link mapTo}
   * @see {@link pluck}
   *
   * @param {function(value: T, index: number): R} project The function to apply
   * to each `value` emitted by the source Observable. The `index` parameter is
   * the number `i` for the i-th emission that has happened since the
   * subscription, starting from the number `0`.
   * @param {any} [thisArg] An optional argument to define what `this` is in the
   * `project` function.
   * @return {Observable<R>} An Observable that emits the values from the source
   * Observable transformed by the given `project` function.
   * @method map
   * @owner Observable
   */function map(project,thisArg){return function mapOperation(source){if(typeof project!=='function'){throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');}return source.lift(new MapOperator(project,thisArg));};}exports.map=map;var MapOperator=function(){function MapOperator(project,thisArg){this.project=project;this.thisArg=thisArg;}MapOperator.prototype.call=function(subscriber,source){return source.subscribe(new MapSubscriber(subscriber,this.project,this.thisArg));};return MapOperator;}();exports.MapOperator=MapOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MapSubscriber=function(_super){__extends(MapSubscriber,_super);function MapSubscriber(destination,project,thisArg){_super.call(this,destination);this.project=project;this.count=0;this.thisArg=thisArg||this;}// NOTE: This looks unoptimized, but it's actually purposefully NOT
  // using try/catch optimizations.
  MapSubscriber.prototype._next=function(value){var result;try{result=this.project.call(this.thisArg,value,this.count++);}catch(err){this.destination.error(err);return;}this.destination.next(result);};return MapSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=map.js.map
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};/**
   * An error thrown when an element was queried at a certain index of an
   * Observable, but no such index or position exists in that sequence.
   *
   * @see {@link elementAt}
   * @see {@link take}
   * @see {@link takeLast}
   *
   * @class ArgumentOutOfRangeError
   */var ArgumentOutOfRangeError=function(_super){__extends(ArgumentOutOfRangeError,_super);function ArgumentOutOfRangeError(){var err=_super.call(this,'argument out of range');this.name=err.name='ArgumentOutOfRangeError';this.stack=err.stack;this.message=err.message;}return ArgumentOutOfRangeError;}(Error);exports.ArgumentOutOfRangeError=ArgumentOutOfRangeError;//# sourceMappingURL=ArgumentOutOfRangeError.js.map
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var scan_1=__webpack_require__(52);var takeLast_1=__webpack_require__(53);var defaultIfEmpty_1=__webpack_require__(47);var pipe_1=__webpack_require__(40);/* tslint:enable:max-line-length *//**
   * Applies an accumulator function over the source Observable, and returns the
   * accumulated result when the source completes, given an optional seed value.
   *
   * <span class="informal">Combines together all values emitted on the source,
   * using an accumulator function that knows how to join a new source value into
   * the accumulation from the past.</span>
   *
   * <img src="./img/reduce.png" width="100%">
   *
   * Like
   * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),
   * `reduce` applies an `accumulator` function against an accumulation and each
   * value of the source Observable (from the past) to reduce it to a single
   * value, emitted on the output Observable. Note that `reduce` will only emit
   * one value, only when the source Observable completes. It is equivalent to
   * applying operator {@link scan} followed by operator {@link last}.
   *
   * Returns an Observable that applies a specified `accumulator` function to each
   * item emitted by the source Observable. If a `seed` value is specified, then
   * that value will be used as the initial value for the accumulator. If no seed
   * value is specified, the first item of the source is used as the seed.
   *
   * @example <caption>Count the number of click events that happened in 5 seconds</caption>
   * var clicksInFiveSeconds = Rx.Observable.fromEvent(document, 'click')
   *   .takeUntil(Rx.Observable.interval(5000));
   * var ones = clicksInFiveSeconds.mapTo(1);
   * var seed = 0;
   * var count = ones.reduce((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link count}
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link scan}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator The accumulator function
   * called on each source value.
   * @param {R} [seed] The initial accumulation value.
   * @return {Observable<R>} An Observable that emits a single value that is the
   * result of accumulating the values emitted by the source Observable.
   * @method reduce
   * @owner Observable
   */function reduce(accumulator,seed){// providing a seed of `undefined` *should* be valid and trigger
  // hasSeed! so don't use `seed !== undefined` checks!
  // For this reason, we have to check it here at the original call site
  // otherwise inside Operator/Subscriber we won't know if `undefined`
  // means they didn't provide anything or if they literally provided `undefined`
  if(arguments.length>=2){return function reduceOperatorFunctionWithSeed(source){return pipe_1.pipe(scan_1.scan(accumulator,seed),takeLast_1.takeLast(1),defaultIfEmpty_1.defaultIfEmpty(seed))(source);};}return function reduceOperatorFunction(source){return pipe_1.pipe(scan_1.scan(function(acc,value,index){return accumulator(acc,value,index+1);}),takeLast_1.takeLast(1))(source);};}exports.reduce=reduce;//# sourceMappingURL=reduce.js.map
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function isFunction(x){return typeof x==='function';}exports.isFunction=isFunction;//# sourceMappingURL=isFunction.js.map
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);var _Symbol=root_1.root.Symbol;exports.rxSubscriber=typeof _Symbol==='function'&&typeof _Symbol.for==='function'?_Symbol.for('rxSubscriber'):'@@rxSubscriber';/**
   * @deprecated use rxSubscriber instead
   */exports.$$rxSubscriber=exports.rxSubscriber;//# sourceMappingURL=rxSubscriber.js.map
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);function getSymbolObservable(context){var $$observable;var _Symbol=context.Symbol;if(typeof _Symbol==='function'){if(_Symbol.observable){$$observable=_Symbol.observable;}else{$$observable=_Symbol('observable');_Symbol.observable=$$observable;}}else{$$observable='@@observable';}return $$observable;}exports.getSymbolObservable=getSymbolObservable;exports.observable=getSymbolObservable(root_1.root);/**
   * @deprecated use observable instead
   */exports.$$observable=exports.observable;//# sourceMappingURL=observable.js.map
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};/**
   * An error thrown when an action is invalid because the object has been
   * unsubscribed.
   *
   * @see {@link Subject}
   * @see {@link BehaviorSubject}
   *
   * @class ObjectUnsubscribedError
   */var ObjectUnsubscribedError=function(_super){__extends(ObjectUnsubscribedError,_super);function ObjectUnsubscribedError(){var err=_super.call(this,'object unsubscribed');this.name=err.name='ObjectUnsubscribedError';this.stack=err.stack;this.message=err.message;}return ObjectUnsubscribedError;}(Error);exports.ObjectUnsubscribedError=ObjectUnsubscribedError;//# sourceMappingURL=ObjectUnsubscribedError.js.map
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var Subscription_1=__webpack_require__(5);/**
   * @class AsyncSubject<T>
   */var AsyncSubject=function(_super){__extends(AsyncSubject,_super);function AsyncSubject(){_super.apply(this,arguments);this.value=null;this.hasNext=false;this.hasCompleted=false;}AsyncSubject.prototype._subscribe=function(subscriber){if(this.hasError){subscriber.error(this.thrownError);return Subscription_1.Subscription.EMPTY;}else if(this.hasCompleted&&this.hasNext){subscriber.next(this.value);subscriber.complete();return Subscription_1.Subscription.EMPTY;}return _super.prototype._subscribe.call(this,subscriber);};AsyncSubject.prototype.next=function(value){if(!this.hasCompleted){this.value=value;this.hasNext=true;}};AsyncSubject.prototype.error=function(error){if(!this.hasCompleted){_super.prototype.error.call(this,error);}};AsyncSubject.prototype.complete=function(){this.hasCompleted=true;if(this.hasNext){_super.prototype.next.call(this,this.value);}_super.prototype.complete.call(this);};return AsyncSubject;}(Subject_1.Subject);exports.AsyncSubject=AsyncSubject;//# sourceMappingURL=AsyncSubject.js.map
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var ArrayObservable_1=__webpack_require__(12);var isArray_1=__webpack_require__(11);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);var none={};/* tslint:enable:max-line-length *//**
   * Combines multiple Observables to create an Observable whose values are
   * calculated from the latest values of each of its input Observables.
   *
   * <span class="informal">Whenever any input Observable emits a value, it
   * computes a formula using the latest values from all the inputs, then emits
   * the output of that formula.</span>
   *
   * <img src="./img/combineLatest.png" width="100%">
   *
   * `combineLatest` combines the values from this Observable with values from
   * Observables passed as arguments. This is done by subscribing to each
   * Observable, in order, and collecting an array of each of the most recent
   * values any time any of the input Observables emits, then either taking that
   * array and passing it as arguments to an optional `project` function and
   * emitting the return value of that, or just emitting the array of recent
   * values directly if there is no `project` function.
   *
   * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>
   * var weight = Rx.Observable.of(70, 72, 76, 79, 75);
   * var height = Rx.Observable.of(1.76, 1.77, 1.78);
   * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));
   * bmi.subscribe(x => console.log('BMI is ' + x));
   *
   * // With output to console:
   * // BMI is 24.212293388429753
   * // BMI is 23.93948099205209
   * // BMI is 23.671253629592222
   *
   * @see {@link combineAll}
   * @see {@link merge}
   * @see {@link withLatestFrom}
   *
   * @param {ObservableInput} other An input Observable to combine with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {function} [project] An optional function to project the values from
   * the combined latest values into a new value on the output Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @method combineLatest
   * @owner Observable
   */function combineLatest(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}var project=null;if(typeof observables[observables.length-1]==='function'){project=observables.pop();}// if the first and only other argument besides the resultSelector is an array
  // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`
  if(observables.length===1&&isArray_1.isArray(observables[0])){observables=observables[0].slice();}return function(source){return source.lift.call(new ArrayObservable_1.ArrayObservable([source].concat(observables)),new CombineLatestOperator(project));};}exports.combineLatest=combineLatest;var CombineLatestOperator=function(){function CombineLatestOperator(project){this.project=project;}CombineLatestOperator.prototype.call=function(subscriber,source){return source.subscribe(new CombineLatestSubscriber(subscriber,this.project));};return CombineLatestOperator;}();exports.CombineLatestOperator=CombineLatestOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var CombineLatestSubscriber=function(_super){__extends(CombineLatestSubscriber,_super);function CombineLatestSubscriber(destination,project){_super.call(this,destination);this.project=project;this.active=0;this.values=[];this.observables=[];}CombineLatestSubscriber.prototype._next=function(observable){this.values.push(none);this.observables.push(observable);};CombineLatestSubscriber.prototype._complete=function(){var observables=this.observables;var len=observables.length;if(len===0){this.destination.complete();}else{this.active=len;this.toRespond=len;for(var i=0;i<len;i++){var observable=observables[i];this.add(subscribeToResult_1.subscribeToResult(this,observable,observable,i));}}};CombineLatestSubscriber.prototype.notifyComplete=function(unused){if((this.active-=1)===0){this.destination.complete();}};CombineLatestSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var values=this.values;var oldVal=values[outerIndex];var toRespond=!this.toRespond?0:oldVal===none?--this.toRespond:this.toRespond;values[outerIndex]=innerValue;if(toRespond===0){if(this.project){this._tryProject(values);}else{this.destination.next(values.slice());}}};CombineLatestSubscriber.prototype._tryProject=function(values){var result;try{result=this.project.apply(this,values);}catch(err){this.destination.error(err);return;}this.destination.next(result);};return CombineLatestSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.CombineLatestSubscriber=CombineLatestSubscriber;//# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Notification_1=__webpack_require__(17);/**
   *
   * Re-emits all notifications from source Observable with specified scheduler.
   *
   * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
   *
   * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
   * notifications emitted by the source Observable. It might be useful, if you do not have control over
   * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
   *
   * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
   * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
   * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
   * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
   * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
   * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
   * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
   * little bit more, to ensure that they are emitted at expected moments.
   *
   * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
   * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
   * will delay all notifications - including error notifications - while `delay` will pass through error
   * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
   * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
   * for notification emissions in general.
   *
   * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>
   * const intervals = Rx.Observable.interval(10); // Intervals are scheduled
   *                                               // with async scheduler by default...
   *
   * intervals
   * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame
   * .subscribe(val => {                           // scheduler to ensure smooth animation.
   *   someDiv.style.height = val + 'px';
   * });
   *
   * @see {@link delay}
   *
   * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.
   * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.
   * @return {Observable<T>} Observable that emits the same notifications as the source Observable,
   * but with provided scheduler.
   *
   * @method observeOn
   * @owner Observable
   */function observeOn(scheduler,delay){if(delay===void 0){delay=0;}return function observeOnOperatorFunction(source){return source.lift(new ObserveOnOperator(scheduler,delay));};}exports.observeOn=observeOn;var ObserveOnOperator=function(){function ObserveOnOperator(scheduler,delay){if(delay===void 0){delay=0;}this.scheduler=scheduler;this.delay=delay;}ObserveOnOperator.prototype.call=function(subscriber,source){return source.subscribe(new ObserveOnSubscriber(subscriber,this.scheduler,this.delay));};return ObserveOnOperator;}();exports.ObserveOnOperator=ObserveOnOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ObserveOnSubscriber=function(_super){__extends(ObserveOnSubscriber,_super);function ObserveOnSubscriber(destination,scheduler,delay){if(delay===void 0){delay=0;}_super.call(this,destination);this.scheduler=scheduler;this.delay=delay;}ObserveOnSubscriber.dispatch=function(arg){var notification=arg.notification,destination=arg.destination;notification.observe(destination);this.unsubscribe();};ObserveOnSubscriber.prototype.scheduleMessage=function(notification){this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch,this.delay,new ObserveOnMessage(notification,this.destination)));};ObserveOnSubscriber.prototype._next=function(value){this.scheduleMessage(Notification_1.Notification.createNext(value));};ObserveOnSubscriber.prototype._error=function(err){this.scheduleMessage(Notification_1.Notification.createError(err));};ObserveOnSubscriber.prototype._complete=function(){this.scheduleMessage(Notification_1.Notification.createComplete());};return ObserveOnSubscriber;}(Subscriber_1.Subscriber);exports.ObserveOnSubscriber=ObserveOnSubscriber;var ObserveOnMessage=function(){function ObserveOnMessage(notification,destination){this.notification=notification;this.destination=destination;}return ObserveOnMessage;}();exports.ObserveOnMessage=ObserveOnMessage;//# sourceMappingURL=observeOn.js.map
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeMap_1=__webpack_require__(18);var identity_1=__webpack_require__(68);/**
   * Converts a higher-order Observable into a first-order Observable which
   * concurrently delivers all values that are emitted on the inner Observables.
   *
   * <span class="informal">Flattens an Observable-of-Observables.</span>
   *
   * <img src="./img/mergeAll.png" width="100%">
   *
   * `mergeAll` subscribes to an Observable that emits Observables, also known as
   * a higher-order Observable. Each time it observes one of these emitted inner
   * Observables, it subscribes to that and delivers all the values from the
   * inner Observable on the output Observable. The output Observable only
   * completes once all inner Observables have completed. Any error delivered by
   * a inner Observable will be immediately emitted on the output Observable.
   *
   * @example <caption>Spawn a new interval Observable for each click event, and blend their outputs as one Observable</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000));
   * var firstOrder = higherOrder.mergeAll();
   * firstOrder.subscribe(x => console.log(x));
   *
   * @example <caption>Count from 0 to 9 every second for each click, but only allow 2 concurrent timers</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(10));
   * var firstOrder = higherOrder.mergeAll(2);
   * firstOrder.subscribe(x => console.log(x));
   *
   * @see {@link combineAll}
   * @see {@link concatAll}
   * @see {@link exhaust}
   * @see {@link merge}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   * @see {@link switch}
   * @see {@link zipAll}
   *
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of inner
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits values coming from all the
   * inner Observables emitted by the source Observable.
   * @method mergeAll
   * @owner Observable
   */function mergeAll(concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return mergeMap_1.mergeMap(identity_1.identity,null,concurrent);}exports.mergeAll=mergeAll;//# sourceMappingURL=mergeAll.js.map
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var ArrayObservable_1=__webpack_require__(12);var isScheduler_1=__webpack_require__(10);var mergeAll_1=__webpack_require__(32);/* tslint:enable:max-line-length *//**
   * Creates an output Observable which concurrently emits all values from every
   * given input Observable.
   *
   * <span class="informal">Flattens multiple Observables together by blending
   * their values into one Observable.</span>
   *
   * <img src="./img/merge.png" width="100%">
   *
   * `merge` subscribes to each given input Observable (as arguments), and simply
   * forwards (without doing any transformation) all the values from all the input
   * Observables to the output Observable. The output Observable only completes
   * once all input Observables have completed. Any error delivered by an input
   * Observable will be immediately emitted on the output Observable.
   *
   * @example <caption>Merge together two Observables: 1s interval and clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var clicksOrTimer = Rx.Observable.merge(clicks, timer);
   * clicksOrTimer.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // timer will emit ascending values, one every second(1000ms) to console
   * // clicks logs MouseEvents to console everytime the "document" is clicked
   * // Since the two streams are merged you see these happening
   * // as they occur.
   *
   * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var concurrent = 2; // the argument
   * var merged = Rx.Observable.merge(timer1, timer2, timer3, concurrent);
   * merged.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // - First timer1 and timer2 will run concurrently
   * // - timer1 will emit a value every 1000ms for 10 iterations
   * // - timer2 will emit a value every 2000ms for 6 iterations
   * // - after timer1 hits it's max iteration, timer2 will
   * //   continue, and timer3 will start to run concurrently with timer2
   * // - when timer2 hits it's max iteration it terminates, and
   * //   timer3 will continue to emit a value every 500ms until it is complete
   *
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   *
   * @param {...ObservableInput} observables Input Observables to merge together.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for managing
   * concurrency of input Observables.
   * @return {Observable} an Observable that emits items that are the result of
   * every input Observable.
   * @static true
   * @name merge
   * @owner Observable
   */function merge(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}var concurrent=Number.POSITIVE_INFINITY;var scheduler=null;var last=observables[observables.length-1];if(isScheduler_1.isScheduler(last)){scheduler=observables.pop();if(observables.length>1&&typeof observables[observables.length-1]==='number'){concurrent=observables.pop();}}else if(typeof last==='number'){concurrent=observables.pop();}if(scheduler===null&&observables.length===1&&observables[0]instanceof Observable_1.Observable){return observables[0];}return mergeAll_1.mergeAll(concurrent)(new ArrayObservable_1.ArrayObservable(observables,scheduler));}exports.merge=merge;//# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function isDate(value){return value instanceof Date&&!isNaN(+value);}exports.isDate=isDate;//# sourceMappingURL=isDate.js.map
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var ArrayObservable_1=__webpack_require__(12);var isArray_1=__webpack_require__(11);var Subscriber_1=__webpack_require__(1);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);var iterator_1=__webpack_require__(15);/* tslint:enable:max-line-length *//**
   * @param observables
   * @return {Observable<R>}
   * @method zip
   * @owner Observable
   */function zip(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return function zipOperatorFunction(source){return source.lift.call(zipStatic.apply(void 0,[source].concat(observables)));};}exports.zip=zip;/* tslint:enable:max-line-length *//**
   * Combines multiple Observables to create an Observable whose values are calculated from the values, in order, of each
   * of its input Observables.
   *
   * If the latest parameter is a function, this function is used to compute the created value from the input values.
   * Otherwise, an array of the input values is returned.
   *
   * @example <caption>Combine age and name from different sources</caption>
   *
   * let age$ = Observable.of<number>(27, 25, 29);
   * let name$ = Observable.of<string>('Foo', 'Bar', 'Beer');
   * let isDev$ = Observable.of<boolean>(true, true, false);
   *
   * Observable
   *     .zip(age$,
   *          name$,
   *          isDev$,
   *          (age: number, name: string, isDev: boolean) => ({ age, name, isDev }))
   *     .subscribe(x => console.log(x));
   *
   * // outputs
   * // { age: 27, name: 'Foo', isDev: true }
   * // { age: 25, name: 'Bar', isDev: true }
   * // { age: 29, name: 'Beer', isDev: false }
   *
   * @param observables
   * @return {Observable<R>}
   * @static true
   * @name zip
   * @owner Observable
   */function zipStatic(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}var project=observables[observables.length-1];if(typeof project==='function'){observables.pop();}return new ArrayObservable_1.ArrayObservable(observables).lift(new ZipOperator(project));}exports.zipStatic=zipStatic;var ZipOperator=function(){function ZipOperator(project){this.project=project;}ZipOperator.prototype.call=function(subscriber,source){return source.subscribe(new ZipSubscriber(subscriber,this.project));};return ZipOperator;}();exports.ZipOperator=ZipOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ZipSubscriber=function(_super){__extends(ZipSubscriber,_super);function ZipSubscriber(destination,project,values){if(values===void 0){values=Object.create(null);}_super.call(this,destination);this.iterators=[];this.active=0;this.project=typeof project==='function'?project:null;this.values=values;}ZipSubscriber.prototype._next=function(value){var iterators=this.iterators;if(isArray_1.isArray(value)){iterators.push(new StaticArrayIterator(value));}else if(typeof value[iterator_1.iterator]==='function'){iterators.push(new StaticIterator(value[iterator_1.iterator]()));}else{iterators.push(new ZipBufferIterator(this.destination,this,value));}};ZipSubscriber.prototype._complete=function(){var iterators=this.iterators;var len=iterators.length;if(len===0){this.destination.complete();return;}this.active=len;for(var i=0;i<len;i++){var iterator=iterators[i];if(iterator.stillUnsubscribed){this.add(iterator.subscribe(iterator,i));}else{this.active--;// not an observable
  }}};ZipSubscriber.prototype.notifyInactive=function(){this.active--;if(this.active===0){this.destination.complete();}};ZipSubscriber.prototype.checkIterators=function(){var iterators=this.iterators;var len=iterators.length;var destination=this.destination;// abort if not all of them have values
  for(var i=0;i<len;i++){var iterator=iterators[i];if(typeof iterator.hasValue==='function'&&!iterator.hasValue()){return;}}var shouldComplete=false;var args=[];for(var i=0;i<len;i++){var iterator=iterators[i];var result=iterator.next();// check to see if it's completed now that you've gotten
  // the next value.
  if(iterator.hasCompleted()){shouldComplete=true;}if(result.done){destination.complete();return;}args.push(result.value);}if(this.project){this._tryProject(args);}else{destination.next(args);}if(shouldComplete){destination.complete();}};ZipSubscriber.prototype._tryProject=function(args){var result;try{result=this.project.apply(this,args);}catch(err){this.destination.error(err);return;}this.destination.next(result);};return ZipSubscriber;}(Subscriber_1.Subscriber);exports.ZipSubscriber=ZipSubscriber;var StaticIterator=function(){function StaticIterator(iterator){this.iterator=iterator;this.nextResult=iterator.next();}StaticIterator.prototype.hasValue=function(){return true;};StaticIterator.prototype.next=function(){var result=this.nextResult;this.nextResult=this.iterator.next();return result;};StaticIterator.prototype.hasCompleted=function(){var nextResult=this.nextResult;return nextResult&&nextResult.done;};return StaticIterator;}();var StaticArrayIterator=function(){function StaticArrayIterator(array){this.array=array;this.index=0;this.length=0;this.length=array.length;}StaticArrayIterator.prototype[iterator_1.iterator]=function(){return this;};StaticArrayIterator.prototype.next=function(value){var i=this.index++;var array=this.array;return i<this.length?{value:array[i],done:false}:{value:null,done:true};};StaticArrayIterator.prototype.hasValue=function(){return this.array.length>this.index;};StaticArrayIterator.prototype.hasCompleted=function(){return this.array.length===this.index;};return StaticArrayIterator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ZipBufferIterator=function(_super){__extends(ZipBufferIterator,_super);function ZipBufferIterator(destination,parent,observable){_super.call(this,destination);this.parent=parent;this.observable=observable;this.stillUnsubscribed=true;this.buffer=[];this.isComplete=false;}ZipBufferIterator.prototype[iterator_1.iterator]=function(){return this;};// NOTE: there is actually a name collision here with Subscriber.next and Iterator.next
  //    this is legit because `next()` will never be called by a subscription in this case.
  ZipBufferIterator.prototype.next=function(){var buffer=this.buffer;if(buffer.length===0&&this.isComplete){return{value:null,done:true};}else{return{value:buffer.shift(),done:false};}};ZipBufferIterator.prototype.hasValue=function(){return this.buffer.length>0;};ZipBufferIterator.prototype.hasCompleted=function(){return this.buffer.length===0&&this.isComplete;};ZipBufferIterator.prototype.notifyComplete=function(){if(this.buffer.length>0){this.isComplete=true;this.parent.notifyInactive();}else{this.destination.complete();}};ZipBufferIterator.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.buffer.push(innerValue);this.parent.checkIterators();};ZipBufferIterator.prototype.subscribe=function(value,index){return subscribeToResult_1.subscribeToResult(this,this.observable,this,index);};return ZipBufferIterator;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var queue_1=__webpack_require__(71);var Subscription_1=__webpack_require__(5);var observeOn_1=__webpack_require__(31);var ObjectUnsubscribedError_1=__webpack_require__(28);var SubjectSubscription_1=__webpack_require__(61);/**
   * @class ReplaySubject<T>
   */var ReplaySubject=function(_super){__extends(ReplaySubject,_super);function ReplaySubject(bufferSize,windowTime,scheduler){if(bufferSize===void 0){bufferSize=Number.POSITIVE_INFINITY;}if(windowTime===void 0){windowTime=Number.POSITIVE_INFINITY;}_super.call(this);this.scheduler=scheduler;this._events=[];this._bufferSize=bufferSize<1?1:bufferSize;this._windowTime=windowTime<1?1:windowTime;}ReplaySubject.prototype.next=function(value){var now=this._getNow();this._events.push(new ReplayEvent(now,value));this._trimBufferThenGetEvents();_super.prototype.next.call(this,value);};ReplaySubject.prototype._subscribe=function(subscriber){var _events=this._trimBufferThenGetEvents();var scheduler=this.scheduler;var subscription;if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}else if(this.hasError){subscription=Subscription_1.Subscription.EMPTY;}else if(this.isStopped){subscription=Subscription_1.Subscription.EMPTY;}else{this.observers.push(subscriber);subscription=new SubjectSubscription_1.SubjectSubscription(this,subscriber);}if(scheduler){subscriber.add(subscriber=new observeOn_1.ObserveOnSubscriber(subscriber,scheduler));}var len=_events.length;for(var i=0;i<len&&!subscriber.closed;i++){subscriber.next(_events[i].value);}if(this.hasError){subscriber.error(this.thrownError);}else if(this.isStopped){subscriber.complete();}return subscription;};ReplaySubject.prototype._getNow=function(){return(this.scheduler||queue_1.queue).now();};ReplaySubject.prototype._trimBufferThenGetEvents=function(){var now=this._getNow();var _bufferSize=this._bufferSize;var _windowTime=this._windowTime;var _events=this._events;var eventsCount=_events.length;var spliceCount=0;// Trim events that fall out of the time window.
  // Start at the front of the list. Break early once
  // we encounter an event that falls within the window.
  while(spliceCount<eventsCount){if(now-_events[spliceCount].time<_windowTime){break;}spliceCount++;}if(eventsCount>_bufferSize){spliceCount=Math.max(spliceCount,eventsCount-_bufferSize);}if(spliceCount>0){_events.splice(0,spliceCount);}return _events;};return ReplaySubject;}(Subject_1.Subject);exports.ReplaySubject=ReplaySubject;var ReplayEvent=function(){function ReplayEvent(time,value){this.time=time;this.value=value;}return ReplayEvent;}();//# sourceMappingURL=ReplaySubject.js.map
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};/**
   * An error thrown when an Observable or a sequence was queried but has no
   * elements.
   *
   * @see {@link first}
   * @see {@link last}
   * @see {@link single}
   *
   * @class EmptyError
   */var EmptyError=function(_super){__extends(EmptyError,_super);function EmptyError(){var err=_super.call(this,'no elements in sequence');this.name=err.name='EmptyError';this.stack=err.stack;this.message=err.message;}return EmptyError;}(Error);exports.EmptyError=EmptyError;//# sourceMappingURL=EmptyError.js.map
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);exports.defaultThrottleConfig={leading:true,trailing:false};/**
   * Emits a value from the source Observable, then ignores subsequent source
   * values for a duration determined by another Observable, then repeats this
   * process.
   *
   * <span class="informal">It's like {@link throttleTime}, but the silencing
   * duration is determined by a second Observable.</span>
   *
   * <img src="./img/throttle.png" width="100%">
   *
   * `throttle` emits the source Observable values on the output Observable
   * when its internal timer is disabled, and ignores source values when the timer
   * is enabled. Initially, the timer is disabled. As soon as the first source
   * value arrives, it is forwarded to the output Observable, and then the timer
   * is enabled by calling the `durationSelector` function with the source value,
   * which returns the "duration" Observable. When the duration Observable emits a
   * value or completes, the timer is disabled, and this process repeats for the
   * next source value.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.throttle(ev => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounce}
   * @see {@link delayWhen}
   * @see {@link sample}
   * @see {@link throttleTime}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the silencing
   * duration for each source value, returned as an Observable or a Promise.
   * @param {Object} config a configuration object to define `leading` and `trailing` behavior. Defaults
   * to `{ leading: true, trailing: false }`.
   * @return {Observable<T>} An Observable that performs the throttle operation to
   * limit the rate of emissions from the source.
   * @method throttle
   * @owner Observable
   */function throttle(durationSelector,config){if(config===void 0){config=exports.defaultThrottleConfig;}return function(source){return source.lift(new ThrottleOperator(durationSelector,config.leading,config.trailing));};}exports.throttle=throttle;var ThrottleOperator=function(){function ThrottleOperator(durationSelector,leading,trailing){this.durationSelector=durationSelector;this.leading=leading;this.trailing=trailing;}ThrottleOperator.prototype.call=function(subscriber,source){return source.subscribe(new ThrottleSubscriber(subscriber,this.durationSelector,this.leading,this.trailing));};return ThrottleOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc
   * @ignore
   * @extends {Ignored}
   */var ThrottleSubscriber=function(_super){__extends(ThrottleSubscriber,_super);function ThrottleSubscriber(destination,durationSelector,_leading,_trailing){_super.call(this,destination);this.destination=destination;this.durationSelector=durationSelector;this._leading=_leading;this._trailing=_trailing;this._hasTrailingValue=false;}ThrottleSubscriber.prototype._next=function(value){if(this.throttled){if(this._trailing){this._hasTrailingValue=true;this._trailingValue=value;}}else{var duration=this.tryDurationSelector(value);if(duration){this.add(this.throttled=subscribeToResult_1.subscribeToResult(this,duration));}if(this._leading){this.destination.next(value);if(this._trailing){this._hasTrailingValue=true;this._trailingValue=value;}}}};ThrottleSubscriber.prototype.tryDurationSelector=function(value){try{return this.durationSelector(value);}catch(err){this.destination.error(err);return null;}};ThrottleSubscriber.prototype._unsubscribe=function(){var _a=this,throttled=_a.throttled,_trailingValue=_a._trailingValue,_hasTrailingValue=_a._hasTrailingValue,_trailing=_a._trailing;this._trailingValue=null;this._hasTrailingValue=false;if(throttled){this.remove(throttled);this.throttled=null;throttled.unsubscribe();}};ThrottleSubscriber.prototype._sendTrailing=function(){var _a=this,destination=_a.destination,throttled=_a.throttled,_trailing=_a._trailing,_trailingValue=_a._trailingValue,_hasTrailingValue=_a._hasTrailingValue;if(throttled&&_trailing&&_hasTrailingValue){destination.next(_trailingValue);this._trailingValue=null;this._hasTrailingValue=false;}};ThrottleSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this._sendTrailing();this._unsubscribe();};ThrottleSubscriber.prototype.notifyComplete=function(){this._sendTrailing();this._unsubscribe();};return ThrottleSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=throttle.js.map
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* tslint:disable:no-unused-variable */// Subject imported before Observable to bypass circular dependency issue since
  // Subject extends Observable and Observable references Subject in it's
  // definition
  var Subject_1=__webpack_require__(6);exports.Subject=Subject_1.Subject;exports.AnonymousSubject=Subject_1.AnonymousSubject;/* tslint:enable:no-unused-variable */var Observable_1=__webpack_require__(0);exports.Observable=Observable_1.Observable;// statics
  /* tslint:disable:no-use-before-declare */__webpack_require__(161);__webpack_require__(164);__webpack_require__(167);__webpack_require__(170);__webpack_require__(173);__webpack_require__(176);__webpack_require__(178);__webpack_require__(181);__webpack_require__(182);__webpack_require__(185);__webpack_require__(188);__webpack_require__(190);__webpack_require__(193);__webpack_require__(196);__webpack_require__(201);__webpack_require__(202);__webpack_require__(203);__webpack_require__(206);__webpack_require__(207);__webpack_require__(209);__webpack_require__(212);__webpack_require__(215);__webpack_require__(218);__webpack_require__(221);__webpack_require__(223);//dom
  __webpack_require__(225);__webpack_require__(227);//operators
  __webpack_require__(233);__webpack_require__(235);__webpack_require__(237);__webpack_require__(239);__webpack_require__(241);__webpack_require__(243);__webpack_require__(245);__webpack_require__(247);__webpack_require__(249);__webpack_require__(251);__webpack_require__(253);__webpack_require__(255);__webpack_require__(257);__webpack_require__(259);__webpack_require__(261);__webpack_require__(263);__webpack_require__(265);__webpack_require__(267);__webpack_require__(269);__webpack_require__(271);__webpack_require__(274);__webpack_require__(276);__webpack_require__(278);__webpack_require__(280);__webpack_require__(282);__webpack_require__(284);__webpack_require__(286);__webpack_require__(288);__webpack_require__(290);__webpack_require__(292);__webpack_require__(294);__webpack_require__(296);__webpack_require__(298);__webpack_require__(303);__webpack_require__(305);__webpack_require__(307);__webpack_require__(309);__webpack_require__(311);__webpack_require__(313);__webpack_require__(315);__webpack_require__(317);__webpack_require__(319);__webpack_require__(321);__webpack_require__(323);__webpack_require__(325);__webpack_require__(327);__webpack_require__(329);__webpack_require__(331);__webpack_require__(333);__webpack_require__(335);__webpack_require__(337);__webpack_require__(339);__webpack_require__(341);__webpack_require__(343);__webpack_require__(345);__webpack_require__(348);__webpack_require__(350);__webpack_require__(352);__webpack_require__(354);__webpack_require__(356);__webpack_require__(358);__webpack_require__(360);__webpack_require__(362);__webpack_require__(364);__webpack_require__(366);__webpack_require__(368);__webpack_require__(370);__webpack_require__(372);__webpack_require__(374);__webpack_require__(376);__webpack_require__(378);__webpack_require__(380);__webpack_require__(382);__webpack_require__(384);__webpack_require__(386);__webpack_require__(388);__webpack_require__(390);__webpack_require__(392);__webpack_require__(394);__webpack_require__(403);__webpack_require__(405);__webpack_require__(407);__webpack_require__(409);__webpack_require__(411);__webpack_require__(413);__webpack_require__(415);__webpack_require__(417);__webpack_require__(419);__webpack_require__(421);__webpack_require__(422);__webpack_require__(424);__webpack_require__(426);__webpack_require__(428);__webpack_require__(430);__webpack_require__(431);__webpack_require__(433);__webpack_require__(435);__webpack_require__(437);__webpack_require__(439);__webpack_require__(441);__webpack_require__(443);__webpack_require__(445);/* tslint:disable:no-unused-variable */var Subscription_1=__webpack_require__(5);exports.Subscription=Subscription_1.Subscription;var Subscriber_1=__webpack_require__(1);exports.Subscriber=Subscriber_1.Subscriber;var AsyncSubject_1=__webpack_require__(29);exports.AsyncSubject=AsyncSubject_1.AsyncSubject;var ReplaySubject_1=__webpack_require__(36);exports.ReplaySubject=ReplaySubject_1.ReplaySubject;var BehaviorSubject_1=__webpack_require__(116);exports.BehaviorSubject=BehaviorSubject_1.BehaviorSubject;var ConnectableObservable_1=__webpack_require__(110);exports.ConnectableObservable=ConnectableObservable_1.ConnectableObservable;var Notification_1=__webpack_require__(17);exports.Notification=Notification_1.Notification;var EmptyError_1=__webpack_require__(37);exports.EmptyError=EmptyError_1.EmptyError;var ArgumentOutOfRangeError_1=__webpack_require__(23);exports.ArgumentOutOfRangeError=ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;var ObjectUnsubscribedError_1=__webpack_require__(28);exports.ObjectUnsubscribedError=ObjectUnsubscribedError_1.ObjectUnsubscribedError;var TimeoutError_1=__webpack_require__(146);exports.TimeoutError=TimeoutError_1.TimeoutError;var UnsubscriptionError_1=__webpack_require__(59);exports.UnsubscriptionError=UnsubscriptionError_1.UnsubscriptionError;var timeInterval_1=__webpack_require__(143);exports.TimeInterval=timeInterval_1.TimeInterval;var timestamp_1=__webpack_require__(56);exports.Timestamp=timestamp_1.Timestamp;var TestScheduler_1=__webpack_require__(447);exports.TestScheduler=TestScheduler_1.TestScheduler;var VirtualTimeScheduler_1=__webpack_require__(159);exports.VirtualTimeScheduler=VirtualTimeScheduler_1.VirtualTimeScheduler;var AjaxObservable_1=__webpack_require__(70);exports.AjaxResponse=AjaxObservable_1.AjaxResponse;exports.AjaxError=AjaxObservable_1.AjaxError;exports.AjaxTimeoutError=AjaxObservable_1.AjaxTimeoutError;var pipe_1=__webpack_require__(40);exports.pipe=pipe_1.pipe;var asap_1=__webpack_require__(135);var async_1=__webpack_require__(4);var queue_1=__webpack_require__(71);var animationFrame_1=__webpack_require__(450);var rxSubscriber_1=__webpack_require__(26);var iterator_1=__webpack_require__(15);var observable_1=__webpack_require__(27);var _operators=__webpack_require__(454);exports.operators=_operators;/* tslint:enable:no-unused-variable *//**
   * @typedef {Object} Rx.Scheduler
   * @property {Scheduler} queue Schedules on a queue in the current event frame
   * (trampoline scheduler). Use this for iteration operations.
   * @property {Scheduler} asap Schedules on the micro task queue, which uses the
   * fastest transport mechanism available, either Node.js' `process.nextTick()`
   * or Web Worker MessageChannel or setTimeout or others. Use this for
   * asynchronous conversions.
   * @property {Scheduler} async Schedules work with `setInterval`. Use this for
   * time-based operations.
   * @property {Scheduler} animationFrame Schedules work with `requestAnimationFrame`.
   * Use this for synchronizing with the platform's painting
   */var Scheduler={asap:asap_1.asap,queue:queue_1.queue,animationFrame:animationFrame_1.animationFrame,async:async_1.async};exports.Scheduler=Scheduler;/**
   * @typedef {Object} Rx.Symbol
   * @property {Symbol|string} rxSubscriber A symbol to use as a property name to
   * retrieve an "Rx safe" Observer from an object. "Rx safety" can be defined as
   * an object that has all of the traits of an Rx Subscriber, including the
   * ability to add and remove subscriptions to the subscription chain and
   * guarantees involving event triggering (can't "next" after unsubscription,
   * etc).
   * @property {Symbol|string} observable A symbol to use as a property name to
   * retrieve an Observable as defined by the [ECMAScript "Observable" spec](https://github.com/zenparsing/es-observable).
   * @property {Symbol|string} iterator The ES6 symbol to use as a property name
   * to retrieve an iterator from an object.
   */var _Symbol={rxSubscriber:rxSubscriber_1.rxSubscriber,observable:observable_1.observable,iterator:iterator_1.iterator};exports.Symbol=_Symbol;//# sourceMappingURL=Rx.js.map
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var noop_1=__webpack_require__(41);/* tslint:enable:max-line-length */function pipe(){var fns=[];for(var _i=0;_i<arguments.length;_i++){fns[_i-0]=arguments[_i];}return pipeFromArray(fns);}exports.pipe=pipe;/* @internal */function pipeFromArray(fns){if(!fns){return noop_1.noop;}if(fns.length===1){return fns[0];}return function piped(input){return fns.reduce(function(prev,fn){return fn(prev);},input);};}exports.pipeFromArray=pipeFromArray;//# sourceMappingURL=pipe.js.map
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* tslint:disable:no-empty */function noop(){}exports.noop=noop;//# sourceMappingURL=noop.js.map
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var ScalarObservable=function(_super){__extends(ScalarObservable,_super);function ScalarObservable(value,scheduler){_super.call(this);this.value=value;this.scheduler=scheduler;this._isScalar=true;if(scheduler){this._isScalar=false;}}ScalarObservable.create=function(value,scheduler){return new ScalarObservable(value,scheduler);};ScalarObservable.dispatch=function(state){var done=state.done,value=state.value,subscriber=state.subscriber;if(done){subscriber.complete();return;}subscriber.next(value);if(subscriber.closed){return;}state.done=true;this.schedule(state);};ScalarObservable.prototype._subscribe=function(subscriber){var value=this.value;var scheduler=this.scheduler;if(scheduler){return scheduler.schedule(ScalarObservable.dispatch,0,{done:false,value:value,subscriber:subscriber});}else{subscriber.next(value);if(!subscriber.closed){subscriber.complete();}}};return ScalarObservable;}(Observable_1.Observable);exports.ScalarObservable=ScalarObservable;//# sourceMappingURL=ScalarObservable.js.map
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeAll_1=__webpack_require__(32);/**
   * Converts a higher-order Observable into a first-order Observable by
   * concatenating the inner Observables in order.
   *
   * <span class="informal">Flattens an Observable-of-Observables by putting one
   * inner Observable after the other.</span>
   *
   * <img src="./img/concatAll.png" width="100%">
   *
   * Joins every Observable emitted by the source (a higher-order Observable), in
   * a serial fashion. It subscribes to each inner Observable only after the
   * previous inner Observable has completed, and merges all of their values into
   * the returned observable.
   *
   * __Warning:__ If the source Observable emits Observables quickly and
   * endlessly, and the inner Observables it emits generally complete slower than
   * the source emits, you can run into memory issues as the incoming Observables
   * collect in an unbounded buffer.
   *
   * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set
   * to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));
   * var firstOrder = higherOrder.concatAll();
   * firstOrder.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link combineAll}
   * @see {@link concat}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   * @see {@link exhaust}
   * @see {@link mergeAll}
   * @see {@link switch}
   * @see {@link zipAll}
   *
   * @return {Observable} An Observable emitting values from all the inner
   * Observables concatenated.
   * @method concatAll
   * @owner Observable
   */function concatAll(){return mergeAll_1.mergeAll(1);}exports.concatAll=concatAll;//# sourceMappingURL=concatAll.js.map
  
  /***/ }),
  /* 44 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isArray_1=__webpack_require__(11);var ArrayObservable_1=__webpack_require__(12);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);function race(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}// if the only argument is an array, it was most likely called with
  // `race([obs1, obs2, ...])`
  if(observables.length===1){if(isArray_1.isArray(observables[0])){observables=observables[0];}else{return observables[0];}}return new ArrayObservable_1.ArrayObservable(observables).lift(new RaceOperator());}exports.race=race;var RaceOperator=function(){function RaceOperator(){}RaceOperator.prototype.call=function(subscriber,source){return source.subscribe(new RaceSubscriber(subscriber));};return RaceOperator;}();exports.RaceOperator=RaceOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var RaceSubscriber=function(_super){__extends(RaceSubscriber,_super);function RaceSubscriber(destination){_super.call(this,destination);this.hasFirst=false;this.observables=[];this.subscriptions=[];}RaceSubscriber.prototype._next=function(observable){this.observables.push(observable);};RaceSubscriber.prototype._complete=function(){var observables=this.observables;var len=observables.length;if(len===0){this.destination.complete();}else{for(var i=0;i<len&&!this.hasFirst;i++){var observable=observables[i];var subscription=subscribeToResult_1.subscribeToResult(this,observable,observable,i);if(this.subscriptions){this.subscriptions.push(subscription);}this.add(subscription);}this.observables=null;}};RaceSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){if(!this.hasFirst){this.hasFirst=true;for(var i=0;i<this.subscriptions.length;i++){if(i!==outerIndex){var subscription=this.subscriptions[i];subscription.unsubscribe();this.remove(subscription);}}this.subscriptions=null;}this.destination.next(innerValue);};return RaceSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.RaceSubscriber=RaceSubscriber;//# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var FromObservable_1=__webpack_require__(66);var isArray_1=__webpack_require__(11);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
   * that was passed.
   *
   * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span>
   *
   * <img src="./img/onErrorResumeNext.png" width="100%">
   *
   * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as
   * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same
   * as the source.
   *
   * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.
   * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`
   * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting
   * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another
   * Observable in provided series, no matter if previous Observable completed or ended with an error. This will
   * be happening until there is no more Observables left in the series, at which point returned Observable will
   * complete - even if the last subscribed stream ended with an error.
   *
   * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive
   * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable
   * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with
   * an error.
   *
   * Note that you do not get any access to errors emitted by the Observables. In particular do not
   * expect these errors to appear in error callback passed to {@link subscribe}. If you want to take
   * specific actions based on what error was emitted by an Observable, you should try out {@link catch} instead.
   *
   *
   * @example <caption>Subscribe to the next Observable after map fails</caption>
   * Rx.Observable.of(1, 2, 3, 0)
   *   .map(x => {
   *       if (x === 0) { throw Error(); }
           return 10 / x;
   *   })
   *   .onErrorResumeNext(Rx.Observable.of(1, 2, 3))
   *   .subscribe(
   *     val => console.log(val),
   *     err => console.log(err),          // Will never be called.
   *     () => console.log('that\'s it!')
   *   );
   *
   * // Logs:
   * // 10
   * // 5
   * // 3.3333333333333335
   * // 1
   * // 2
   * // 3
   * // "that's it!"
   *
   * @see {@link concat}
   * @see {@link catch}
   *
   * @param {...ObservableInput} observables Observables passed either directly or as an array.
   * @return {Observable} An Observable that emits values from source Observable, but - if it errors - subscribes
   * to the next passed Observable and so on, until it completes or runs out of Observables.
   * @method onErrorResumeNext
   * @owner Observable
   */function onErrorResumeNext(){var nextSources=[];for(var _i=0;_i<arguments.length;_i++){nextSources[_i-0]=arguments[_i];}if(nextSources.length===1&&isArray_1.isArray(nextSources[0])){nextSources=nextSources[0];}return function(source){return source.lift(new OnErrorResumeNextOperator(nextSources));};}exports.onErrorResumeNext=onErrorResumeNext;/* tslint:enable:max-line-length */function onErrorResumeNextStatic(){var nextSources=[];for(var _i=0;_i<arguments.length;_i++){nextSources[_i-0]=arguments[_i];}var source=null;if(nextSources.length===1&&isArray_1.isArray(nextSources[0])){nextSources=nextSources[0];}source=nextSources.shift();return new FromObservable_1.FromObservable(source,null).lift(new OnErrorResumeNextOperator(nextSources));}exports.onErrorResumeNextStatic=onErrorResumeNextStatic;var OnErrorResumeNextOperator=function(){function OnErrorResumeNextOperator(nextSources){this.nextSources=nextSources;}OnErrorResumeNextOperator.prototype.call=function(subscriber,source){return source.subscribe(new OnErrorResumeNextSubscriber(subscriber,this.nextSources));};return OnErrorResumeNextOperator;}();var OnErrorResumeNextSubscriber=function(_super){__extends(OnErrorResumeNextSubscriber,_super);function OnErrorResumeNextSubscriber(destination,nextSources){_super.call(this,destination);this.destination=destination;this.nextSources=nextSources;}OnErrorResumeNextSubscriber.prototype.notifyError=function(error,innerSub){this.subscribeToNextSource();};OnErrorResumeNextSubscriber.prototype.notifyComplete=function(innerSub){this.subscribeToNextSource();};OnErrorResumeNextSubscriber.prototype._error=function(err){this.subscribeToNextSource();};OnErrorResumeNextSubscriber.prototype._complete=function(){this.subscribeToNextSource();};OnErrorResumeNextSubscriber.prototype.subscribeToNextSource=function(){var next=this.nextSources.shift();if(next){this.add(subscribeToResult_1.subscribeToResult(this,next));}else{this.destination.complete();}};return OnErrorResumeNextSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 46 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeMap_1=__webpack_require__(18);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable, in a serialized fashion waiting for each one to complete before
   * merging the next.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link concatAll}.</span>
   *
   * <img src="./img/concatMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. Each new inner Observable is
   * concatenated with the previous inner Observable.
   *
   * __Warning:__ if source values arrive endlessly and faster than their
   * corresponding inner Observables can complete, it will result in memory issues
   * as inner Observables amass in an unbounded buffer waiting for their turn to
   * be subscribed to.
   *
   * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set
   * to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link concat}
   * @see {@link concatAll}
   * @see {@link concatMapTo}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking values from each projected inner
   * Observable sequentially.
   * @method concatMap
   * @owner Observable
   */function concatMap(project,resultSelector){return mergeMap_1.mergeMap(project,resultSelector,1);}exports.concatMap=concatMap;//# sourceMappingURL=concatMap.js.map
  
  /***/ }),
  /* 47 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/* tslint:enable:max-line-length *//**
   * Emits a given value if the source Observable completes without emitting any
   * `next` value, otherwise mirrors the source Observable.
   *
   * <span class="informal">If the source Observable turns out to be empty, then
   * this operator will emit a default value.</span>
   *
   * <img src="./img/defaultIfEmpty.png" width="100%">
   *
   * `defaultIfEmpty` emits the values emitted by the source Observable or a
   * specified default value if the source Observable is empty (completes without
   * having emitted any `next` value).
   *
   * @example <caption>If no clicks happen in 5 seconds, then emit "no clicks"</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var clicksBeforeFive = clicks.takeUntil(Rx.Observable.interval(5000));
   * var result = clicksBeforeFive.defaultIfEmpty('no clicks');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link empty}
   * @see {@link last}
   *
   * @param {any} [defaultValue=null] The default value used if the source
   * Observable is empty.
   * @return {Observable} An Observable that emits either the specified
   * `defaultValue` if the source Observable emits no items, or the values emitted
   * by the source Observable.
   * @method defaultIfEmpty
   * @owner Observable
   */function defaultIfEmpty(defaultValue){if(defaultValue===void 0){defaultValue=null;}return function(source){return source.lift(new DefaultIfEmptyOperator(defaultValue));};}exports.defaultIfEmpty=defaultIfEmpty;var DefaultIfEmptyOperator=function(){function DefaultIfEmptyOperator(defaultValue){this.defaultValue=defaultValue;}DefaultIfEmptyOperator.prototype.call=function(subscriber,source){return source.subscribe(new DefaultIfEmptySubscriber(subscriber,this.defaultValue));};return DefaultIfEmptyOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DefaultIfEmptySubscriber=function(_super){__extends(DefaultIfEmptySubscriber,_super);function DefaultIfEmptySubscriber(destination,defaultValue){_super.call(this,destination);this.defaultValue=defaultValue;this.isEmpty=true;}DefaultIfEmptySubscriber.prototype._next=function(value){this.isEmpty=false;this.destination.next(value);};DefaultIfEmptySubscriber.prototype._complete=function(){if(this.isEmpty){this.destination.next(this.defaultValue);}this.destination.complete();};return DefaultIfEmptySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=defaultIfEmpty.js.map
  
  /***/ }),
  /* 48 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.
   *
   * 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.
   *
   * If a comparator function is not provided, an equality check is used by default.
   *
   * @example <caption>A simple example with numbers</caption>
   * Observable.of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4)
   *   .distinctUntilChanged()
   *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4
   *
   * @example <caption>An example using a compare function</caption>
   * interface Person {
   *    age: number,
   *    name: string
   * }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'})
   *     { age: 6, name: 'Foo'})
   *     .distinctUntilChanged((p: Person, q: Person) => p.name === q.name)
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo' }
   *
   * @see {@link distinct}
   * @see {@link distinctUntilKeyChanged}
   *
   * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values.
   * @method distinctUntilChanged
   * @owner Observable
   */function distinctUntilChanged(compare,keySelector){return function(source){return source.lift(new DistinctUntilChangedOperator(compare,keySelector));};}exports.distinctUntilChanged=distinctUntilChanged;var DistinctUntilChangedOperator=function(){function DistinctUntilChangedOperator(compare,keySelector){this.compare=compare;this.keySelector=keySelector;}DistinctUntilChangedOperator.prototype.call=function(subscriber,source){return source.subscribe(new DistinctUntilChangedSubscriber(subscriber,this.compare,this.keySelector));};return DistinctUntilChangedOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DistinctUntilChangedSubscriber=function(_super){__extends(DistinctUntilChangedSubscriber,_super);function DistinctUntilChangedSubscriber(destination,compare,keySelector){_super.call(this,destination);this.keySelector=keySelector;this.hasKey=false;if(typeof compare==='function'){this.compare=compare;}}DistinctUntilChangedSubscriber.prototype.compare=function(x,y){return x===y;};DistinctUntilChangedSubscriber.prototype._next=function(value){var keySelector=this.keySelector;var key=value;if(keySelector){key=tryCatch_1.tryCatch(this.keySelector)(value);if(key===errorObject_1.errorObject){return this.destination.error(errorObject_1.errorObject.e);}}var result=false;if(this.hasKey){result=tryCatch_1.tryCatch(this.compare)(this.key,key);if(result===errorObject_1.errorObject){return this.destination.error(errorObject_1.errorObject.e);}}else{this.hasKey=true;}if(Boolean(result)===false){this.key=key;this.destination.next(value);}};return DistinctUntilChangedSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=distinctUntilChanged.js.map
  
  /***/ }),
  /* 49 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/* tslint:enable:max-line-length *//**
   * Filter items emitted by the source Observable by only emitting those that
   * satisfy a specified predicate.
   *
   * <span class="informal">Like
   * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
   * it only emits a value from the source if it passes a criterion function.</span>
   *
   * <img src="./img/filter.png" width="100%">
   *
   * Similar to the well-known `Array.prototype.filter` method, this operator
   * takes values from the source Observable, passes them through a `predicate`
   * function and only emits those values that yielded `true`.
   *
   * @example <caption>Emit only click events whose target was a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');
   * clicksOnDivs.subscribe(x => console.log(x));
   *
   * @see {@link distinct}
   * @see {@link distinctUntilChanged}
   * @see {@link distinctUntilKeyChanged}
   * @see {@link ignoreElements}
   * @see {@link partition}
   * @see {@link skip}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates each value emitted by the source Observable. If it returns `true`,
   * the value is emitted, if `false` the value is not passed to the output
   * Observable. The `index` parameter is the number `i` for the i-th source
   * emission that has happened since the subscription, starting from the number
   * `0`.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable} An Observable of values from the source that were
   * allowed by the `predicate` function.
   * @method filter
   * @owner Observable
   */function filter(predicate,thisArg){return function filterOperatorFunction(source){return source.lift(new FilterOperator(predicate,thisArg));};}exports.filter=filter;var FilterOperator=function(){function FilterOperator(predicate,thisArg){this.predicate=predicate;this.thisArg=thisArg;}FilterOperator.prototype.call=function(subscriber,source){return source.subscribe(new FilterSubscriber(subscriber,this.predicate,this.thisArg));};return FilterOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var FilterSubscriber=function(_super){__extends(FilterSubscriber,_super);function FilterSubscriber(destination,predicate,thisArg){_super.call(this,destination);this.predicate=predicate;this.thisArg=thisArg;this.count=0;}// the try catch block below is left specifically for
  // optimization and perf reasons. a tryCatcher is not necessary here.
  FilterSubscriber.prototype._next=function(value){var result;try{result=this.predicate.call(this.thisArg,value,this.count++);}catch(err){this.destination.error(err);return;}if(result){this.destination.next(value);}};return FilterSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=filter.js.map
  
  /***/ }),
  /* 50 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Emits only the first value emitted by the source Observable that meets some
   * condition.
   *
   * <span class="informal">Finds the first value that passes some test and emits
   * that.</span>
   *
   * <img src="./img/find.png" width="100%">
   *
   * `find` searches for the first item in the source Observable that matches the
   * specified condition embodied by the `predicate`, and returns the first
   * occurrence in the source. Unlike {@link first}, the `predicate` is required
   * in `find`, and does not emit an error if a valid value is not found.
   *
   * @example <caption>Find and emit the first click that happens on a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.find(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link first}
   * @see {@link findIndex}
   * @see {@link take}
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
   * A function called with each item to test for condition matching.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable<T>} An Observable of the first item that matches the
   * condition.
   * @method find
   * @owner Observable
   */function find(predicate,thisArg){if(typeof predicate!=='function'){throw new TypeError('predicate is not a function');}return function(source){return source.lift(new FindValueOperator(predicate,source,false,thisArg));};}exports.find=find;var FindValueOperator=function(){function FindValueOperator(predicate,source,yieldIndex,thisArg){this.predicate=predicate;this.source=source;this.yieldIndex=yieldIndex;this.thisArg=thisArg;}FindValueOperator.prototype.call=function(observer,source){return source.subscribe(new FindValueSubscriber(observer,this.predicate,this.source,this.yieldIndex,this.thisArg));};return FindValueOperator;}();exports.FindValueOperator=FindValueOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var FindValueSubscriber=function(_super){__extends(FindValueSubscriber,_super);function FindValueSubscriber(destination,predicate,source,yieldIndex,thisArg){_super.call(this,destination);this.predicate=predicate;this.source=source;this.yieldIndex=yieldIndex;this.thisArg=thisArg;this.index=0;}FindValueSubscriber.prototype.notifyComplete=function(value){var destination=this.destination;destination.next(value);destination.complete();};FindValueSubscriber.prototype._next=function(value){var _a=this,predicate=_a.predicate,thisArg=_a.thisArg;var index=this.index++;try{var result=predicate.call(thisArg||this,value,index,this.source);if(result){this.notifyComplete(this.yieldIndex?index:value);}}catch(err){this.destination.error(err);}};FindValueSubscriber.prototype._complete=function(){this.notifyComplete(this.yieldIndex?-1:undefined);};return FindValueSubscriber;}(Subscriber_1.Subscriber);exports.FindValueSubscriber=FindValueSubscriber;//# sourceMappingURL=find.js.map
  
  /***/ }),
  /* 51 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Ignores source values for a duration determined by another Observable, then
   * emits the most recent value from the source Observable, then repeats this
   * process.
   *
   * <span class="informal">It's like {@link auditTime}, but the silencing
   * duration is determined by a second Observable.</span>
   *
   * <img src="./img/audit.png" width="100%">
   *
   * `audit` is similar to `throttle`, but emits the last value from the silenced
   * time window, instead of the first value. `audit` emits the most recent value
   * from the source Observable on the output Observable as soon as its internal
   * timer becomes disabled, and ignores source values while the timer is enabled.
   * Initially, the timer is disabled. As soon as the first source value arrives,
   * the timer is enabled by calling the `durationSelector` function with the
   * source value, which returns the "duration" Observable. When the duration
   * Observable emits a value or completes, the timer is disabled, then the most
   * recent source value is emitted on the output Observable, and this process
   * repeats for the next source value.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.audit(ev => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounce}
   * @see {@link delayWhen}
   * @see {@link sample}
   * @see {@link throttle}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the silencing
   * duration, returned as an Observable or a Promise.
   * @return {Observable<T>} An Observable that performs rate-limiting of
   * emissions from the source Observable.
   * @method audit
   * @owner Observable
   */function audit(durationSelector){return function auditOperatorFunction(source){return source.lift(new AuditOperator(durationSelector));};}exports.audit=audit;var AuditOperator=function(){function AuditOperator(durationSelector){this.durationSelector=durationSelector;}AuditOperator.prototype.call=function(subscriber,source){return source.subscribe(new AuditSubscriber(subscriber,this.durationSelector));};return AuditOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var AuditSubscriber=function(_super){__extends(AuditSubscriber,_super);function AuditSubscriber(destination,durationSelector){_super.call(this,destination);this.durationSelector=durationSelector;this.hasValue=false;}AuditSubscriber.prototype._next=function(value){this.value=value;this.hasValue=true;if(!this.throttled){var duration=tryCatch_1.tryCatch(this.durationSelector)(value);if(duration===errorObject_1.errorObject){this.destination.error(errorObject_1.errorObject.e);}else{var innerSubscription=subscribeToResult_1.subscribeToResult(this,duration);if(innerSubscription.closed){this.clearThrottle();}else{this.add(this.throttled=innerSubscription);}}}};AuditSubscriber.prototype.clearThrottle=function(){var _a=this,value=_a.value,hasValue=_a.hasValue,throttled=_a.throttled;if(throttled){this.remove(throttled);this.throttled=null;throttled.unsubscribe();}if(hasValue){this.value=null;this.hasValue=false;this.destination.next(value);}};AuditSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex){this.clearThrottle();};AuditSubscriber.prototype.notifyComplete=function(){this.clearThrottle();};return AuditSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=audit.js.map
  
  /***/ }),
  /* 52 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/* tslint:enable:max-line-length *//**
   * Applies an accumulator function over the source Observable, and returns each
   * intermediate result, with an optional seed value.
   *
   * <span class="informal">It's like {@link reduce}, but emits the current
   * accumulation whenever the source emits a value.</span>
   *
   * <img src="./img/scan.png" width="100%">
   *
   * Combines together all values emitted on the source, using an accumulator
   * function that knows how to join a new source value into the accumulation from
   * the past. Is similar to {@link reduce}, but emits the intermediate
   * accumulations.
   *
   * Returns an Observable that applies a specified `accumulator` function to each
   * item emitted by the source Observable. If a `seed` value is specified, then
   * that value will be used as the initial value for the accumulator. If no seed
   * value is specified, the first item of the source is used as the seed.
   *
   * @example <caption>Count the number of click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var ones = clicks.mapTo(1);
   * var seed = 0;
   * var count = ones.scan((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link reduce}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator
   * The accumulator function called on each source value.
   * @param {T|R} [seed] The initial accumulation value.
   * @return {Observable<R>} An observable of the accumulated values.
   * @method scan
   * @owner Observable
   */function scan(accumulator,seed){var hasSeed=false;// providing a seed of `undefined` *should* be valid and trigger
  // hasSeed! so don't use `seed !== undefined` checks!
  // For this reason, we have to check it here at the original call site
  // otherwise inside Operator/Subscriber we won't know if `undefined`
  // means they didn't provide anything or if they literally provided `undefined`
  if(arguments.length>=2){hasSeed=true;}return function scanOperatorFunction(source){return source.lift(new ScanOperator(accumulator,seed,hasSeed));};}exports.scan=scan;var ScanOperator=function(){function ScanOperator(accumulator,seed,hasSeed){if(hasSeed===void 0){hasSeed=false;}this.accumulator=accumulator;this.seed=seed;this.hasSeed=hasSeed;}ScanOperator.prototype.call=function(subscriber,source){return source.subscribe(new ScanSubscriber(subscriber,this.accumulator,this.seed,this.hasSeed));};return ScanOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ScanSubscriber=function(_super){__extends(ScanSubscriber,_super);function ScanSubscriber(destination,accumulator,_seed,hasSeed){_super.call(this,destination);this.accumulator=accumulator;this._seed=_seed;this.hasSeed=hasSeed;this.index=0;}Object.defineProperty(ScanSubscriber.prototype,"seed",{get:function get(){return this._seed;},set:function set(value){this.hasSeed=true;this._seed=value;},enumerable:true,configurable:true});ScanSubscriber.prototype._next=function(value){if(!this.hasSeed){this.seed=value;this.destination.next(value);}else{return this._tryNext(value);}};ScanSubscriber.prototype._tryNext=function(value){var index=this.index++;var result;try{result=this.accumulator(this.seed,value,index);}catch(err){this.destination.error(err);}this.seed=result;this.destination.next(result);};return ScanSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=scan.js.map
  
  /***/ }),
  /* 53 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var ArgumentOutOfRangeError_1=__webpack_require__(23);var EmptyObservable_1=__webpack_require__(13);/**
   * Emits only the last `count` values emitted by the source Observable.
   *
   * <span class="informal">Remembers the latest `count` values, then emits those
   * only when the source completes.</span>
   *
   * <img src="./img/takeLast.png" width="100%">
   *
   * `takeLast` returns an Observable that emits at most the last `count` values
   * emitted by the source Observable. If the source emits fewer than `count`
   * values then all of its values are emitted. This operator must wait until the
   * `complete` notification emission from the source in order to emit the `next`
   * values on the output Observable, because otherwise it is impossible to know
   * whether or not more values will be emitted on the source. For this reason,
   * all values are emitted synchronously, followed by the complete notification.
   *
   * @example <caption>Take the last 3 values of an Observable with many values</caption>
   * var many = Rx.Observable.range(1, 100);
   * var lastThree = many.takeLast(3);
   * lastThree.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `takeLast(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of values to emit from the end of
   * the sequence of values emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits at most the last count
   * values emitted by the source Observable.
   * @method takeLast
   * @owner Observable
   */function takeLast(count){return function takeLastOperatorFunction(source){if(count===0){return new EmptyObservable_1.EmptyObservable();}else{return source.lift(new TakeLastOperator(count));}};}exports.takeLast=takeLast;var TakeLastOperator=function(){function TakeLastOperator(total){this.total=total;if(this.total<0){throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError();}}TakeLastOperator.prototype.call=function(subscriber,source){return source.subscribe(new TakeLastSubscriber(subscriber,this.total));};return TakeLastOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TakeLastSubscriber=function(_super){__extends(TakeLastSubscriber,_super);function TakeLastSubscriber(destination,total){_super.call(this,destination);this.total=total;this.ring=new Array();this.count=0;}TakeLastSubscriber.prototype._next=function(value){var ring=this.ring;var total=this.total;var count=this.count++;if(ring.length<total){ring.push(value);}else{var index=count%total;ring[index]=value;}};TakeLastSubscriber.prototype._complete=function(){var destination=this.destination;var count=this.count;if(count>0){var total=this.count>=this.total?this.total:this.count;var ring=this.ring;for(var i=0;i<total;i++){var idx=count++%total;destination.next(ring[idx]);}}destination.complete();};return TakeLastSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=takeLast.js.map
  
  /***/ }),
  /* 54 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);function refCount(){return function refCountOperatorFunction(source){return source.lift(new RefCountOperator(source));};}exports.refCount=refCount;var RefCountOperator=function(){function RefCountOperator(connectable){this.connectable=connectable;}RefCountOperator.prototype.call=function(subscriber,source){var connectable=this.connectable;connectable._refCount++;var refCounter=new RefCountSubscriber(subscriber,connectable);var subscription=source.subscribe(refCounter);if(!refCounter.closed){refCounter.connection=connectable.connect();}return subscription;};return RefCountOperator;}();var RefCountSubscriber=function(_super){__extends(RefCountSubscriber,_super);function RefCountSubscriber(destination,connectable){_super.call(this,destination);this.connectable=connectable;}RefCountSubscriber.prototype._unsubscribe=function(){var connectable=this.connectable;if(!connectable){this.connection=null;return;}this.connectable=null;var refCount=connectable._refCount;if(refCount<=0){this.connection=null;return;}connectable._refCount=refCount-1;if(refCount>1){this.connection=null;return;}///
  // Compare the local RefCountSubscriber's connection Subscription to the
  // connection Subscription on the shared ConnectableObservable. In cases
  // where the ConnectableObservable source synchronously emits values, and
  // the RefCountSubscriber's downstream Observers synchronously unsubscribe,
  // execution continues to here before the RefCountOperator has a chance to
  // supply the RefCountSubscriber with the shared connection Subscription.
  // For example:
  // ```
  // Observable.range(0, 10)
  //   .publish()
  //   .refCount()
  //   .take(5)
  //   .subscribe();
  // ```
  // In order to account for this case, RefCountSubscriber should only dispose
  // the ConnectableObservable's shared connection Subscription if the
  // connection Subscription exists, *and* either:
  //   a. RefCountSubscriber doesn't have a reference to the shared connection
  //      Subscription yet, or,
  //   b. RefCountSubscriber's connection Subscription reference is identical
  //      to the shared connection Subscription
  ///
  var connection=this.connection;var sharedConnection=connectable._connection;this.connection=null;if(sharedConnection&&(!connection||sharedConnection===connection)){sharedConnection.unsubscribe();}};return RefCountSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=refCount.js.map
  
  /***/ }),
  /* 55 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable, emitting values only from the most recently projected Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link switch}.</span>
   *
   * <img src="./img/switchMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. Each time it observes one of these
   * inner Observables, the output Observable begins emitting the items emitted by
   * that inner Observable. When a new inner Observable is emitted, `switchMap`
   * stops emitting items from the earlier-emitted inner Observable and begins
   * emitting items from the new one. It continues to behave like this for
   * subsequent inner Observables.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switch}
   * @see {@link switchMapTo}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking only the values from the most recently
   * projected inner Observable.
   * @method switchMap
   * @owner Observable
   */function switchMap(project,resultSelector){return function switchMapOperatorFunction(source){return source.lift(new SwitchMapOperator(project,resultSelector));};}exports.switchMap=switchMap;var SwitchMapOperator=function(){function SwitchMapOperator(project,resultSelector){this.project=project;this.resultSelector=resultSelector;}SwitchMapOperator.prototype.call=function(subscriber,source){return source.subscribe(new SwitchMapSubscriber(subscriber,this.project,this.resultSelector));};return SwitchMapOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SwitchMapSubscriber=function(_super){__extends(SwitchMapSubscriber,_super);function SwitchMapSubscriber(destination,project,resultSelector){_super.call(this,destination);this.project=project;this.resultSelector=resultSelector;this.index=0;}SwitchMapSubscriber.prototype._next=function(value){var result;var index=this.index++;try{result=this.project(value,index);}catch(error){this.destination.error(error);return;}this._innerSub(result,value,index);};SwitchMapSubscriber.prototype._innerSub=function(result,value,index){var innerSubscription=this.innerSubscription;if(innerSubscription){innerSubscription.unsubscribe();}this.add(this.innerSubscription=subscribeToResult_1.subscribeToResult(this,result,value,index));};SwitchMapSubscriber.prototype._complete=function(){var innerSubscription=this.innerSubscription;if(!innerSubscription||innerSubscription.closed){_super.prototype._complete.call(this);}};SwitchMapSubscriber.prototype._unsubscribe=function(){this.innerSubscription=null;};SwitchMapSubscriber.prototype.notifyComplete=function(innerSub){this.remove(innerSub);this.innerSubscription=null;if(this.isStopped){_super.prototype._complete.call(this);}};SwitchMapSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){if(this.resultSelector){this._tryNotifyNext(outerValue,innerValue,outerIndex,innerIndex);}else{this.destination.next(innerValue);}};SwitchMapSubscriber.prototype._tryNotifyNext=function(outerValue,innerValue,outerIndex,innerIndex){var result;try{result=this.resultSelector(outerValue,innerValue,outerIndex,innerIndex);}catch(err){this.destination.error(err);return;}this.destination.next(result);};return SwitchMapSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  /* 56 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var map_1=__webpack_require__(22);/**
   * @param scheduler
   * @return {Observable<Timestamp<any>>|WebSocketSubject<T>|Observable<T>}
   * @method timestamp
   * @owner Observable
   */function timestamp(scheduler){if(scheduler===void 0){scheduler=async_1.async;}return map_1.map(function(value){return new Timestamp(value,scheduler.now());});// return (source: Observable<T>) => source.lift(new TimestampOperator(scheduler));
  }exports.timestamp=timestamp;var Timestamp=function(){function Timestamp(value,timestamp){this.value=value;this.timestamp=timestamp;}return Timestamp;}();exports.Timestamp=Timestamp;;//# sourceMappingURL=timestamp.js.map
  
  /***/ }),
  /* 57 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};var g;// This works in non-strict mode
  g=function(){return this;}();try{// This works if eval is allowed (see CSP)
  g=g||Function("return this")()||(1,eval)("this");}catch(e){// This works if the window reference is available
  if((typeof window==="undefined"?"undefined":_typeof(window))==="object")g=window;}// g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  module.exports=g;
  
  /***/ }),
  /* 58 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};function isObject(x){return x!=null&&(typeof x==="undefined"?"undefined":_typeof(x))==='object';}exports.isObject=isObject;//# sourceMappingURL=isObject.js.map
  
  /***/ }),
  /* 59 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};/**
   * An error thrown when one or more errors have occurred during the
   * `unsubscribe` of a {@link Subscription}.
   */var UnsubscriptionError=function(_super){__extends(UnsubscriptionError,_super);function UnsubscriptionError(errors){_super.call(this);this.errors=errors;var err=Error.call(this,errors?errors.length+" errors occurred during unsubscription:\n  "+errors.map(function(err,i){return i+1+") "+err.toString();}).join('\n  '):'');this.name=err.name='UnsubscriptionError';this.stack=err.stack;this.message=err.message;}return UnsubscriptionError;}(Error);exports.UnsubscriptionError=UnsubscriptionError;//# sourceMappingURL=UnsubscriptionError.js.map
  
  /***/ }),
  /* 60 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  exports.empty={closed:true,next:function next(value){},error:function error(err){throw err;},complete:function complete(){}};//# sourceMappingURL=Observer.js.map
  
  /***/ }),
  /* 61 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscription_1=__webpack_require__(5);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SubjectSubscription=function(_super){__extends(SubjectSubscription,_super);function SubjectSubscription(subject,subscriber){_super.call(this);this.subject=subject;this.subscriber=subscriber;this.closed=false;}SubjectSubscription.prototype.unsubscribe=function(){if(this.closed){return;}this.closed=true;var subject=this.subject;var observers=subject.observers;this.subject=null;if(!observers||observers.length===0||subject.isStopped||subject.closed){return;}var subscriberIndex=observers.indexOf(this.subscriber);if(subscriberIndex!==-1){observers.splice(subscriberIndex,1);}};return SubjectSubscription;}(Subscription_1.Subscription);exports.SubjectSubscription=SubjectSubscription;//# sourceMappingURL=SubjectSubscription.js.map
  
  /***/ }),
  /* 62 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  exports.isArrayLike=function(x){return x&&typeof x.length==='number';};//# sourceMappingURL=isArrayLike.js.map
  
  /***/ }),
  /* 63 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function isPromise(value){return value&&typeof value.subscribe!=='function'&&typeof value.then==='function';}exports.isPromise=isPromise;//# sourceMappingURL=isPromise.js.map
  
  /***/ }),
  /* 64 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ArrayObservable_1=__webpack_require__(12);exports.of=ArrayObservable_1.ArrayObservable.of;//# sourceMappingURL=of.js.map
  
  /***/ }),
  /* 65 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var FromObservable_1=__webpack_require__(66);exports.from=FromObservable_1.FromObservable.create;//# sourceMappingURL=from.js.map
  
  /***/ }),
  /* 66 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isArray_1=__webpack_require__(11);var isArrayLike_1=__webpack_require__(62);var isPromise_1=__webpack_require__(63);var PromiseObservable_1=__webpack_require__(67);var IteratorObservable_1=__webpack_require__(171);var ArrayObservable_1=__webpack_require__(12);var ArrayLikeObservable_1=__webpack_require__(172);var iterator_1=__webpack_require__(15);var Observable_1=__webpack_require__(0);var observeOn_1=__webpack_require__(31);var observable_1=__webpack_require__(27);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var FromObservable=function(_super){__extends(FromObservable,_super);function FromObservable(ish,scheduler){_super.call(this,null);this.ish=ish;this.scheduler=scheduler;}/**
       * Creates an Observable from an Array, an array-like object, a Promise, an
       * iterable object, or an Observable-like object.
       *
       * <span class="informal">Converts almost anything to an Observable.</span>
       *
       * <img src="./img/from.png" width="100%">
       *
       * Convert various other objects and data types into Observables. `from`
       * converts a Promise or an array-like or an
       * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
       * object into an Observable that emits the items in that promise or array or
       * iterable. A String, in this context, is treated as an array of characters.
       * Observable-like objects (contains a function named with the ES2015 Symbol
       * for Observable) can also be converted through this operator.
       *
       * @example <caption>Converts an array to an Observable</caption>
       * var array = [10, 20, 30];
       * var result = Rx.Observable.from(array);
       * result.subscribe(x => console.log(x));
       *
       * // Results in the following:
       * // 10 20 30
       *
       * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>
       * function* generateDoubles(seed) {
       *   var i = seed;
       *   while (true) {
       *     yield i;
       *     i = 2 * i; // double it
       *   }
       * }
       *
       * var iterator = generateDoubles(3);
       * var result = Rx.Observable.from(iterator).take(10);
       * result.subscribe(x => console.log(x));
       *
       * // Results in the following:
       * // 3 6 12 24 48 96 192 384 768 1536
       *
       * @see {@link create}
       * @see {@link fromEvent}
       * @see {@link fromEventPattern}
       * @see {@link fromPromise}
       *
       * @param {ObservableInput<T>} ish A subscribable object, a Promise, an
       * Observable-like, an Array, an iterable or an array-like object to be
       * converted.
       * @param {Scheduler} [scheduler] The scheduler on which to schedule the
       * emissions of values.
       * @return {Observable<T>} The Observable whose values are originally from the
       * input object that was converted.
       * @static true
       * @name from
       * @owner Observable
       */FromObservable.create=function(ish,scheduler){if(ish!=null){if(typeof ish[observable_1.observable]==='function'){if(ish instanceof Observable_1.Observable&&!scheduler){return ish;}return new FromObservable(ish,scheduler);}else if(isArray_1.isArray(ish)){return new ArrayObservable_1.ArrayObservable(ish,scheduler);}else if(isPromise_1.isPromise(ish)){return new PromiseObservable_1.PromiseObservable(ish,scheduler);}else if(typeof ish[iterator_1.iterator]==='function'||typeof ish==='string'){return new IteratorObservable_1.IteratorObservable(ish,scheduler);}else if(isArrayLike_1.isArrayLike(ish)){return new ArrayLikeObservable_1.ArrayLikeObservable(ish,scheduler);}}throw new TypeError((ish!==null&&(typeof ish==='undefined'?'undefined':_typeof(ish))||ish)+' is not observable');};FromObservable.prototype._subscribe=function(subscriber){var ish=this.ish;var scheduler=this.scheduler;if(scheduler==null){return ish[observable_1.observable]().subscribe(subscriber);}else{return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber,scheduler,0));}};return FromObservable;}(Observable_1.Observable);exports.FromObservable=FromObservable;//# sourceMappingURL=FromObservable.js.map
  
  /***/ }),
  /* 67 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var root_1=__webpack_require__(9);var Observable_1=__webpack_require__(0);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var PromiseObservable=function(_super){__extends(PromiseObservable,_super);function PromiseObservable(promise,scheduler){_super.call(this);this.promise=promise;this.scheduler=scheduler;}/**
       * Converts a Promise to an Observable.
       *
       * <span class="informal">Returns an Observable that just emits the Promise's
       * resolved value, then completes.</span>
       *
       * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an
       * Observable. If the Promise resolves with a value, the output Observable
       * emits that resolved value as a `next`, and then completes. If the Promise
       * is rejected, then the output Observable emits the corresponding Error.
       *
       * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>
       * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       * @see {@link bindCallback}
       * @see {@link from}
       *
       * @param {PromiseLike<T>} promise The promise to be converted.
       * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling
       * the delivery of the resolved value (or the rejection).
       * @return {Observable<T>} An Observable which wraps the Promise.
       * @static true
       * @name fromPromise
       * @owner Observable
       */PromiseObservable.create=function(promise,scheduler){return new PromiseObservable(promise,scheduler);};PromiseObservable.prototype._subscribe=function(subscriber){var _this=this;var promise=this.promise;var scheduler=this.scheduler;if(scheduler==null){if(this._isScalar){if(!subscriber.closed){subscriber.next(this.value);subscriber.complete();}}else{promise.then(function(value){_this.value=value;_this._isScalar=true;if(!subscriber.closed){subscriber.next(value);subscriber.complete();}},function(err){if(!subscriber.closed){subscriber.error(err);}}).then(null,function(err){// escape the promise trap, throw unhandled errors
  root_1.root.setTimeout(function(){throw err;});});}}else{if(this._isScalar){if(!subscriber.closed){return scheduler.schedule(dispatchNext,0,{value:this.value,subscriber:subscriber});}}else{promise.then(function(value){_this.value=value;_this._isScalar=true;if(!subscriber.closed){subscriber.add(scheduler.schedule(dispatchNext,0,{value:value,subscriber:subscriber}));}},function(err){if(!subscriber.closed){subscriber.add(scheduler.schedule(dispatchError,0,{err:err,subscriber:subscriber}));}}).then(null,function(err){// escape the promise trap, throw unhandled errors
  root_1.root.setTimeout(function(){throw err;});});}}};return PromiseObservable;}(Observable_1.Observable);exports.PromiseObservable=PromiseObservable;function dispatchNext(arg){var value=arg.value,subscriber=arg.subscriber;if(!subscriber.closed){subscriber.next(value);subscriber.complete();}}function dispatchError(arg){var err=arg.err,subscriber=arg.subscriber;if(!subscriber.closed){subscriber.error(err);}}//# sourceMappingURL=PromiseObservable.js.map
  
  /***/ }),
  /* 68 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function identity(x){return x;}exports.identity=identity;//# sourceMappingURL=identity.js.map
  
  /***/ }),
  /* 69 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var TimerObservable_1=__webpack_require__(222);exports.timer=TimerObservable_1.TimerObservable.create;//# sourceMappingURL=timer.js.map
  
  /***/ }),
  /* 70 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var root_1=__webpack_require__(9);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var Observable_1=__webpack_require__(0);var Subscriber_1=__webpack_require__(1);var map_1=__webpack_require__(22);function getCORSRequest(){if(root_1.root.XMLHttpRequest){return new root_1.root.XMLHttpRequest();}else if(!!root_1.root.XDomainRequest){return new root_1.root.XDomainRequest();}else{throw new Error('CORS is not supported by your browser');}}function getXMLHttpRequest(){if(root_1.root.XMLHttpRequest){return new root_1.root.XMLHttpRequest();}else{var progId=void 0;try{var progIds=['Msxml2.XMLHTTP','Microsoft.XMLHTTP','Msxml2.XMLHTTP.4.0'];for(var i=0;i<3;i++){try{progId=progIds[i];if(new root_1.root.ActiveXObject(progId)){break;}}catch(e){}}return new root_1.root.ActiveXObject(progId);}catch(e){throw new Error('XMLHttpRequest is not supported by your browser');}}}function ajaxGet(url,headers){if(headers===void 0){headers=null;}return new AjaxObservable({method:'GET',url:url,headers:headers});}exports.ajaxGet=ajaxGet;;function ajaxPost(url,body,headers){return new AjaxObservable({method:'POST',url:url,body:body,headers:headers});}exports.ajaxPost=ajaxPost;;function ajaxDelete(url,headers){return new AjaxObservable({method:'DELETE',url:url,headers:headers});}exports.ajaxDelete=ajaxDelete;;function ajaxPut(url,body,headers){return new AjaxObservable({method:'PUT',url:url,body:body,headers:headers});}exports.ajaxPut=ajaxPut;;function ajaxPatch(url,body,headers){return new AjaxObservable({method:'PATCH',url:url,body:body,headers:headers});}exports.ajaxPatch=ajaxPatch;;var mapResponse=map_1.map(function(x,index){return x.response;});function ajaxGetJSON(url,headers){return mapResponse(new AjaxObservable({method:'GET',url:url,responseType:'json',headers:headers}));}exports.ajaxGetJSON=ajaxGetJSON;;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var AjaxObservable=function(_super){__extends(AjaxObservable,_super);function AjaxObservable(urlOrRequest){_super.call(this);var request={async:true,createXHR:function createXHR(){return this.crossDomain?getCORSRequest.call(this):getXMLHttpRequest();},crossDomain:false,withCredentials:false,headers:{},method:'GET',responseType:'json',timeout:0};if(typeof urlOrRequest==='string'){request.url=urlOrRequest;}else{for(var prop in urlOrRequest){if(urlOrRequest.hasOwnProperty(prop)){request[prop]=urlOrRequest[prop];}}}this.request=request;}AjaxObservable.prototype._subscribe=function(subscriber){return new AjaxSubscriber(subscriber,this.request);};/**
       * Creates an observable for an Ajax request with either a request object with
       * url, headers, etc or a string for a URL.
       *
       * @example
       * source = Rx.Observable.ajax('/products');
       * source = Rx.Observable.ajax({ url: 'products', method: 'GET' });
       *
       * @param {string|Object} request Can be one of the following:
       *   A string of the URL to make the Ajax call.
       *   An object with the following properties
       *   - url: URL of the request
       *   - body: The body of the request
       *   - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE
       *   - async: Whether the request is async
       *   - headers: Optional headers
       *   - crossDomain: true if a cross domain request, else false
       *   - createXHR: a function to override if you need to use an alternate
       *   XMLHttpRequest implementation.
       *   - resultSelector: a function to use to alter the output value type of
       *   the Observable. Gets {@link AjaxResponse} as an argument.
       * @return {Observable} An observable sequence containing the XMLHttpRequest.
       * @static true
       * @name ajax
       * @owner Observable
      */AjaxObservable.create=function(){var create=function create(urlOrRequest){return new AjaxObservable(urlOrRequest);};create.get=ajaxGet;create.post=ajaxPost;create.delete=ajaxDelete;create.put=ajaxPut;create.patch=ajaxPatch;create.getJSON=ajaxGetJSON;return create;}();return AjaxObservable;}(Observable_1.Observable);exports.AjaxObservable=AjaxObservable;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var AjaxSubscriber=function(_super){__extends(AjaxSubscriber,_super);function AjaxSubscriber(destination,request){_super.call(this,destination);this.request=request;this.done=false;var headers=request.headers=request.headers||{};// force CORS if requested
  if(!request.crossDomain&&!headers['X-Requested-With']){headers['X-Requested-With']='XMLHttpRequest';}// ensure content type is set
  if(!('Content-Type'in headers)&&!(root_1.root.FormData&&request.body instanceof root_1.root.FormData)&&typeof request.body!=='undefined'){headers['Content-Type']='application/x-www-form-urlencoded; charset=UTF-8';}// properly serialize body
  request.body=this.serializeBody(request.body,request.headers['Content-Type']);this.send();}AjaxSubscriber.prototype.next=function(e){this.done=true;var _a=this,xhr=_a.xhr,request=_a.request,destination=_a.destination;var response=new AjaxResponse(e,xhr,request);destination.next(response);};AjaxSubscriber.prototype.send=function(){var _a=this,request=_a.request,_b=_a.request,user=_b.user,method=_b.method,url=_b.url,async=_b.async,password=_b.password,headers=_b.headers,body=_b.body;var createXHR=request.createXHR;var xhr=tryCatch_1.tryCatch(createXHR).call(request);if(xhr===errorObject_1.errorObject){this.error(errorObject_1.errorObject.e);}else{this.xhr=xhr;// set up the events before open XHR
  // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest
  // You need to add the event listeners before calling open() on the request.
  // Otherwise the progress events will not fire.
  this.setupEvents(xhr,request);// open XHR
  var result=void 0;if(user){result=tryCatch_1.tryCatch(xhr.open).call(xhr,method,url,async,user,password);}else{result=tryCatch_1.tryCatch(xhr.open).call(xhr,method,url,async);}if(result===errorObject_1.errorObject){this.error(errorObject_1.errorObject.e);return null;}// timeout, responseType and withCredentials can be set once the XHR is open
  if(async){xhr.timeout=request.timeout;xhr.responseType=request.responseType;}if('withCredentials'in xhr){xhr.withCredentials=!!request.withCredentials;}// set headers
  this.setHeaders(xhr,headers);// finally send the request
  result=body?tryCatch_1.tryCatch(xhr.send).call(xhr,body):tryCatch_1.tryCatch(xhr.send).call(xhr);if(result===errorObject_1.errorObject){this.error(errorObject_1.errorObject.e);return null;}}return xhr;};AjaxSubscriber.prototype.serializeBody=function(body,contentType){if(!body||typeof body==='string'){return body;}else if(root_1.root.FormData&&body instanceof root_1.root.FormData){return body;}if(contentType){var splitIndex=contentType.indexOf(';');if(splitIndex!==-1){contentType=contentType.substring(0,splitIndex);}}switch(contentType){case'application/x-www-form-urlencoded':return Object.keys(body).map(function(key){return encodeURI(key)+"="+encodeURI(body[key]);}).join('&');case'application/json':return JSON.stringify(body);default:return body;}};AjaxSubscriber.prototype.setHeaders=function(xhr,headers){for(var key in headers){if(headers.hasOwnProperty(key)){xhr.setRequestHeader(key,headers[key]);}}};AjaxSubscriber.prototype.setupEvents=function(xhr,request){var progressSubscriber=request.progressSubscriber;function xhrTimeout(e){var _a=xhrTimeout,subscriber=_a.subscriber,progressSubscriber=_a.progressSubscriber,request=_a.request;if(progressSubscriber){progressSubscriber.error(e);}subscriber.error(new AjaxTimeoutError(this,request));//TODO: Make betterer.
  };xhr.ontimeout=xhrTimeout;xhrTimeout.request=request;xhrTimeout.subscriber=this;xhrTimeout.progressSubscriber=progressSubscriber;if(xhr.upload&&'withCredentials'in xhr){if(progressSubscriber){var _xhrProgress_;_xhrProgress_=function xhrProgress_1(e){var progressSubscriber=_xhrProgress_.progressSubscriber;progressSubscriber.next(e);};if(root_1.root.XDomainRequest){xhr.onprogress=_xhrProgress_;}else{xhr.upload.onprogress=_xhrProgress_;}_xhrProgress_.progressSubscriber=progressSubscriber;}var _xhrError_;_xhrError_=function xhrError_1(e){var _a=_xhrError_,progressSubscriber=_a.progressSubscriber,subscriber=_a.subscriber,request=_a.request;if(progressSubscriber){progressSubscriber.error(e);}subscriber.error(new AjaxError('ajax error',this,request));};xhr.onerror=_xhrError_;_xhrError_.request=request;_xhrError_.subscriber=this;_xhrError_.progressSubscriber=progressSubscriber;}function xhrReadyStateChange(e){var _a=xhrReadyStateChange,subscriber=_a.subscriber,progressSubscriber=_a.progressSubscriber,request=_a.request;if(this.readyState===4){// normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
  var status_1=this.status===1223?204:this.status;var response=this.responseType==='text'?this.response||this.responseText:this.response;// fix status code when it is 0 (0 status is undocumented).
  // Occurs when accessing file resources or on Android 4.1 stock browser
  // while retrieving files from application cache.
  if(status_1===0){status_1=response?200:0;}if(200<=status_1&&status_1<300){if(progressSubscriber){progressSubscriber.complete();}subscriber.next(e);subscriber.complete();}else{if(progressSubscriber){progressSubscriber.error(e);}subscriber.error(new AjaxError('ajax error '+status_1,this,request));}}};xhr.onreadystatechange=xhrReadyStateChange;xhrReadyStateChange.subscriber=this;xhrReadyStateChange.progressSubscriber=progressSubscriber;xhrReadyStateChange.request=request;};AjaxSubscriber.prototype.unsubscribe=function(){var _a=this,done=_a.done,xhr=_a.xhr;if(!done&&xhr&&xhr.readyState!==4&&typeof xhr.abort==='function'){xhr.abort();}_super.prototype.unsubscribe.call(this);};return AjaxSubscriber;}(Subscriber_1.Subscriber);exports.AjaxSubscriber=AjaxSubscriber;/**
   * A normalized AJAX response.
   *
   * @see {@link ajax}
   *
   * @class AjaxResponse
   */var AjaxResponse=function(){function AjaxResponse(originalEvent,xhr,request){this.originalEvent=originalEvent;this.xhr=xhr;this.request=request;this.status=xhr.status;this.responseType=xhr.responseType||request.responseType;this.response=parseXhrResponse(this.responseType,xhr);}return AjaxResponse;}();exports.AjaxResponse=AjaxResponse;/**
   * A normalized AJAX error.
   *
   * @see {@link ajax}
   *
   * @class AjaxError
   */var AjaxError=function(_super){__extends(AjaxError,_super);function AjaxError(message,xhr,request){_super.call(this,message);this.message=message;this.xhr=xhr;this.request=request;this.status=xhr.status;this.responseType=xhr.responseType||request.responseType;this.response=parseXhrResponse(this.responseType,xhr);}return AjaxError;}(Error);exports.AjaxError=AjaxError;function parseXhrResponse(responseType,xhr){switch(responseType){case'json':if('response'in xhr){//IE does not support json as responseType, parse it internally
  return xhr.responseType?xhr.response:JSON.parse(xhr.response||xhr.responseText||'null');}else{return JSON.parse(xhr.responseText||'null');}case'xml':return xhr.responseXML;case'text':default:return'response'in xhr?xhr.response:xhr.responseText;}}/**
   * @see {@link ajax}
   *
   * @class AjaxTimeoutError
   */var AjaxTimeoutError=function(_super){__extends(AjaxTimeoutError,_super);function AjaxTimeoutError(xhr,request){_super.call(this,'ajax timeout',xhr,request);}return AjaxTimeoutError;}(AjaxError);exports.AjaxTimeoutError=AjaxTimeoutError;//# sourceMappingURL=AjaxObservable.js.map
  
  /***/ }),
  /* 71 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var QueueAction_1=__webpack_require__(230);var QueueScheduler_1=__webpack_require__(231);/**
   *
   * Queue Scheduler
   *
   * <span class="informal">Put every next task on a queue, instead of executing it immediately</span>
   *
   * `queue` scheduler, when used with delay, behaves the same as {@link async} scheduler.
   *
   * When used without delay, it schedules given task synchronously - executes it right when
   * it is scheduled. However when called recursively, that is when inside the scheduled task,
   * another task is scheduled with queue scheduler, instead of executing immediately as well,
   * that task will be put on a queue and wait for current one to finish.
   *
   * This means that when you execute task with `queue` scheduler, you are sure it will end
   * before any other task scheduled with that scheduler will start.
   *
   * @examples <caption>Schedule recursively first, then do something</caption>
   *
   * Rx.Scheduler.queue.schedule(() => {
   *   Rx.Scheduler.queue.schedule(() => console.log('second')); // will not happen now, but will be put on a queue
   *
   *   console.log('first');
   * });
   *
   * // Logs:
   * // "first"
   * // "second"
   *
   *
   * @example <caption>Reschedule itself recursively</caption>
   *
   * Rx.Scheduler.queue.schedule(function(state) {
   *   if (state !== 0) {
   *     console.log('before', state);
   *     this.schedule(state - 1); // `this` references currently executing Action,
   *                               // which we reschedule with new state
   *     console.log('after', state);
   *   }
   * }, 0, 3);
   *
   * // In scheduler that runs recursively, you would expect:
   * // "before", 3
   * // "before", 2
   * // "before", 1
   * // "after", 1
   * // "after", 2
   * // "after", 3
   *
   * // But with queue it logs:
   * // "before", 3
   * // "after", 3
   * // "before", 2
   * // "after", 2
   * // "before", 1
   * // "after", 1
   *
   *
   * @static true
   * @name queue
   * @owner Scheduler
   */exports.queue=new QueueScheduler_1.QueueScheduler(QueueAction_1.QueueAction);//# sourceMappingURL=queue.js.map
  
  /***/ }),
  /* 72 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Buffers the source Observable values until `closingNotifier` emits.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * that array only when another Observable emits.</span>
   *
   * <img src="./img/buffer.png" width="100%">
   *
   * Buffers the incoming Observable values until the given `closingNotifier`
   * Observable emits a value, at which point it emits the buffer on the output
   * Observable and starts a new buffer internally, awaiting the next time
   * `closingNotifier` emits.
   *
   * @example <caption>On every click, emit array of most recent interval events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var interval = Rx.Observable.interval(1000);
   * var buffered = interval.buffer(clicks);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link window}
   *
   * @param {Observable<any>} closingNotifier An Observable that signals the
   * buffer to be emitted on the output Observable.
   * @return {Observable<T[]>} An Observable of buffers, which are arrays of
   * values.
   * @method buffer
   * @owner Observable
   */function buffer(closingNotifier){return function bufferOperatorFunction(source){return source.lift(new BufferOperator(closingNotifier));};}exports.buffer=buffer;var BufferOperator=function(){function BufferOperator(closingNotifier){this.closingNotifier=closingNotifier;}BufferOperator.prototype.call=function(subscriber,source){return source.subscribe(new BufferSubscriber(subscriber,this.closingNotifier));};return BufferOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferSubscriber=function(_super){__extends(BufferSubscriber,_super);function BufferSubscriber(destination,closingNotifier){_super.call(this,destination);this.buffer=[];this.add(subscribeToResult_1.subscribeToResult(this,closingNotifier));}BufferSubscriber.prototype._next=function(value){this.buffer.push(value);};BufferSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var buffer=this.buffer;this.buffer=[];this.destination.next(buffer);};return BufferSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=buffer.js.map
  
  /***/ }),
  /* 73 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Buffers the source Observable values until the size hits the maximum
   * `bufferSize` given.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * that array only when its size reaches `bufferSize`.</span>
   *
   * <img src="./img/bufferCount.png" width="100%">
   *
   * Buffers a number of values from the source Observable by `bufferSize` then
   * emits the buffer and clears it, and starts a new buffer each
   * `startBufferEvery` values. If `startBufferEvery` is not provided or is
   * `null`, then new buffers are started immediately at the start of the source
   * and when each buffer closes and is emitted.
   *
   * @example <caption>Emit the last two click events as an array</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferCount(2);
   * buffered.subscribe(x => console.log(x));
   *
   * @example <caption>On every click, emit the last two click events as an array</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferCount(2, 1);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link pairwise}
   * @see {@link windowCount}
   *
   * @param {number} bufferSize The maximum size of the buffer emitted.
   * @param {number} [startBufferEvery] Interval at which to start a new buffer.
   * For example if `startBufferEvery` is `2`, then a new buffer will be started
   * on every other value from the source. A new buffer is started at the
   * beginning of the source by default.
   * @return {Observable<T[]>} An Observable of arrays of buffered values.
   * @method bufferCount
   * @owner Observable
   */function bufferCount(bufferSize,startBufferEvery){if(startBufferEvery===void 0){startBufferEvery=null;}return function bufferCountOperatorFunction(source){return source.lift(new BufferCountOperator(bufferSize,startBufferEvery));};}exports.bufferCount=bufferCount;var BufferCountOperator=function(){function BufferCountOperator(bufferSize,startBufferEvery){this.bufferSize=bufferSize;this.startBufferEvery=startBufferEvery;if(!startBufferEvery||bufferSize===startBufferEvery){this.subscriberClass=BufferCountSubscriber;}else{this.subscriberClass=BufferSkipCountSubscriber;}}BufferCountOperator.prototype.call=function(subscriber,source){return source.subscribe(new this.subscriberClass(subscriber,this.bufferSize,this.startBufferEvery));};return BufferCountOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferCountSubscriber=function(_super){__extends(BufferCountSubscriber,_super);function BufferCountSubscriber(destination,bufferSize){_super.call(this,destination);this.bufferSize=bufferSize;this.buffer=[];}BufferCountSubscriber.prototype._next=function(value){var buffer=this.buffer;buffer.push(value);if(buffer.length==this.bufferSize){this.destination.next(buffer);this.buffer=[];}};BufferCountSubscriber.prototype._complete=function(){var buffer=this.buffer;if(buffer.length>0){this.destination.next(buffer);}_super.prototype._complete.call(this);};return BufferCountSubscriber;}(Subscriber_1.Subscriber);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferSkipCountSubscriber=function(_super){__extends(BufferSkipCountSubscriber,_super);function BufferSkipCountSubscriber(destination,bufferSize,startBufferEvery){_super.call(this,destination);this.bufferSize=bufferSize;this.startBufferEvery=startBufferEvery;this.buffers=[];this.count=0;}BufferSkipCountSubscriber.prototype._next=function(value){var _a=this,bufferSize=_a.bufferSize,startBufferEvery=_a.startBufferEvery,buffers=_a.buffers,count=_a.count;this.count++;if(count%startBufferEvery===0){buffers.push([]);}for(var i=buffers.length;i--;){var buffer=buffers[i];buffer.push(value);if(buffer.length===bufferSize){buffers.splice(i,1);this.destination.next(buffer);}}};BufferSkipCountSubscriber.prototype._complete=function(){var _a=this,buffers=_a.buffers,destination=_a.destination;while(buffers.length>0){var buffer=buffers.shift();if(buffer.length>0){destination.next(buffer);}}_super.prototype._complete.call(this);};return BufferSkipCountSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=bufferCount.js.map
  
  /***/ }),
  /* 74 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var async_1=__webpack_require__(4);var Subscriber_1=__webpack_require__(1);var isScheduler_1=__webpack_require__(10);/* tslint:enable:max-line-length *//**
   * Buffers the source Observable values for a specific time period.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * those arrays periodically in time.</span>
   *
   * <img src="./img/bufferTime.png" width="100%">
   *
   * Buffers values from the source for a specific time duration `bufferTimeSpan`.
   * Unless the optional argument `bufferCreationInterval` is given, it emits and
   * resets the buffer every `bufferTimeSpan` milliseconds. If
   * `bufferCreationInterval` is given, this operator opens the buffer every
   * `bufferCreationInterval` milliseconds and closes (emits and resets) the
   * buffer every `bufferTimeSpan` milliseconds. When the optional argument
   * `maxBufferSize` is specified, the buffer will be closed either after
   * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.
   *
   * @example <caption>Every second, emit an array of the recent click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferTime(1000);
   * buffered.subscribe(x => console.log(x));
   *
   * @example <caption>Every 5 seconds, emit the click events from the next 2 seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferTime(2000, 5000);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link windowTime}
   *
   * @param {number} bufferTimeSpan The amount of time to fill each buffer array.
   * @param {number} [bufferCreationInterval] The interval at which to start new
   * buffers.
   * @param {number} [maxBufferSize] The maximum buffer size.
   * @param {Scheduler} [scheduler=async] The scheduler on which to schedule the
   * intervals that determine buffer boundaries.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferTime
   * @owner Observable
   */function bufferTime(bufferTimeSpan){var length=arguments.length;var scheduler=async_1.async;if(isScheduler_1.isScheduler(arguments[arguments.length-1])){scheduler=arguments[arguments.length-1];length--;}var bufferCreationInterval=null;if(length>=2){bufferCreationInterval=arguments[1];}var maxBufferSize=Number.POSITIVE_INFINITY;if(length>=3){maxBufferSize=arguments[2];}return function bufferTimeOperatorFunction(source){return source.lift(new BufferTimeOperator(bufferTimeSpan,bufferCreationInterval,maxBufferSize,scheduler));};}exports.bufferTime=bufferTime;var BufferTimeOperator=function(){function BufferTimeOperator(bufferTimeSpan,bufferCreationInterval,maxBufferSize,scheduler){this.bufferTimeSpan=bufferTimeSpan;this.bufferCreationInterval=bufferCreationInterval;this.maxBufferSize=maxBufferSize;this.scheduler=scheduler;}BufferTimeOperator.prototype.call=function(subscriber,source){return source.subscribe(new BufferTimeSubscriber(subscriber,this.bufferTimeSpan,this.bufferCreationInterval,this.maxBufferSize,this.scheduler));};return BufferTimeOperator;}();var Context=function(){function Context(){this.buffer=[];}return Context;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferTimeSubscriber=function(_super){__extends(BufferTimeSubscriber,_super);function BufferTimeSubscriber(destination,bufferTimeSpan,bufferCreationInterval,maxBufferSize,scheduler){_super.call(this,destination);this.bufferTimeSpan=bufferTimeSpan;this.bufferCreationInterval=bufferCreationInterval;this.maxBufferSize=maxBufferSize;this.scheduler=scheduler;this.contexts=[];var context=this.openContext();this.timespanOnly=bufferCreationInterval==null||bufferCreationInterval<0;if(this.timespanOnly){var timeSpanOnlyState={subscriber:this,context:context,bufferTimeSpan:bufferTimeSpan};this.add(context.closeAction=scheduler.schedule(dispatchBufferTimeSpanOnly,bufferTimeSpan,timeSpanOnlyState));}else{var closeState={subscriber:this,context:context};var creationState={bufferTimeSpan:bufferTimeSpan,bufferCreationInterval:bufferCreationInterval,subscriber:this,scheduler:scheduler};this.add(context.closeAction=scheduler.schedule(dispatchBufferClose,bufferTimeSpan,closeState));this.add(scheduler.schedule(dispatchBufferCreation,bufferCreationInterval,creationState));}}BufferTimeSubscriber.prototype._next=function(value){var contexts=this.contexts;var len=contexts.length;var filledBufferContext;for(var i=0;i<len;i++){var context=contexts[i];var buffer=context.buffer;buffer.push(value);if(buffer.length==this.maxBufferSize){filledBufferContext=context;}}if(filledBufferContext){this.onBufferFull(filledBufferContext);}};BufferTimeSubscriber.prototype._error=function(err){this.contexts.length=0;_super.prototype._error.call(this,err);};BufferTimeSubscriber.prototype._complete=function(){var _a=this,contexts=_a.contexts,destination=_a.destination;while(contexts.length>0){var context=contexts.shift();destination.next(context.buffer);}_super.prototype._complete.call(this);};BufferTimeSubscriber.prototype._unsubscribe=function(){this.contexts=null;};BufferTimeSubscriber.prototype.onBufferFull=function(context){this.closeContext(context);var closeAction=context.closeAction;closeAction.unsubscribe();this.remove(closeAction);if(!this.closed&&this.timespanOnly){context=this.openContext();var bufferTimeSpan=this.bufferTimeSpan;var timeSpanOnlyState={subscriber:this,context:context,bufferTimeSpan:bufferTimeSpan};this.add(context.closeAction=this.scheduler.schedule(dispatchBufferTimeSpanOnly,bufferTimeSpan,timeSpanOnlyState));}};BufferTimeSubscriber.prototype.openContext=function(){var context=new Context();this.contexts.push(context);return context;};BufferTimeSubscriber.prototype.closeContext=function(context){this.destination.next(context.buffer);var contexts=this.contexts;var spliceIndex=contexts?contexts.indexOf(context):-1;if(spliceIndex>=0){contexts.splice(contexts.indexOf(context),1);}};return BufferTimeSubscriber;}(Subscriber_1.Subscriber);function dispatchBufferTimeSpanOnly(state){var subscriber=state.subscriber;var prevContext=state.context;if(prevContext){subscriber.closeContext(prevContext);}if(!subscriber.closed){state.context=subscriber.openContext();state.context.closeAction=this.schedule(state,state.bufferTimeSpan);}}function dispatchBufferCreation(state){var bufferCreationInterval=state.bufferCreationInterval,bufferTimeSpan=state.bufferTimeSpan,subscriber=state.subscriber,scheduler=state.scheduler;var context=subscriber.openContext();var action=this;if(!subscriber.closed){subscriber.add(context.closeAction=scheduler.schedule(dispatchBufferClose,bufferTimeSpan,{subscriber:subscriber,context:context}));action.schedule(state,bufferCreationInterval);}}function dispatchBufferClose(arg){var subscriber=arg.subscriber,context=arg.context;subscriber.closeContext(context);}//# sourceMappingURL=bufferTime.js.map
  
  /***/ }),
  /* 75 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscription_1=__webpack_require__(5);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * Buffers the source Observable values starting from an emission from
   * `openings` and ending when the output of `closingSelector` emits.
   *
   * <span class="informal">Collects values from the past as an array. Starts
   * collecting only when `opening` emits, and calls the `closingSelector`
   * function to get an Observable that tells when to close the buffer.</span>
   *
   * <img src="./img/bufferToggle.png" width="100%">
   *
   * Buffers values from the source by opening the buffer via signals from an
   * Observable provided to `openings`, and closing and sending the buffers when
   * a Subscribable or Promise returned by the `closingSelector` function emits.
   *
   * @example <caption>Every other second, emit the click events from the next 500ms</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var openings = Rx.Observable.interval(1000);
   * var buffered = clicks.bufferToggle(openings, i =>
   *   i % 2 ? Rx.Observable.interval(500) : Rx.Observable.empty()
   * );
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferWhen}
   * @see {@link windowToggle}
   *
   * @param {SubscribableOrPromise<O>} openings A Subscribable or Promise of notifications to start new
   * buffers.
   * @param {function(value: O): SubscribableOrPromise} closingSelector A function that takes
   * the value emitted by the `openings` observable and returns a Subscribable or Promise,
   * which, when it emits, signals that the associated buffer should be emitted
   * and cleared.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferToggle
   * @owner Observable
   */function bufferToggle(openings,closingSelector){return function bufferToggleOperatorFunction(source){return source.lift(new BufferToggleOperator(openings,closingSelector));};}exports.bufferToggle=bufferToggle;var BufferToggleOperator=function(){function BufferToggleOperator(openings,closingSelector){this.openings=openings;this.closingSelector=closingSelector;}BufferToggleOperator.prototype.call=function(subscriber,source){return source.subscribe(new BufferToggleSubscriber(subscriber,this.openings,this.closingSelector));};return BufferToggleOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferToggleSubscriber=function(_super){__extends(BufferToggleSubscriber,_super);function BufferToggleSubscriber(destination,openings,closingSelector){_super.call(this,destination);this.openings=openings;this.closingSelector=closingSelector;this.contexts=[];this.add(subscribeToResult_1.subscribeToResult(this,openings));}BufferToggleSubscriber.prototype._next=function(value){var contexts=this.contexts;var len=contexts.length;for(var i=0;i<len;i++){contexts[i].buffer.push(value);}};BufferToggleSubscriber.prototype._error=function(err){var contexts=this.contexts;while(contexts.length>0){var context=contexts.shift();context.subscription.unsubscribe();context.buffer=null;context.subscription=null;}this.contexts=null;_super.prototype._error.call(this,err);};BufferToggleSubscriber.prototype._complete=function(){var contexts=this.contexts;while(contexts.length>0){var context=contexts.shift();this.destination.next(context.buffer);context.subscription.unsubscribe();context.buffer=null;context.subscription=null;}this.contexts=null;_super.prototype._complete.call(this);};BufferToggleSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){outerValue?this.closeBuffer(outerValue):this.openBuffer(innerValue);};BufferToggleSubscriber.prototype.notifyComplete=function(innerSub){this.closeBuffer(innerSub.context);};BufferToggleSubscriber.prototype.openBuffer=function(value){try{var closingSelector=this.closingSelector;var closingNotifier=closingSelector.call(this,value);if(closingNotifier){this.trySubscribe(closingNotifier);}}catch(err){this._error(err);}};BufferToggleSubscriber.prototype.closeBuffer=function(context){var contexts=this.contexts;if(contexts&&context){var buffer=context.buffer,subscription=context.subscription;this.destination.next(buffer);contexts.splice(contexts.indexOf(context),1);this.remove(subscription);subscription.unsubscribe();}};BufferToggleSubscriber.prototype.trySubscribe=function(closingNotifier){var contexts=this.contexts;var buffer=[];var subscription=new Subscription_1.Subscription();var context={buffer:buffer,subscription:subscription};contexts.push(context);var innerSubscription=subscribeToResult_1.subscribeToResult(this,closingNotifier,context);if(!innerSubscription||innerSubscription.closed){this.closeBuffer(context);}else{innerSubscription.context=context;this.add(innerSubscription);subscription.add(innerSubscription);}};return BufferToggleSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=bufferToggle.js.map
  
  /***/ }),
  /* 76 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscription_1=__webpack_require__(5);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Buffers the source Observable values, using a factory function of closing
   * Observables to determine when to close, emit, and reset the buffer.
   *
   * <span class="informal">Collects values from the past as an array. When it
   * starts collecting values, it calls a function that returns an Observable that
   * tells when to close the buffer and restart collecting.</span>
   *
   * <img src="./img/bufferWhen.png" width="100%">
   *
   * Opens a buffer immediately, then closes the buffer when the observable
   * returned by calling `closingSelector` function emits a value. When it closes
   * the buffer, it immediately opens a new buffer and repeats the process.
   *
   * @example <caption>Emit an array of the last clicks every [1-5] random seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferWhen(() =>
   *   Rx.Observable.interval(1000 + Math.random() * 4000)
   * );
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link windowWhen}
   *
   * @param {function(): Observable} closingSelector A function that takes no
   * arguments and returns an Observable that signals buffer closure.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferWhen
   * @owner Observable
   */function bufferWhen(closingSelector){return function(source){return source.lift(new BufferWhenOperator(closingSelector));};}exports.bufferWhen=bufferWhen;var BufferWhenOperator=function(){function BufferWhenOperator(closingSelector){this.closingSelector=closingSelector;}BufferWhenOperator.prototype.call=function(subscriber,source){return source.subscribe(new BufferWhenSubscriber(subscriber,this.closingSelector));};return BufferWhenOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var BufferWhenSubscriber=function(_super){__extends(BufferWhenSubscriber,_super);function BufferWhenSubscriber(destination,closingSelector){_super.call(this,destination);this.closingSelector=closingSelector;this.subscribing=false;this.openBuffer();}BufferWhenSubscriber.prototype._next=function(value){this.buffer.push(value);};BufferWhenSubscriber.prototype._complete=function(){var buffer=this.buffer;if(buffer){this.destination.next(buffer);}_super.prototype._complete.call(this);};BufferWhenSubscriber.prototype._unsubscribe=function(){this.buffer=null;this.subscribing=false;};BufferWhenSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.openBuffer();};BufferWhenSubscriber.prototype.notifyComplete=function(){if(this.subscribing){this.complete();}else{this.openBuffer();}};BufferWhenSubscriber.prototype.openBuffer=function(){var closingSubscription=this.closingSubscription;if(closingSubscription){this.remove(closingSubscription);closingSubscription.unsubscribe();}var buffer=this.buffer;if(this.buffer){this.destination.next(buffer);}this.buffer=[];var closingNotifier=tryCatch_1.tryCatch(this.closingSelector)();if(closingNotifier===errorObject_1.errorObject){this.error(errorObject_1.errorObject.e);}else{closingSubscription=new Subscription_1.Subscription();this.closingSubscription=closingSubscription;this.add(closingSubscription);this.subscribing=true;closingSubscription.add(subscribeToResult_1.subscribeToResult(this,closingNotifier));this.subscribing=false;}};return BufferWhenSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=bufferWhen.js.map
  
  /***/ }),
  /* 77 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Catches errors on the observable to be handled by returning a new observable or throwing an error.
   *
   * <img src="./img/catch.png" width="100%">
   *
   * @example <caption>Continues with a different Observable when there's an error</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   * 	   if (n == 4) {
   * 	     throw 'four!';
   *     }
   *	   return n;
   *   })
   *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))
   *   .subscribe(x => console.log(x));
   *   // 1, 2, 3, I, II, III, IV, V
   *
   * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   * 	   if (n === 4) {
   * 	     throw 'four!';
   *     }
   * 	   return n;
   *   })
   *   .catch((err, caught) => caught)
   *   .take(30)
   *   .subscribe(x => console.log(x));
   *   // 1, 2, 3, 1, 2, 3, ...
   *
   * @example <caption>Throws a new error when the source Observable throws an error</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   *     if (n == 4) {
   *       throw 'four!';
   *     }
   *     return n;
   *   })
   *   .catch(err => {
   *     throw 'error in source. Details: ' + err;
   *   })
   *   .subscribe(
   *     x => console.log(x),
   *     err => console.log(err)
   *   );
   *   // 1, 2, 3, error in source. Details: four!
   *
   * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which
   *  is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable
   *  is returned by the `selector` will be used to continue the observable chain.
   * @return {Observable} An observable that originates from either the source or the observable returned by the
   *  catch `selector` function.
   * @name catchError
   */function catchError(selector){return function catchErrorOperatorFunction(source){var operator=new CatchOperator(selector);var caught=source.lift(operator);return operator.caught=caught;};}exports.catchError=catchError;var CatchOperator=function(){function CatchOperator(selector){this.selector=selector;}CatchOperator.prototype.call=function(subscriber,source){return source.subscribe(new CatchSubscriber(subscriber,this.selector,this.caught));};return CatchOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var CatchSubscriber=function(_super){__extends(CatchSubscriber,_super);function CatchSubscriber(destination,selector,caught){_super.call(this,destination);this.selector=selector;this.caught=caught;}// NOTE: overriding `error` instead of `_error` because we don't want
  // to have this flag this subscriber as `isStopped`. We can mimic the
  // behavior of the RetrySubscriber (from the `retry` operator), where
  // we unsubscribe from our source chain, reset our Subscriber flags,
  // then subscribe to the selector result.
  CatchSubscriber.prototype.error=function(err){if(!this.isStopped){var result=void 0;try{result=this.selector(err,this.caught);}catch(err2){_super.prototype.error.call(this,err2);return;}this._unsubscribeAndRecycle();this.add(subscribeToResult_1.subscribeToResult(this,result));}};return CatchSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=catchError.js.map
  
  /***/ }),
  /* 78 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var combineLatest_1=__webpack_require__(30);function combineAll(project){return function(source){return source.lift(new combineLatest_1.CombineLatestOperator(project));};}exports.combineAll=combineAll;//# sourceMappingURL=combineAll.js.map
  
  /***/ }),
  /* 79 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concat_1=__webpack_require__(16);var concat_2=__webpack_require__(16);exports.concatStatic=concat_2.concat;/* tslint:enable:max-line-length *//**
   * Creates an output Observable which sequentially emits all values from every
   * given input Observable after the current Observable.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * Joins this Observable with multiple other Observables by subscribing to them
   * one at a time, starting with the source, and merging their results into the
   * output Observable. Will wait for each Observable to complete before moving
   * on to the next.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = timer.concat(sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   * @example <caption>Concatenate 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = timer1.concat(timer2, timer3);
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} other An input Observable to concatenate after the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @method concat
   * @owner Observable
   */function concat(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return function(source){return source.lift.call(concat_1.concat.apply(void 0,[source].concat(observables)));};}exports.concat=concat;//# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 80 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concatMap_1=__webpack_require__(46);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is merged multiple
   * times in a serialized fashion on the output Observable.
   *
   * <span class="informal">It's like {@link concatMap}, but maps each value
   * always to the same inner Observable.</span>
   *
   * <img src="./img/concatMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then flattens those resulting Observables into one
   * single Observable, which is the output Observable. Each new `innerObservable`
   * instance emitted on the output Observable is concatenated with the previous
   * `innerObservable` instance.
   *
   * __Warning:__ if source values arrive endlessly and faster than their
   * corresponding inner Observables can complete, it will result in memory issues
   * as inner Observables amass in an unbounded buffer waiting for their turn to
   * be subscribed to.
   *
   * Note: `concatMapTo` is equivalent to `mergeMapTo` with concurrency parameter
   * set to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.concatMapTo(Rx.Observable.interval(1000).take(4));
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link concat}
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link mergeMapTo}
   * @see {@link switchMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An observable of values merged together by joining the
   * passed observable with itself, one after the other, for each value emitted
   * from the source.
   * @method concatMapTo
   * @owner Observable
   */function concatMapTo(innerObservable,resultSelector){return concatMap_1.concatMap(function(){return innerObservable;},resultSelector);}exports.concatMapTo=concatMapTo;//# sourceMappingURL=concatMapTo.js.map
  
  /***/ }),
  /* 81 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Counts the number of emissions on the source and emits that number when the
   * source completes.
   *
   * <span class="informal">Tells how many values were emitted, when the source
   * completes.</span>
   *
   * <img src="./img/count.png" width="100%">
   *
   * `count` transforms an Observable that emits values into an Observable that
   * emits a single value that represents the number of values emitted by the
   * source Observable. If the source Observable terminates with an error, `count`
   * will pass this error notification along without emitting a value first. If
   * the source Observable does not terminate at all, `count` will neither emit
   * a value nor terminate. This operator takes an optional `predicate` function
   * as argument, in which case the output emission will represent the number of
   * source values that matched `true` with the `predicate`.
   *
   * @example <caption>Counts how many seconds have passed before the first click happened</caption>
   * var seconds = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var secondsBeforeClick = seconds.takeUntil(clicks);
   * var result = secondsBeforeClick.count();
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>
   * var numbers = Rx.Observable.range(1, 7);
   * var result = numbers.count(i => i % 2 === 1);
   * result.subscribe(x => console.log(x));
   *
   * // Results in:
   * // 4
   *
   * @see {@link max}
   * @see {@link min}
   * @see {@link reduce}
   *
   * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A
   * boolean function to select what values are to be counted. It is provided with
   * arguments of:
   * - `value`: the value from the source Observable.
   * - `index`: the (zero-based) "index" of the value from the source Observable.
   * - `source`: the source Observable instance itself.
   * @return {Observable} An Observable of one number that represents the count as
   * described above.
   * @method count
   * @owner Observable
   */function count(predicate){return function(source){return source.lift(new CountOperator(predicate,source));};}exports.count=count;var CountOperator=function(){function CountOperator(predicate,source){this.predicate=predicate;this.source=source;}CountOperator.prototype.call=function(subscriber,source){return source.subscribe(new CountSubscriber(subscriber,this.predicate,this.source));};return CountOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var CountSubscriber=function(_super){__extends(CountSubscriber,_super);function CountSubscriber(destination,predicate,source){_super.call(this,destination);this.predicate=predicate;this.source=source;this.count=0;this.index=0;}CountSubscriber.prototype._next=function(value){if(this.predicate){this._tryPredicate(value);}else{this.count++;}};CountSubscriber.prototype._tryPredicate=function(value){var result;try{result=this.predicate(value,this.index++,this.source);}catch(err){this.destination.error(err);return;}if(result){this.count++;}};CountSubscriber.prototype._complete=function(){this.destination.next(this.count);this.destination.complete();};return CountSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=count.js.map
  
  /***/ }),
  /* 82 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Converts an Observable of {@link Notification} objects into the emissions
   * that they represent.
   *
   * <span class="informal">Unwraps {@link Notification} objects as actual `next`,
   * `error` and `complete` emissions. The opposite of {@link materialize}.</span>
   *
   * <img src="./img/dematerialize.png" width="100%">
   *
   * `dematerialize` is assumed to operate an Observable that only emits
   * {@link Notification} objects as `next` emissions, and does not emit any
   * `error`. Such Observable is the output of a `materialize` operation. Those
   * notifications are then unwrapped using the metadata they contain, and emitted
   * as `next`, `error`, and `complete` on the output Observable.
   *
   * Use this operator in conjunction with {@link materialize}.
   *
   * @example <caption>Convert an Observable of Notifications to an actual Observable</caption>
   * var notifA = new Rx.Notification('N', 'A');
   * var notifB = new Rx.Notification('N', 'B');
   * var notifE = new Rx.Notification('E', void 0,
   *   new TypeError('x.toUpperCase is not a function')
   * );
   * var materialized = Rx.Observable.of(notifA, notifB, notifE);
   * var upperCase = materialized.dematerialize();
   * upperCase.subscribe(x => console.log(x), e => console.error(e));
   *
   * // Results in:
   * // A
   * // B
   * // TypeError: x.toUpperCase is not a function
   *
   * @see {@link Notification}
   * @see {@link materialize}
   *
   * @return {Observable} An Observable that emits items and notifications
   * embedded in Notification objects emitted by the source Observable.
   * @method dematerialize
   * @owner Observable
   */function dematerialize(){return function dematerializeOperatorFunction(source){return source.lift(new DeMaterializeOperator());};}exports.dematerialize=dematerialize;var DeMaterializeOperator=function(){function DeMaterializeOperator(){}DeMaterializeOperator.prototype.call=function(subscriber,source){return source.subscribe(new DeMaterializeSubscriber(subscriber));};return DeMaterializeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DeMaterializeSubscriber=function(_super){__extends(DeMaterializeSubscriber,_super);function DeMaterializeSubscriber(destination){_super.call(this,destination);}DeMaterializeSubscriber.prototype._next=function(value){value.observe(this.destination);};return DeMaterializeSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=dematerialize.js.map
  
  /***/ }),
  /* 83 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Emits a value from the source Observable only after a particular time span
   * determined by another Observable has passed without another source emission.
   *
   * <span class="informal">It's like {@link debounceTime}, but the time span of
   * emission silence is determined by a second Observable.</span>
   *
   * <img src="./img/debounce.png" width="100%">
   *
   * `debounce` delays values emitted by the source Observable, but drops previous
   * pending delayed emissions if a new value arrives on the source Observable.
   * This operator keeps track of the most recent value from the source
   * Observable, and spawns a duration Observable by calling the
   * `durationSelector` function. The value is emitted only when the duration
   * Observable emits a value or completes, and if no other value was emitted on
   * the source Observable since the duration Observable was spawned. If a new
   * value appears before the duration Observable emits, the previous value will
   * be dropped and will not be emitted on the output Observable.
   *
   * Like {@link debounceTime}, this is a rate-limiting operator, and also a
   * delay-like operator since output emissions do not necessarily occur at the
   * same time as they did on the source Observable.
   *
   * @example <caption>Emit the most recent click after a burst of clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.debounce(() => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounceTime}
   * @see {@link delayWhen}
   * @see {@link throttle}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the timeout
   * duration for each source value, returned as an Observable or a Promise.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified duration Observable returned by
   * `durationSelector`, and may drop some values if they occur too frequently.
   * @method debounce
   * @owner Observable
   */function debounce(durationSelector){return function(source){return source.lift(new DebounceOperator(durationSelector));};}exports.debounce=debounce;var DebounceOperator=function(){function DebounceOperator(durationSelector){this.durationSelector=durationSelector;}DebounceOperator.prototype.call=function(subscriber,source){return source.subscribe(new DebounceSubscriber(subscriber,this.durationSelector));};return DebounceOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DebounceSubscriber=function(_super){__extends(DebounceSubscriber,_super);function DebounceSubscriber(destination,durationSelector){_super.call(this,destination);this.durationSelector=durationSelector;this.hasValue=false;this.durationSubscription=null;}DebounceSubscriber.prototype._next=function(value){try{var result=this.durationSelector.call(this,value);if(result){this._tryNext(value,result);}}catch(err){this.destination.error(err);}};DebounceSubscriber.prototype._complete=function(){this.emitValue();this.destination.complete();};DebounceSubscriber.prototype._tryNext=function(value,duration){var subscription=this.durationSubscription;this.value=value;this.hasValue=true;if(subscription){subscription.unsubscribe();this.remove(subscription);}subscription=subscribeToResult_1.subscribeToResult(this,duration);if(!subscription.closed){this.add(this.durationSubscription=subscription);}};DebounceSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.emitValue();};DebounceSubscriber.prototype.notifyComplete=function(){this.emitValue();};DebounceSubscriber.prototype.emitValue=function(){if(this.hasValue){var value=this.value;var subscription=this.durationSubscription;if(subscription){this.durationSubscription=null;subscription.unsubscribe();this.remove(subscription);}this.value=null;this.hasValue=false;_super.prototype._next.call(this,value);}};return DebounceSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=debounce.js.map
  
  /***/ }),
  /* 84 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var async_1=__webpack_require__(4);/**
   * Emits a value from the source Observable only after a particular time span
   * has passed without another source emission.
   *
   * <span class="informal">It's like {@link delay}, but passes only the most
   * recent value from each burst of emissions.</span>
   *
   * <img src="./img/debounceTime.png" width="100%">
   *
   * `debounceTime` delays values emitted by the source Observable, but drops
   * previous pending delayed emissions if a new value arrives on the source
   * Observable. This operator keeps track of the most recent value from the
   * source Observable, and emits that only when `dueTime` enough time has passed
   * without any other value appearing on the source Observable. If a new value
   * appears before `dueTime` silence occurs, the previous value will be dropped
   * and will not be emitted on the output Observable.
   *
   * This is a rate-limiting operator, because it is impossible for more than one
   * value to be emitted in any time window of duration `dueTime`, but it is also
   * a delay-like operator since output emissions do not occur at the same time as
   * they did on the source Observable. Optionally takes a {@link IScheduler} for
   * managing timers.
   *
   * @example <caption>Emit the most recent click after a burst of clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.debounceTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounce}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttleTime}
   *
   * @param {number} dueTime The timeout duration in milliseconds (or the time
   * unit determined internally by the optional `scheduler`) for the window of
   * time required to wait for emission silence before emitting the most recent
   * source value.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the timeout for each value.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified `dueTime`, and may drop some values if they occur
   * too frequently.
   * @method debounceTime
   * @owner Observable
   */function debounceTime(dueTime,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return function(source){return source.lift(new DebounceTimeOperator(dueTime,scheduler));};}exports.debounceTime=debounceTime;var DebounceTimeOperator=function(){function DebounceTimeOperator(dueTime,scheduler){this.dueTime=dueTime;this.scheduler=scheduler;}DebounceTimeOperator.prototype.call=function(subscriber,source){return source.subscribe(new DebounceTimeSubscriber(subscriber,this.dueTime,this.scheduler));};return DebounceTimeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DebounceTimeSubscriber=function(_super){__extends(DebounceTimeSubscriber,_super);function DebounceTimeSubscriber(destination,dueTime,scheduler){_super.call(this,destination);this.dueTime=dueTime;this.scheduler=scheduler;this.debouncedSubscription=null;this.lastValue=null;this.hasValue=false;}DebounceTimeSubscriber.prototype._next=function(value){this.clearDebounce();this.lastValue=value;this.hasValue=true;this.add(this.debouncedSubscription=this.scheduler.schedule(dispatchNext,this.dueTime,this));};DebounceTimeSubscriber.prototype._complete=function(){this.debouncedNext();this.destination.complete();};DebounceTimeSubscriber.prototype.debouncedNext=function(){this.clearDebounce();if(this.hasValue){this.destination.next(this.lastValue);this.lastValue=null;this.hasValue=false;}};DebounceTimeSubscriber.prototype.clearDebounce=function(){var debouncedSubscription=this.debouncedSubscription;if(debouncedSubscription!==null){this.remove(debouncedSubscription);debouncedSubscription.unsubscribe();this.debouncedSubscription=null;}};return DebounceTimeSubscriber;}(Subscriber_1.Subscriber);function dispatchNext(subscriber){subscriber.debouncedNext();}//# sourceMappingURL=debounceTime.js.map
  
  /***/ }),
  /* 85 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var async_1=__webpack_require__(4);var isDate_1=__webpack_require__(34);var Subscriber_1=__webpack_require__(1);var Notification_1=__webpack_require__(17);/**
   * Delays the emission of items from the source Observable by a given timeout or
   * until a given Date.
   *
   * <span class="informal">Time shifts each item by some specified amount of
   * milliseconds.</span>
   *
   * <img src="./img/delay.png" width="100%">
   *
   * If the delay argument is a Number, this operator time shifts the source
   * Observable by that amount of time expressed in milliseconds. The relative
   * time intervals between the values are preserved.
   *
   * If the delay argument is a Date, this operator time shifts the start of the
   * Observable execution until the given date occurs.
   *
   * @example <caption>Delay each click by one second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @example <caption>Delay all clicks until a future date happens</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var date = new Date('March 15, 2050 12:00:00'); // in the future
   * var delayedClicks = clicks.delay(date); // click emitted only after that date
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @see {@link debounceTime}
   * @see {@link delayWhen}
   *
   * @param {number|Date} delay The delay duration in milliseconds (a `number`) or
   * a `Date` until which the emission of the source items is delayed.
   * @param {Scheduler} [scheduler=async] The IScheduler to use for
   * managing the timers that handle the time-shift for each item.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified timeout or Date.
   * @method delay
   * @owner Observable
   */function delay(delay,scheduler){if(scheduler===void 0){scheduler=async_1.async;}var absoluteDelay=isDate_1.isDate(delay);var delayFor=absoluteDelay?+delay-scheduler.now():Math.abs(delay);return function(source){return source.lift(new DelayOperator(delayFor,scheduler));};}exports.delay=delay;var DelayOperator=function(){function DelayOperator(delay,scheduler){this.delay=delay;this.scheduler=scheduler;}DelayOperator.prototype.call=function(subscriber,source){return source.subscribe(new DelaySubscriber(subscriber,this.delay,this.scheduler));};return DelayOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DelaySubscriber=function(_super){__extends(DelaySubscriber,_super);function DelaySubscriber(destination,delay,scheduler){_super.call(this,destination);this.delay=delay;this.scheduler=scheduler;this.queue=[];this.active=false;this.errored=false;}DelaySubscriber.dispatch=function(state){var source=state.source;var queue=source.queue;var scheduler=state.scheduler;var destination=state.destination;while(queue.length>0&&queue[0].time-scheduler.now()<=0){queue.shift().notification.observe(destination);}if(queue.length>0){var delay_1=Math.max(0,queue[0].time-scheduler.now());this.schedule(state,delay_1);}else{source.active=false;}};DelaySubscriber.prototype._schedule=function(scheduler){this.active=true;this.add(scheduler.schedule(DelaySubscriber.dispatch,this.delay,{source:this,destination:this.destination,scheduler:scheduler}));};DelaySubscriber.prototype.scheduleNotification=function(notification){if(this.errored===true){return;}var scheduler=this.scheduler;var message=new DelayMessage(scheduler.now()+this.delay,notification);this.queue.push(message);if(this.active===false){this._schedule(scheduler);}};DelaySubscriber.prototype._next=function(value){this.scheduleNotification(Notification_1.Notification.createNext(value));};DelaySubscriber.prototype._error=function(err){this.errored=true;this.queue=[];this.destination.error(err);};DelaySubscriber.prototype._complete=function(){this.scheduleNotification(Notification_1.Notification.createComplete());};return DelaySubscriber;}(Subscriber_1.Subscriber);var DelayMessage=function(){function DelayMessage(time,notification){this.time=time;this.notification=notification;}return DelayMessage;}();//# sourceMappingURL=delay.js.map
  
  /***/ }),
  /* 86 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Observable_1=__webpack_require__(0);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Delays the emission of items from the source Observable by a given time span
   * determined by the emissions of another Observable.
   *
   * <span class="informal">It's like {@link delay}, but the time span of the
   * delay duration is determined by a second Observable.</span>
   *
   * <img src="./img/delayWhen.png" width="100%">
   *
   * `delayWhen` time shifts each emitted value from the source Observable by a
   * time span determined by another Observable. When the source emits a value,
   * the `delayDurationSelector` function is called with the source value as
   * argument, and should return an Observable, called the "duration" Observable.
   * The source value is emitted on the output Observable only when the duration
   * Observable emits a value or completes.
   *
   * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which
   * is an Observable. When `subscriptionDelay` emits its first value or
   * completes, the source Observable is subscribed to and starts behaving like
   * described in the previous paragraph. If `subscriptionDelay` is not provided,
   * `delayWhen` will subscribe to the source Observable as soon as the output
   * Observable is subscribed.
   *
   * @example <caption>Delay each click by a random amount of time, between 0 and 5 seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var delayedClicks = clicks.delayWhen(event =>
   *   Rx.Observable.interval(Math.random() * 5000)
   * );
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @see {@link debounce}
   * @see {@link delay}
   *
   * @param {function(value: T): Observable} delayDurationSelector A function that
   * returns an Observable for each value emitted by the source Observable, which
   * is then used to delay the emission of that item on the output Observable
   * until the Observable returned from this function emits a value.
   * @param {Observable} subscriptionDelay An Observable that triggers the
   * subscription to the source Observable once it emits any value.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by an amount of time specified by the Observable returned by
   * `delayDurationSelector`.
   * @method delayWhen
   * @owner Observable
   */function delayWhen(delayDurationSelector,subscriptionDelay){if(subscriptionDelay){return function(source){return new SubscriptionDelayObservable(source,subscriptionDelay).lift(new DelayWhenOperator(delayDurationSelector));};}return function(source){return source.lift(new DelayWhenOperator(delayDurationSelector));};}exports.delayWhen=delayWhen;var DelayWhenOperator=function(){function DelayWhenOperator(delayDurationSelector){this.delayDurationSelector=delayDurationSelector;}DelayWhenOperator.prototype.call=function(subscriber,source){return source.subscribe(new DelayWhenSubscriber(subscriber,this.delayDurationSelector));};return DelayWhenOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DelayWhenSubscriber=function(_super){__extends(DelayWhenSubscriber,_super);function DelayWhenSubscriber(destination,delayDurationSelector){_super.call(this,destination);this.delayDurationSelector=delayDurationSelector;this.completed=false;this.delayNotifierSubscriptions=[];this.values=[];}DelayWhenSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.destination.next(outerValue);this.removeSubscription(innerSub);this.tryComplete();};DelayWhenSubscriber.prototype.notifyError=function(error,innerSub){this._error(error);};DelayWhenSubscriber.prototype.notifyComplete=function(innerSub){var value=this.removeSubscription(innerSub);if(value){this.destination.next(value);}this.tryComplete();};DelayWhenSubscriber.prototype._next=function(value){try{var delayNotifier=this.delayDurationSelector(value);if(delayNotifier){this.tryDelay(delayNotifier,value);}}catch(err){this.destination.error(err);}};DelayWhenSubscriber.prototype._complete=function(){this.completed=true;this.tryComplete();};DelayWhenSubscriber.prototype.removeSubscription=function(subscription){subscription.unsubscribe();var subscriptionIdx=this.delayNotifierSubscriptions.indexOf(subscription);var value=null;if(subscriptionIdx!==-1){value=this.values[subscriptionIdx];this.delayNotifierSubscriptions.splice(subscriptionIdx,1);this.values.splice(subscriptionIdx,1);}return value;};DelayWhenSubscriber.prototype.tryDelay=function(delayNotifier,value){var notifierSubscription=subscribeToResult_1.subscribeToResult(this,delayNotifier,value);if(notifierSubscription&&!notifierSubscription.closed){this.add(notifierSubscription);this.delayNotifierSubscriptions.push(notifierSubscription);}this.values.push(value);};DelayWhenSubscriber.prototype.tryComplete=function(){if(this.completed&&this.delayNotifierSubscriptions.length===0){this.destination.complete();}};return DelayWhenSubscriber;}(OuterSubscriber_1.OuterSubscriber);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SubscriptionDelayObservable=function(_super){__extends(SubscriptionDelayObservable,_super);function SubscriptionDelayObservable(source,subscriptionDelay){_super.call(this);this.source=source;this.subscriptionDelay=subscriptionDelay;}SubscriptionDelayObservable.prototype._subscribe=function(subscriber){this.subscriptionDelay.subscribe(new SubscriptionDelaySubscriber(subscriber,this.source));};return SubscriptionDelayObservable;}(Observable_1.Observable);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SubscriptionDelaySubscriber=function(_super){__extends(SubscriptionDelaySubscriber,_super);function SubscriptionDelaySubscriber(parent,source){_super.call(this);this.parent=parent;this.source=source;this.sourceSubscribed=false;}SubscriptionDelaySubscriber.prototype._next=function(unused){this.subscribeToSource();};SubscriptionDelaySubscriber.prototype._error=function(err){this.unsubscribe();this.parent.error(err);};SubscriptionDelaySubscriber.prototype._complete=function(){this.subscribeToSource();};SubscriptionDelaySubscriber.prototype.subscribeToSource=function(){if(!this.sourceSubscribed){this.sourceSubscribed=true;this.unsubscribe();this.source.subscribe(this.parent);}};return SubscriptionDelaySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=delayWhen.js.map
  
  /***/ }),
  /* 87 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);var Set_1=__webpack_require__(273);/**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
   *
   * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
   * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
   * source observable directly with an equality check against previous values.
   *
   * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
   *
   * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
   * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
   * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
   * that the internal `Set` can be "flushed", basically clearing it of values.
   *
   * @example <caption>A simple example with numbers</caption>
   * Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
   *   .distinct()
   *   .subscribe(x => console.log(x)); // 1, 2, 3, 4
   *
   * @example <caption>An example using a keySelector function</caption>
   * interface Person {
   *    age: number,
   *    name: string
   * }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'})
   *     .distinct((p: Person) => p.name)
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   *
   * @see {@link distinctUntilChanged}
   * @see {@link distinctUntilKeyChanged}
   *
   * @param {function} [keySelector] Optional function to select which value you want to check as distinct.
   * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values.
   * @method distinct
   * @owner Observable
   */function distinct(keySelector,flushes){return function(source){return source.lift(new DistinctOperator(keySelector,flushes));};}exports.distinct=distinct;var DistinctOperator=function(){function DistinctOperator(keySelector,flushes){this.keySelector=keySelector;this.flushes=flushes;}DistinctOperator.prototype.call=function(subscriber,source){return source.subscribe(new DistinctSubscriber(subscriber,this.keySelector,this.flushes));};return DistinctOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DistinctSubscriber=function(_super){__extends(DistinctSubscriber,_super);function DistinctSubscriber(destination,keySelector,flushes){_super.call(this,destination);this.keySelector=keySelector;this.values=new Set_1.Set();if(flushes){this.add(subscribeToResult_1.subscribeToResult(this,flushes));}}DistinctSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.values.clear();};DistinctSubscriber.prototype.notifyError=function(error,innerSub){this._error(error);};DistinctSubscriber.prototype._next=function(value){if(this.keySelector){this._useKeySelector(value);}else{this._finalizeNext(value,value);}};DistinctSubscriber.prototype._useKeySelector=function(value){var key;var destination=this.destination;try{key=this.keySelector(value);}catch(err){destination.error(err);return;}this._finalizeNext(key,value);};DistinctSubscriber.prototype._finalizeNext=function(key,value){var values=this.values;if(!values.has(key)){values.add(key);this.destination.next(value);}};return DistinctSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.DistinctSubscriber=DistinctSubscriber;//# sourceMappingURL=distinct.js.map
  
  /***/ }),
  /* 88 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var distinctUntilChanged_1=__webpack_require__(48);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item,
   * using a property accessed by using the key provided to check if the two items are distinct.
   *
   * 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.
   *
   * If a comparator function is not provided, an equality check is used by default.
   *
   * @example <caption>An example comparing the name of persons</caption>
   *
   *  interface Person {
   *     age: number,
   *     name: string
   *  }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'},
   *     { age: 6, name: 'Foo'})
   *     .distinctUntilKeyChanged('name')
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo' }
   *
   * @example <caption>An example comparing the first letters of the name</caption>
   *
   * interface Person {
   *     age: number,
   *     name: string
   *  }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo1'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo2'},
   *     { age: 6, name: 'Foo3'})
   *     .distinctUntilKeyChanged('name', (x: string, y: string) => x.substring(0, 3) === y.substring(0, 3))
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo1' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo2' }
   *
   * @see {@link distinct}
   * @see {@link distinctUntilChanged}
   *
   * @param {string} key String key for object property lookup on each item.
   * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values based on the key specified.
   * @method distinctUntilKeyChanged
   * @owner Observable
   */function distinctUntilKeyChanged(key,compare){return distinctUntilChanged_1.distinctUntilChanged(function(x,y){return compare?compare(x[key],y[key]):x[key]===y[key];});}exports.distinctUntilKeyChanged=distinctUntilKeyChanged;//# sourceMappingURL=distinctUntilKeyChanged.js.map
  
  /***/ }),
  /* 89 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/* tslint:enable:max-line-length *//**
   * Perform a side effect for every emission on the source Observable, but return
   * an Observable that is identical to the source.
   *
   * <span class="informal">Intercepts each emission on the source and runs a
   * function, but returns an output which is identical to the source as long as errors don't occur.</span>
   *
   * <img src="./img/do.png" width="100%">
   *
   * Returns a mirrored Observable of the source Observable, but modified so that
   * the provided Observer is called to perform a side effect for every value,
   * error, and completion emitted by the source. Any errors that are thrown in
   * the aforementioned Observer or handlers are safely sent down the error path
   * of the output Observable.
   *
   * This operator is useful for debugging your Observables for the correct values
   * or performing other side effects.
   *
   * Note: this is different to a `subscribe` on the Observable. If the Observable
   * returned by `do` is not subscribed, the side effects specified by the
   * Observer will never happen. `do` therefore simply spies on existing
   * execution, it does not trigger an execution to happen like `subscribe` does.
   *
   * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var positions = clicks
   *   .do(ev => console.log(ev))
   *   .map(ev => ev.clientX);
   * positions.subscribe(x => console.log(x));
   *
   * @see {@link map}
   * @see {@link subscribe}
   *
   * @param {Observer|function} [nextOrObserver] A normal Observer object or a
   * callback for `next`.
   * @param {function} [error] Callback for errors in the source.
   * @param {function} [complete] Callback for the completion of the source.
   * @return {Observable} An Observable identical to the source, but runs the
   * specified Observer or callback(s) for each item.
   * @name tap
   */function tap(nextOrObserver,error,complete){return function tapOperatorFunction(source){return source.lift(new DoOperator(nextOrObserver,error,complete));};}exports.tap=tap;var DoOperator=function(){function DoOperator(nextOrObserver,error,complete){this.nextOrObserver=nextOrObserver;this.error=error;this.complete=complete;}DoOperator.prototype.call=function(subscriber,source){return source.subscribe(new DoSubscriber(subscriber,this.nextOrObserver,this.error,this.complete));};return DoOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var DoSubscriber=function(_super){__extends(DoSubscriber,_super);function DoSubscriber(destination,nextOrObserver,error,complete){_super.call(this,destination);var safeSubscriber=new Subscriber_1.Subscriber(nextOrObserver,error,complete);safeSubscriber.syncErrorThrowable=true;this.add(safeSubscriber);this.safeSubscriber=safeSubscriber;}DoSubscriber.prototype._next=function(value){var safeSubscriber=this.safeSubscriber;safeSubscriber.next(value);if(safeSubscriber.syncErrorThrown){this.destination.error(safeSubscriber.syncErrorValue);}else{this.destination.next(value);}};DoSubscriber.prototype._error=function(err){var safeSubscriber=this.safeSubscriber;safeSubscriber.error(err);if(safeSubscriber.syncErrorThrown){this.destination.error(safeSubscriber.syncErrorValue);}else{this.destination.error(err);}};DoSubscriber.prototype._complete=function(){var safeSubscriber=this.safeSubscriber;safeSubscriber.complete();if(safeSubscriber.syncErrorThrown){this.destination.error(safeSubscriber.syncErrorValue);}else{this.destination.complete();}};return DoSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=tap.js.map
  
  /***/ }),
  /* 90 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Converts a higher-order Observable into a first-order Observable by dropping
   * inner Observables while the previous inner Observable has not yet completed.
   *
   * <span class="informal">Flattens an Observable-of-Observables by dropping the
   * next inner Observables while the current inner is still executing.</span>
   *
   * <img src="./img/exhaust.png" width="100%">
   *
   * `exhaust` subscribes to an Observable that emits Observables, also known as a
   * higher-order Observable. Each time it observes one of these emitted inner
   * Observables, the output Observable begins emitting the items emitted by that
   * inner Observable. So far, it behaves like {@link mergeAll}. However,
   * `exhaust` ignores every new inner Observable if the previous Observable has
   * not yet completed. Once that one completes, it will accept and flatten the
   * next inner Observable and repeat this process.
   *
   * @example <caption>Run a finite timer for each click, only if there is no currently active timer</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(5));
   * var result = higherOrder.exhaust();
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineAll}
   * @see {@link concatAll}
   * @see {@link switch}
   * @see {@link mergeAll}
   * @see {@link exhaustMap}
   * @see {@link zipAll}
   *
   * @return {Observable} An Observable that takes a source of Observables and propagates the first observable
   * exclusively until it completes before subscribing to the next.
   * @method exhaust
   * @owner Observable
   */function exhaust(){return function(source){return source.lift(new SwitchFirstOperator());};}exports.exhaust=exhaust;var SwitchFirstOperator=function(){function SwitchFirstOperator(){}SwitchFirstOperator.prototype.call=function(subscriber,source){return source.subscribe(new SwitchFirstSubscriber(subscriber));};return SwitchFirstOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SwitchFirstSubscriber=function(_super){__extends(SwitchFirstSubscriber,_super);function SwitchFirstSubscriber(destination){_super.call(this,destination);this.hasCompleted=false;this.hasSubscription=false;}SwitchFirstSubscriber.prototype._next=function(value){if(!this.hasSubscription){this.hasSubscription=true;this.add(subscribeToResult_1.subscribeToResult(this,value));}};SwitchFirstSubscriber.prototype._complete=function(){this.hasCompleted=true;if(!this.hasSubscription){this.destination.complete();}};SwitchFirstSubscriber.prototype.notifyComplete=function(innerSub){this.remove(innerSub);this.hasSubscription=false;if(this.hasCompleted){this.destination.complete();}};return SwitchFirstSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=exhaust.js.map
  
  /***/ }),
  /* 91 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable only if the previous projected Observable has completed.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link exhaust}.</span>
   *
   * <img src="./img/exhaustMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. When it projects a source value to
   * an Observable, the output Observable begins emitting the items emitted by
   * that projected Observable. However, `exhaustMap` ignores every new projected
   * Observable if the previous projected Observable has not yet completed. Once
   * that one completes, it will accept and flatten the next projected Observable
   * and repeat this process.
   *
   * @example <caption>Run a finite timer for each click, only if there is no currently active timer</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.exhaustMap((ev) => Rx.Observable.interval(1000).take(5));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaust}
   * @see {@link mergeMap}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable containing projected Observables
   * of each item of the source, ignoring projected Observables that start before
   * their preceding Observable has completed.
   * @method exhaustMap
   * @owner Observable
   */function exhaustMap(project,resultSelector){return function(source){return source.lift(new SwitchFirstMapOperator(project,resultSelector));};}exports.exhaustMap=exhaustMap;var SwitchFirstMapOperator=function(){function SwitchFirstMapOperator(project,resultSelector){this.project=project;this.resultSelector=resultSelector;}SwitchFirstMapOperator.prototype.call=function(subscriber,source){return source.subscribe(new SwitchFirstMapSubscriber(subscriber,this.project,this.resultSelector));};return SwitchFirstMapOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SwitchFirstMapSubscriber=function(_super){__extends(SwitchFirstMapSubscriber,_super);function SwitchFirstMapSubscriber(destination,project,resultSelector){_super.call(this,destination);this.project=project;this.resultSelector=resultSelector;this.hasSubscription=false;this.hasCompleted=false;this.index=0;}SwitchFirstMapSubscriber.prototype._next=function(value){if(!this.hasSubscription){this.tryNext(value);}};SwitchFirstMapSubscriber.prototype.tryNext=function(value){var index=this.index++;var destination=this.destination;try{var result=this.project(value,index);this.hasSubscription=true;this.add(subscribeToResult_1.subscribeToResult(this,result,value,index));}catch(err){destination.error(err);}};SwitchFirstMapSubscriber.prototype._complete=function(){this.hasCompleted=true;if(!this.hasSubscription){this.destination.complete();}};SwitchFirstMapSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;if(resultSelector){this.trySelectResult(outerValue,innerValue,outerIndex,innerIndex);}else{destination.next(innerValue);}};SwitchFirstMapSubscriber.prototype.trySelectResult=function(outerValue,innerValue,outerIndex,innerIndex){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;try{var result=resultSelector(outerValue,innerValue,outerIndex,innerIndex);destination.next(result);}catch(err){destination.error(err);}};SwitchFirstMapSubscriber.prototype.notifyError=function(err){this.destination.error(err);};SwitchFirstMapSubscriber.prototype.notifyComplete=function(innerSub){this.remove(innerSub);this.hasSubscription=false;if(this.hasCompleted){this.destination.complete();}};return SwitchFirstMapSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=exhaustMap.js.map
  
  /***/ }),
  /* 92 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Recursively projects each source value to an Observable which is merged in
   * the output Observable.
   *
   * <span class="informal">It's similar to {@link mergeMap}, but applies the
   * projection function to every source value as well as every output value.
   * It's recursive.</span>
   *
   * <img src="./img/expand.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an Observable, and then merging those resulting Observables and
   * emitting the results of this merger. *Expand* will re-emit on the output
   * Observable every source value. Then, each output value is given to the
   * `project` function which returns an inner Observable to be merged on the
   * output Observable. Those output values resulting from the projection are also
   * given to the `project` function to produce new output values. This is how
   * *expand* behaves recursively.
   *
   * @example <caption>Start emitting the powers of two on every click, at most 10 of them</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var powersOfTwo = clicks
   *   .mapTo(1)
   *   .expand(x => Rx.Observable.of(2 * x).delay(1000))
   *   .take(10);
   * powersOfTwo.subscribe(x => console.log(x));
   *
   * @see {@link mergeMap}
   * @see {@link mergeScan}
   *
   * @param {function(value: T, index: number) => Observable} project A function
   * that, when applied to an item emitted by the source or the output Observable,
   * returns an Observable.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for subscribing to
   * each projected inner Observable.
   * @return {Observable} An Observable that emits the source values and also
   * result of applying the projection function to each value emitted on the
   * output Observable and and merging the results of the Observables obtained
   * from this transformation.
   * @method expand
   * @owner Observable
   */function expand(project,concurrent,scheduler){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}if(scheduler===void 0){scheduler=undefined;}concurrent=(concurrent||0)<1?Number.POSITIVE_INFINITY:concurrent;return function(source){return source.lift(new ExpandOperator(project,concurrent,scheduler));};}exports.expand=expand;var ExpandOperator=function(){function ExpandOperator(project,concurrent,scheduler){this.project=project;this.concurrent=concurrent;this.scheduler=scheduler;}ExpandOperator.prototype.call=function(subscriber,source){return source.subscribe(new ExpandSubscriber(subscriber,this.project,this.concurrent,this.scheduler));};return ExpandOperator;}();exports.ExpandOperator=ExpandOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ExpandSubscriber=function(_super){__extends(ExpandSubscriber,_super);function ExpandSubscriber(destination,project,concurrent,scheduler){_super.call(this,destination);this.project=project;this.concurrent=concurrent;this.scheduler=scheduler;this.index=0;this.active=0;this.hasCompleted=false;if(concurrent<Number.POSITIVE_INFINITY){this.buffer=[];}}ExpandSubscriber.dispatch=function(arg){var subscriber=arg.subscriber,result=arg.result,value=arg.value,index=arg.index;subscriber.subscribeToProjection(result,value,index);};ExpandSubscriber.prototype._next=function(value){var destination=this.destination;if(destination.closed){this._complete();return;}var index=this.index++;if(this.active<this.concurrent){destination.next(value);var result=tryCatch_1.tryCatch(this.project)(value,index);if(result===errorObject_1.errorObject){destination.error(errorObject_1.errorObject.e);}else if(!this.scheduler){this.subscribeToProjection(result,value,index);}else{var state={subscriber:this,result:result,value:value,index:index};this.add(this.scheduler.schedule(ExpandSubscriber.dispatch,0,state));}}else{this.buffer.push(value);}};ExpandSubscriber.prototype.subscribeToProjection=function(result,value,index){this.active++;this.add(subscribeToResult_1.subscribeToResult(this,result,value,index));};ExpandSubscriber.prototype._complete=function(){this.hasCompleted=true;if(this.hasCompleted&&this.active===0){this.destination.complete();}};ExpandSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this._next(innerValue);};ExpandSubscriber.prototype.notifyComplete=function(innerSub){var buffer=this.buffer;this.remove(innerSub);this.active--;if(buffer&&buffer.length>0){this._next(buffer.shift());}if(this.hasCompleted&&this.active===0){this.destination.complete();}};return ExpandSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.ExpandSubscriber=ExpandSubscriber;//# sourceMappingURL=expand.js.map
  
  /***/ }),
  /* 93 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var ArgumentOutOfRangeError_1=__webpack_require__(23);/**
   * Emits the single value at the specified `index` in a sequence of emissions
   * from the source Observable.
   *
   * <span class="informal">Emits only the i-th value, then completes.</span>
   *
   * <img src="./img/elementAt.png" width="100%">
   *
   * `elementAt` returns an Observable that emits the item at the specified
   * `index` in the source Observable, or a default value if that `index` is out
   * of range and the `default` argument is provided. If the `default` argument is
   * not given and the `index` is out of range, the output Observable will emit an
   * `ArgumentOutOfRangeError` error.
   *
   * @example <caption>Emit only the third click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.elementAt(2);
   * result.subscribe(x => console.log(x));
   *
   * // Results in:
   * // click 1 = nothing
   * // click 2 = nothing
   * // click 3 = MouseEvent object logged to console
   *
   * @see {@link first}
   * @see {@link last}
   * @see {@link skip}
   * @see {@link single}
   * @see {@link take}
   *
   * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0` or the
   * Observable has completed before emitting the i-th `next` notification.
   *
   * @param {number} index Is the number `i` for the i-th source emission that has
   * happened since the subscription, starting from the number `0`.
   * @param {T} [defaultValue] The default value returned for missing indices.
   * @return {Observable} An Observable that emits a single item, if it is found.
   * Otherwise, will emit the default value if given. If not, then emits an error.
   * @method elementAt
   * @owner Observable
   */function elementAt(index,defaultValue){return function(source){return source.lift(new ElementAtOperator(index,defaultValue));};}exports.elementAt=elementAt;var ElementAtOperator=function(){function ElementAtOperator(index,defaultValue){this.index=index;this.defaultValue=defaultValue;if(index<0){throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError();}}ElementAtOperator.prototype.call=function(subscriber,source){return source.subscribe(new ElementAtSubscriber(subscriber,this.index,this.defaultValue));};return ElementAtOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ElementAtSubscriber=function(_super){__extends(ElementAtSubscriber,_super);function ElementAtSubscriber(destination,index,defaultValue){_super.call(this,destination);this.index=index;this.defaultValue=defaultValue;}ElementAtSubscriber.prototype._next=function(x){if(this.index--===0){this.destination.next(x);this.destination.complete();}};ElementAtSubscriber.prototype._complete=function(){var destination=this.destination;if(this.index>=0){if(typeof this.defaultValue!=='undefined'){destination.next(this.defaultValue);}else{destination.error(new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError());}}destination.complete();};return ElementAtSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=elementAt.js.map
  
  /***/ }),
  /* 94 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Subscription_1=__webpack_require__(5);/**
   * Returns an Observable that mirrors the source Observable, but will call a specified function when
   * the source terminates on complete or error.
   * @param {function} callback Function to be called when source terminates.
   * @return {Observable} An Observable that mirrors the source, but will call the specified function on termination.
   * @method finally
   * @owner Observable
   */function finalize(callback){return function(source){return source.lift(new FinallyOperator(callback));};}exports.finalize=finalize;var FinallyOperator=function(){function FinallyOperator(callback){this.callback=callback;}FinallyOperator.prototype.call=function(subscriber,source){return source.subscribe(new FinallySubscriber(subscriber,this.callback));};return FinallyOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var FinallySubscriber=function(_super){__extends(FinallySubscriber,_super);function FinallySubscriber(destination,callback){_super.call(this,destination);this.add(new Subscription_1.Subscription(callback));}return FinallySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=finalize.js.map
  
  /***/ }),
  /* 95 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var find_1=__webpack_require__(50);/**
   * Emits only the index of the first value emitted by the source Observable that
   * meets some condition.
   *
   * <span class="informal">It's like {@link find}, but emits the index of the
   * found value, not the value itself.</span>
   *
   * <img src="./img/findIndex.png" width="100%">
   *
   * `findIndex` searches for the first item in the source Observable that matches
   * the specified condition embodied by the `predicate`, and returns the
   * (zero-based) index of the first occurrence in the source. Unlike
   * {@link first}, the `predicate` is required in `findIndex`, and does not emit
   * an error if a valid value is not found.
   *
   * @example <caption>Emit the index of first click that happens on a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.findIndex(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link find}
   * @see {@link first}
   * @see {@link take}
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
   * A function called with each item to test for condition matching.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable} An Observable of the index of the first item that
   * matches the condition.
   * @method find
   * @owner Observable
   */function findIndex(predicate,thisArg){return function(source){return source.lift(new find_1.FindValueOperator(predicate,source,true,thisArg));};}exports.findIndex=findIndex;//# sourceMappingURL=findIndex.js.map
  
  /***/ }),
  /* 96 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var EmptyError_1=__webpack_require__(37);/**
   * Emits only the first value (or the first value that meets some condition)
   * emitted by the source Observable.
   *
   * <span class="informal">Emits only the first value. Or emits only the first
   * value that passes some test.</span>
   *
   * <img src="./img/first.png" width="100%">
   *
   * If called with no arguments, `first` emits the first value of the source
   * Observable, then completes. If called with a `predicate` function, `first`
   * emits the first value of the source that matches the specified condition. It
   * may also take a `resultSelector` function to produce the output value from
   * the input value, and a `defaultValue` to emit in case the source completes
   * before it is able to emit a valid value. Throws an error if `defaultValue`
   * was not provided and a matching element is not found.
   *
   * @example <caption>Emit only the first click that happens on the DOM</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.first();
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Emits the first click that happens on a DIV</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.first(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link find}
   * @see {@link take}
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} [predicate]
   * An optional function called with each item to test for condition matching.
   * @param {function(value: T, index: number): R} [resultSelector] A function to
   * produce the value on the output Observable based on the values
   * and the indices of the source Observable. The arguments passed to this
   * function are:
   * - `value`: the value that was emitted on the source.
   * - `index`: the "index" of the value from the source.
   * @param {R} [defaultValue] The default value emitted in case no valid value
   * was found on the source.
   * @return {Observable<T|R>} An Observable of the first item that matches the
   * condition.
   * @method first
   * @owner Observable
   */function first(predicate,resultSelector,defaultValue){return function(source){return source.lift(new FirstOperator(predicate,resultSelector,defaultValue,source));};}exports.first=first;var FirstOperator=function(){function FirstOperator(predicate,resultSelector,defaultValue,source){this.predicate=predicate;this.resultSelector=resultSelector;this.defaultValue=defaultValue;this.source=source;}FirstOperator.prototype.call=function(observer,source){return source.subscribe(new FirstSubscriber(observer,this.predicate,this.resultSelector,this.defaultValue,this.source));};return FirstOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var FirstSubscriber=function(_super){__extends(FirstSubscriber,_super);function FirstSubscriber(destination,predicate,resultSelector,defaultValue,source){_super.call(this,destination);this.predicate=predicate;this.resultSelector=resultSelector;this.defaultValue=defaultValue;this.source=source;this.index=0;this.hasCompleted=false;this._emitted=false;}FirstSubscriber.prototype._next=function(value){var index=this.index++;if(this.predicate){this._tryPredicate(value,index);}else{this._emit(value,index);}};FirstSubscriber.prototype._tryPredicate=function(value,index){var result;try{result=this.predicate(value,index,this.source);}catch(err){this.destination.error(err);return;}if(result){this._emit(value,index);}};FirstSubscriber.prototype._emit=function(value,index){if(this.resultSelector){this._tryResultSelector(value,index);return;}this._emitFinal(value);};FirstSubscriber.prototype._tryResultSelector=function(value,index){var result;try{result=this.resultSelector(value,index);}catch(err){this.destination.error(err);return;}this._emitFinal(result);};FirstSubscriber.prototype._emitFinal=function(value){var destination=this.destination;if(!this._emitted){this._emitted=true;destination.next(value);destination.complete();this.hasCompleted=true;}};FirstSubscriber.prototype._complete=function(){var destination=this.destination;if(!this.hasCompleted&&typeof this.defaultValue!=='undefined'){destination.next(this.defaultValue);destination.complete();}else if(!this.hasCompleted){destination.error(new EmptyError_1.EmptyError());}};return FirstSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=first.js.map
  
  /***/ }),
  /* 97 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Subscription_1=__webpack_require__(5);var Observable_1=__webpack_require__(0);var Subject_1=__webpack_require__(6);var Map_1=__webpack_require__(300);var FastMap_1=__webpack_require__(302);/* tslint:enable:max-line-length *//**
   * Groups the items emitted by an Observable according to a specified criterion,
   * and emits these grouped items as `GroupedObservables`, one
   * {@link GroupedObservable} per group.
   *
   * <img src="./img/groupBy.png" width="100%">
   *
   * @example <caption>Group objects by id and return as array</caption>
   * Observable.of<Obj>({id: 1, name: 'aze1'},
   *                    {id: 2, name: 'sf2'},
   *                    {id: 2, name: 'dg2'},
   *                    {id: 1, name: 'erg1'},
   *                    {id: 1, name: 'df1'},
   *                    {id: 2, name: 'sfqfb2'},
   *                    {id: 3, name: 'qfs3'},
   *                    {id: 2, name: 'qsgqsfg2'}
   *     )
   *     .groupBy(p => p.id)
   *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], []))
   *     .subscribe(p => console.log(p));
   *
   * // displays:
   * // [ { id: 1, name: 'aze1' },
   * //   { id: 1, name: 'erg1' },
   * //   { id: 1, name: 'df1' } ]
   * //
   * // [ { id: 2, name: 'sf2' },
   * //   { id: 2, name: 'dg2' },
   * //   { id: 2, name: 'sfqfb2' },
   * //   { id: 2, name: 'qsgqsfg2' } ]
   * //
   * // [ { id: 3, name: 'qfs3' } ]
   *
   * @example <caption>Pivot data on the id field</caption>
   * Observable.of<Obj>({id: 1, name: 'aze1'},
   *                    {id: 2, name: 'sf2'},
   *                    {id: 2, name: 'dg2'},
   *                    {id: 1, name: 'erg1'},
   *                    {id: 1, name: 'df1'},
   *                    {id: 2, name: 'sfqfb2'},
   *                    {id: 3, name: 'qfs1'},
   *                    {id: 2, name: 'qsgqsfg2'}
   *                   )
   *     .groupBy(p => p.id, p => p.name)
   *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], ["" + group$.key]))
   *     .map(arr => ({'id': parseInt(arr[0]), 'values': arr.slice(1)}))
   *     .subscribe(p => console.log(p));
   *
   * // displays:
   * // { id: 1, values: [ 'aze1', 'erg1', 'df1' ] }
   * // { id: 2, values: [ 'sf2', 'dg2', 'sfqfb2', 'qsgqsfg2' ] }
   * // { id: 3, values: [ 'qfs1' ] }
   *
   * @param {function(value: T): K} keySelector A function that extracts the key
   * for each item.
   * @param {function(value: T): R} [elementSelector] A function that extracts the
   * return element for each item.
   * @param {function(grouped: GroupedObservable<K,R>): Observable<any>} [durationSelector]
   * A function that returns an Observable to determine how long each group should
   * exist.
   * @return {Observable<GroupedObservable<K,R>>} An Observable that emits
   * GroupedObservables, each of which corresponds to a unique key value and each
   * of which emits those items from the source Observable that share that key
   * value.
   * @method groupBy
   * @owner Observable
   */function groupBy(keySelector,elementSelector,durationSelector,subjectSelector){return function(source){return source.lift(new GroupByOperator(keySelector,elementSelector,durationSelector,subjectSelector));};}exports.groupBy=groupBy;var GroupByOperator=function(){function GroupByOperator(keySelector,elementSelector,durationSelector,subjectSelector){this.keySelector=keySelector;this.elementSelector=elementSelector;this.durationSelector=durationSelector;this.subjectSelector=subjectSelector;}GroupByOperator.prototype.call=function(subscriber,source){return source.subscribe(new GroupBySubscriber(subscriber,this.keySelector,this.elementSelector,this.durationSelector,this.subjectSelector));};return GroupByOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var GroupBySubscriber=function(_super){__extends(GroupBySubscriber,_super);function GroupBySubscriber(destination,keySelector,elementSelector,durationSelector,subjectSelector){_super.call(this,destination);this.keySelector=keySelector;this.elementSelector=elementSelector;this.durationSelector=durationSelector;this.subjectSelector=subjectSelector;this.groups=null;this.attemptedToUnsubscribe=false;this.count=0;}GroupBySubscriber.prototype._next=function(value){var key;try{key=this.keySelector(value);}catch(err){this.error(err);return;}this._group(value,key);};GroupBySubscriber.prototype._group=function(value,key){var groups=this.groups;if(!groups){groups=this.groups=typeof key==='string'?new FastMap_1.FastMap():new Map_1.Map();}var group=groups.get(key);var element;if(this.elementSelector){try{element=this.elementSelector(value);}catch(err){this.error(err);}}else{element=value;}if(!group){group=this.subjectSelector?this.subjectSelector():new Subject_1.Subject();groups.set(key,group);var groupedObservable=new GroupedObservable(key,group,this);this.destination.next(groupedObservable);if(this.durationSelector){var duration=void 0;try{duration=this.durationSelector(new GroupedObservable(key,group));}catch(err){this.error(err);return;}this.add(duration.subscribe(new GroupDurationSubscriber(key,group,this)));}}if(!group.closed){group.next(element);}};GroupBySubscriber.prototype._error=function(err){var groups=this.groups;if(groups){groups.forEach(function(group,key){group.error(err);});groups.clear();}this.destination.error(err);};GroupBySubscriber.prototype._complete=function(){var groups=this.groups;if(groups){groups.forEach(function(group,key){group.complete();});groups.clear();}this.destination.complete();};GroupBySubscriber.prototype.removeGroup=function(key){this.groups.delete(key);};GroupBySubscriber.prototype.unsubscribe=function(){if(!this.closed){this.attemptedToUnsubscribe=true;if(this.count===0){_super.prototype.unsubscribe.call(this);}}};return GroupBySubscriber;}(Subscriber_1.Subscriber);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var GroupDurationSubscriber=function(_super){__extends(GroupDurationSubscriber,_super);function GroupDurationSubscriber(key,group,parent){_super.call(this,group);this.key=key;this.group=group;this.parent=parent;}GroupDurationSubscriber.prototype._next=function(value){this.complete();};GroupDurationSubscriber.prototype._unsubscribe=function(){var _a=this,parent=_a.parent,key=_a.key;this.key=this.parent=null;if(parent){parent.removeGroup(key);}};return GroupDurationSubscriber;}(Subscriber_1.Subscriber);/**
   * An Observable representing values belonging to the same group represented by
   * a common key. The values emitted by a GroupedObservable come from the source
   * Observable. The common key is available as the field `key` on a
   * GroupedObservable instance.
   *
   * @class GroupedObservable<K, T>
   */var GroupedObservable=function(_super){__extends(GroupedObservable,_super);function GroupedObservable(key,groupSubject,refCountSubscription){_super.call(this);this.key=key;this.groupSubject=groupSubject;this.refCountSubscription=refCountSubscription;}GroupedObservable.prototype._subscribe=function(subscriber){var subscription=new Subscription_1.Subscription();var _a=this,refCountSubscription=_a.refCountSubscription,groupSubject=_a.groupSubject;if(refCountSubscription&&!refCountSubscription.closed){subscription.add(new InnerRefCountSubscription(refCountSubscription));}subscription.add(groupSubject.subscribe(subscriber));return subscription;};return GroupedObservable;}(Observable_1.Observable);exports.GroupedObservable=GroupedObservable;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var InnerRefCountSubscription=function(_super){__extends(InnerRefCountSubscription,_super);function InnerRefCountSubscription(parent){_super.call(this);this.parent=parent;parent.count++;}InnerRefCountSubscription.prototype.unsubscribe=function(){var parent=this.parent;if(!parent.closed&&!this.closed){_super.prototype.unsubscribe.call(this);parent.count-=1;if(parent.count===0&&parent.attemptedToUnsubscribe){parent.unsubscribe();}}};return InnerRefCountSubscription;}(Subscription_1.Subscription);//# sourceMappingURL=groupBy.js.map
  
  /***/ }),
  /* 98 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var noop_1=__webpack_require__(41);/**
   * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.
   *
   * <img src="./img/ignoreElements.png" width="100%">
   *
   * @return {Observable} An empty Observable that only calls `complete`
   * or `error`, based on which one is called by the source Observable.
   * @method ignoreElements
   * @owner Observable
   */function ignoreElements(){return function ignoreElementsOperatorFunction(source){return source.lift(new IgnoreElementsOperator());};}exports.ignoreElements=ignoreElements;var IgnoreElementsOperator=function(){function IgnoreElementsOperator(){}IgnoreElementsOperator.prototype.call=function(subscriber,source){return source.subscribe(new IgnoreElementsSubscriber(subscriber));};return IgnoreElementsOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var IgnoreElementsSubscriber=function(_super){__extends(IgnoreElementsSubscriber,_super);function IgnoreElementsSubscriber(){_super.apply(this,arguments);}IgnoreElementsSubscriber.prototype._next=function(unused){noop_1.noop();};return IgnoreElementsSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=ignoreElements.js.map
  
  /***/ }),
  /* 99 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);function isEmpty(){return function(source){return source.lift(new IsEmptyOperator());};}exports.isEmpty=isEmpty;var IsEmptyOperator=function(){function IsEmptyOperator(){}IsEmptyOperator.prototype.call=function(observer,source){return source.subscribe(new IsEmptySubscriber(observer));};return IsEmptyOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var IsEmptySubscriber=function(_super){__extends(IsEmptySubscriber,_super);function IsEmptySubscriber(destination){_super.call(this,destination);}IsEmptySubscriber.prototype.notifyComplete=function(isEmpty){var destination=this.destination;destination.next(isEmpty);destination.complete();};IsEmptySubscriber.prototype._next=function(value){this.notifyComplete(false);};IsEmptySubscriber.prototype._complete=function(){this.notifyComplete(true);};return IsEmptySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=isEmpty.js.map
  
  /***/ }),
  /* 100 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var audit_1=__webpack_require__(51);var timer_1=__webpack_require__(69);/**
   * Ignores source values for `duration` milliseconds, then emits the most recent
   * value from the source Observable, then repeats this process.
   *
   * <span class="informal">When it sees a source values, it ignores that plus
   * the next ones for `duration` milliseconds, and then it emits the most recent
   * value from the source.</span>
   *
   * <img src="./img/auditTime.png" width="100%">
   *
   * `auditTime` is similar to `throttleTime`, but emits the last value from the
   * silenced time window, instead of the first value. `auditTime` emits the most
   * recent value from the source Observable on the output Observable as soon as
   * its internal timer becomes disabled, and ignores source values while the
   * timer is enabled. Initially, the timer is disabled. As soon as the first
   * source value arrives, the timer is enabled. After `duration` milliseconds (or
   * the time unit determined internally by the optional `scheduler`) has passed,
   * the timer is disabled, then the most recent source value is emitted on the
   * output Observable, and this process repeats for the next source value.
   * Optionally takes a {@link IScheduler} for managing timers.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.auditTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttleTime}
   *
   * @param {number} duration Time to wait before emitting the most recent source
   * value, measured in milliseconds or the time unit determined internally
   * by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the rate-limiting behavior.
   * @return {Observable<T>} An Observable that performs rate-limiting of
   * emissions from the source Observable.
   * @method auditTime
   * @owner Observable
   */function auditTime(duration,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return audit_1.audit(function(){return timer_1.timer(duration,scheduler);});}exports.auditTime=auditTime;//# sourceMappingURL=auditTime.js.map
  
  /***/ }),
  /* 101 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var EmptyError_1=__webpack_require__(37);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits only the last item emitted by the source Observable.
   * It optionally takes a predicate function as a parameter, in which case, rather than emitting
   * the last item from the source Observable, the resulting Observable will emit the last item
   * from the source Observable that satisfies the predicate.
   *
   * <img src="./img/last.png" width="100%">
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   * @param {function} predicate - The condition any source emitted item has to satisfy.
   * @return {Observable} An Observable that emits only the last item satisfying the given condition
   * from the source, or an NoSuchElementException if no such items are emitted.
   * @throws - Throws if no items that match the predicate are emitted by the source Observable.
   * @method last
   * @owner Observable
   */function last(predicate,resultSelector,defaultValue){return function(source){return source.lift(new LastOperator(predicate,resultSelector,defaultValue,source));};}exports.last=last;var LastOperator=function(){function LastOperator(predicate,resultSelector,defaultValue,source){this.predicate=predicate;this.resultSelector=resultSelector;this.defaultValue=defaultValue;this.source=source;}LastOperator.prototype.call=function(observer,source){return source.subscribe(new LastSubscriber(observer,this.predicate,this.resultSelector,this.defaultValue,this.source));};return LastOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var LastSubscriber=function(_super){__extends(LastSubscriber,_super);function LastSubscriber(destination,predicate,resultSelector,defaultValue,source){_super.call(this,destination);this.predicate=predicate;this.resultSelector=resultSelector;this.defaultValue=defaultValue;this.source=source;this.hasValue=false;this.index=0;if(typeof defaultValue!=='undefined'){this.lastValue=defaultValue;this.hasValue=true;}}LastSubscriber.prototype._next=function(value){var index=this.index++;if(this.predicate){this._tryPredicate(value,index);}else{if(this.resultSelector){this._tryResultSelector(value,index);return;}this.lastValue=value;this.hasValue=true;}};LastSubscriber.prototype._tryPredicate=function(value,index){var result;try{result=this.predicate(value,index,this.source);}catch(err){this.destination.error(err);return;}if(result){if(this.resultSelector){this._tryResultSelector(value,index);return;}this.lastValue=value;this.hasValue=true;}};LastSubscriber.prototype._tryResultSelector=function(value,index){var result;try{result=this.resultSelector(value,index);}catch(err){this.destination.error(err);return;}this.lastValue=result;this.hasValue=true;};LastSubscriber.prototype._complete=function(){var destination=this.destination;if(this.hasValue){destination.next(this.lastValue);destination.complete();}else{destination.error(new EmptyError_1.EmptyError());}};return LastSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=last.js.map
  
  /***/ }),
  /* 102 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.
   *
   * @example <caption>A simple example emitting true if all elements are less than 5, false otherwise</caption>
   *  Observable.of(1, 2, 3, 4, 5, 6)
   *     .every(x => x < 5)
   *     .subscribe(x => console.log(x)); // -> false
   *
   * @param {function} predicate A function for determining if an item meets a specified condition.
   * @param {any} [thisArg] Optional object to use for `this` in the callback.
   * @return {Observable} An Observable of booleans that determines if all items of the source Observable meet the condition specified.
   * @method every
   * @owner Observable
   */function every(predicate,thisArg){return function(source){return source.lift(new EveryOperator(predicate,thisArg,source));};}exports.every=every;var EveryOperator=function(){function EveryOperator(predicate,thisArg,source){this.predicate=predicate;this.thisArg=thisArg;this.source=source;}EveryOperator.prototype.call=function(observer,source){return source.subscribe(new EverySubscriber(observer,this.predicate,this.thisArg,this.source));};return EveryOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var EverySubscriber=function(_super){__extends(EverySubscriber,_super);function EverySubscriber(destination,predicate,thisArg,source){_super.call(this,destination);this.predicate=predicate;this.thisArg=thisArg;this.source=source;this.index=0;this.thisArg=thisArg||this;}EverySubscriber.prototype.notifyComplete=function(everyValueMatch){this.destination.next(everyValueMatch);this.destination.complete();};EverySubscriber.prototype._next=function(value){var result=false;try{result=this.predicate.call(this.thisArg,value,this.index++,this.source);}catch(err){this.destination.error(err);return;}if(!result){this.notifyComplete(false);}};EverySubscriber.prototype._complete=function(){this.notifyComplete(true);};return EverySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=every.js.map
  
  /***/ }),
  /* 103 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Emits the given constant value on the output Observable every time the source
   * Observable emits a value.
   *
   * <span class="informal">Like {@link map}, but it maps every source value to
   * the same output value every time.</span>
   *
   * <img src="./img/mapTo.png" width="100%">
   *
   * Takes a constant `value` as argument, and emits that whenever the source
   * Observable emits a value. In other words, ignores the actual source value,
   * and simply uses the emission moment to know when to emit the given `value`.
   *
   * @example <caption>Map every click to the string 'Hi'</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var greetings = clicks.mapTo('Hi');
   * greetings.subscribe(x => console.log(x));
   *
   * @see {@link map}
   *
   * @param {any} value The value to map each source value to.
   * @return {Observable} An Observable that emits the given `value` every time
   * the source Observable emits something.
   * @method mapTo
   * @owner Observable
   */function mapTo(value){return function(source){return source.lift(new MapToOperator(value));};}exports.mapTo=mapTo;var MapToOperator=function(){function MapToOperator(value){this.value=value;}MapToOperator.prototype.call=function(subscriber,source){return source.subscribe(new MapToSubscriber(subscriber,this.value));};return MapToOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MapToSubscriber=function(_super){__extends(MapToSubscriber,_super);function MapToSubscriber(destination,value){_super.call(this,destination);this.value=value;}MapToSubscriber.prototype._next=function(x){this.destination.next(this.value);};return MapToSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=mapTo.js.map
  
  /***/ }),
  /* 104 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Notification_1=__webpack_require__(17);/**
   * Represents all of the notifications from the source Observable as `next`
   * emissions marked with their original types within {@link Notification}
   * objects.
   *
   * <span class="informal">Wraps `next`, `error` and `complete` emissions in
   * {@link Notification} objects, emitted as `next` on the output Observable.
   * </span>
   *
   * <img src="./img/materialize.png" width="100%">
   *
   * `materialize` returns an Observable that emits a `next` notification for each
   * `next`, `error`, or `complete` emission of the source Observable. When the
   * source Observable emits `complete`, the output Observable will emit `next` as
   * a Notification of type "complete", and then it will emit `complete` as well.
   * When the source Observable emits `error`, the output will emit `next` as a
   * Notification of type "error", and then `complete`.
   *
   * This operator is useful for producing metadata of the source Observable, to
   * be consumed as `next` emissions. Use it in conjunction with
   * {@link dematerialize}.
   *
   * @example <caption>Convert a faulty Observable to an Observable of Notifications</caption>
   * var letters = Rx.Observable.of('a', 'b', 13, 'd');
   * var upperCase = letters.map(x => x.toUpperCase());
   * var materialized = upperCase.materialize();
   * materialized.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // - Notification {kind: "N", value: "A", error: undefined, hasValue: true}
   * // - Notification {kind: "N", value: "B", error: undefined, hasValue: true}
   * // - Notification {kind: "E", value: undefined, error: TypeError:
   * //   x.toUpperCase is not a function at MapSubscriber.letters.map.x
   * //   [as project] (http://1…, hasValue: false}
   *
   * @see {@link Notification}
   * @see {@link dematerialize}
   *
   * @return {Observable<Notification<T>>} An Observable that emits
   * {@link Notification} objects that wrap the original emissions from the source
   * Observable with metadata.
   * @method materialize
   * @owner Observable
   */function materialize(){return function materializeOperatorFunction(source){return source.lift(new MaterializeOperator());};}exports.materialize=materialize;var MaterializeOperator=function(){function MaterializeOperator(){}MaterializeOperator.prototype.call=function(subscriber,source){return source.subscribe(new MaterializeSubscriber(subscriber));};return MaterializeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MaterializeSubscriber=function(_super){__extends(MaterializeSubscriber,_super);function MaterializeSubscriber(destination){_super.call(this,destination);}MaterializeSubscriber.prototype._next=function(value){this.destination.next(Notification_1.Notification.createNext(value));};MaterializeSubscriber.prototype._error=function(err){var destination=this.destination;destination.next(Notification_1.Notification.createError(err));destination.complete();};MaterializeSubscriber.prototype._complete=function(){var destination=this.destination;destination.next(Notification_1.Notification.createComplete());destination.complete();};return MaterializeSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=materialize.js.map
  
  /***/ }),
  /* 105 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var reduce_1=__webpack_require__(24);/**
   * The Max operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
   * and when source Observable completes it emits a single item: the item with the largest value.
   *
   * <img src="./img/max.png" width="100%">
   *
   * @example <caption>Get the maximal value of a series of numbers</caption>
   * Rx.Observable.of(5, 4, 7, 2, 8)
   *   .max()
   *   .subscribe(x => console.log(x)); // -> 8
   *
   * @example <caption>Use a comparer function to get the maximal item</caption>
   * interface Person {
   *   age: number,
   *   name: string
   * }
   * Observable.of<Person>({age: 7, name: 'Foo'},
   *                       {age: 5, name: 'Bar'},
   *                       {age: 9, name: 'Beer'})
   *           .max<Person>((a: Person, b: Person) => a.age < b.age ? -1 : 1)
   *           .subscribe((x: Person) => console.log(x.name)); // -> 'Beer'
   * }
   *
   * @see {@link min}
   *
   * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
   * value of two items.
   * @return {Observable} An Observable that emits item with the largest value.
   * @method max
   * @owner Observable
   */function max(comparer){var max=typeof comparer==='function'?function(x,y){return comparer(x,y)>0?x:y;}:function(x,y){return x>y?x:y;};return reduce_1.reduce(max);}exports.max=max;//# sourceMappingURL=max.js.map
  
  /***/ }),
  /* 106 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var merge_1=__webpack_require__(33);var merge_2=__webpack_require__(33);exports.mergeStatic=merge_2.merge;/* tslint:enable:max-line-length *//**
   * Creates an output Observable which concurrently emits all values from every
   * given input Observable.
   *
   * <span class="informal">Flattens multiple Observables together by blending
   * their values into one Observable.</span>
   *
   * <img src="./img/merge.png" width="100%">
   *
   * `merge` subscribes to each given input Observable (either the source or an
   * Observable given as argument), and simply forwards (without doing any
   * transformation) all the values from all the input Observables to the output
   * Observable. The output Observable only completes once all input Observables
   * have completed. Any error delivered by an input Observable will be immediately
   * emitted on the output Observable.
   *
   * @example <caption>Merge together two Observables: 1s interval and clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var clicksOrTimer = clicks.merge(timer);
   * clicksOrTimer.subscribe(x => console.log(x));
   *
   * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var concurrent = 2; // the argument
   * var merged = timer1.merge(timer2, timer3, concurrent);
   * merged.subscribe(x => console.log(x));
   *
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   *
   * @param {ObservableInput} other An input Observable to merge with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for managing
   * concurrency of input Observables.
   * @return {Observable} An Observable that emits items that are the result of
   * every input Observable.
   * @method merge
   * @owner Observable
   */function merge(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return function(source){return source.lift.call(merge_1.merge.apply(void 0,[source].concat(observables)));};}exports.merge=merge;//# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 107 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is merged multiple
   * times in the output Observable.
   *
   * <span class="informal">It's like {@link mergeMap}, but maps each value always
   * to the same inner Observable.</span>
   *
   * <img src="./img/mergeMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then merges those resulting Observables into one
   * single Observable, which is the output Observable.
   *
   * @example <caption>For each click event, start an interval Observable ticking every 1 second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.mergeMapTo(Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMapTo}
   * @see {@link merge}
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeScan}
   * @see {@link switchMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable.
   * @method mergeMapTo
   * @owner Observable
   */function mergeMapTo(innerObservable,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}if(typeof resultSelector==='number'){concurrent=resultSelector;resultSelector=null;}return function(source){return source.lift(new MergeMapToOperator(innerObservable,resultSelector,concurrent));};}exports.mergeMapTo=mergeMapTo;// TODO: Figure out correct signature here: an Operator<Observable<T>, R>
  //       needs to implement call(observer: Subscriber<R>): Subscriber<Observable<T>>
  var MergeMapToOperator=function(){function MergeMapToOperator(ish,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}this.ish=ish;this.resultSelector=resultSelector;this.concurrent=concurrent;}MergeMapToOperator.prototype.call=function(observer,source){return source.subscribe(new MergeMapToSubscriber(observer,this.ish,this.resultSelector,this.concurrent));};return MergeMapToOperator;}();exports.MergeMapToOperator=MergeMapToOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MergeMapToSubscriber=function(_super){__extends(MergeMapToSubscriber,_super);function MergeMapToSubscriber(destination,ish,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}_super.call(this,destination);this.ish=ish;this.resultSelector=resultSelector;this.concurrent=concurrent;this.hasCompleted=false;this.buffer=[];this.active=0;this.index=0;}MergeMapToSubscriber.prototype._next=function(value){if(this.active<this.concurrent){var resultSelector=this.resultSelector;var index=this.index++;var ish=this.ish;var destination=this.destination;this.active++;this._innerSub(ish,destination,resultSelector,value,index);}else{this.buffer.push(value);}};MergeMapToSubscriber.prototype._innerSub=function(ish,destination,resultSelector,value,index){this.add(subscribeToResult_1.subscribeToResult(this,ish,value,index));};MergeMapToSubscriber.prototype._complete=function(){this.hasCompleted=true;if(this.active===0&&this.buffer.length===0){this.destination.complete();}};MergeMapToSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;if(resultSelector){this.trySelectResult(outerValue,innerValue,outerIndex,innerIndex);}else{destination.next(innerValue);}};MergeMapToSubscriber.prototype.trySelectResult=function(outerValue,innerValue,outerIndex,innerIndex){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;var result;try{result=resultSelector(outerValue,innerValue,outerIndex,innerIndex);}catch(err){destination.error(err);return;}destination.next(result);};MergeMapToSubscriber.prototype.notifyError=function(err){this.destination.error(err);};MergeMapToSubscriber.prototype.notifyComplete=function(innerSub){var buffer=this.buffer;this.remove(innerSub);this.active--;if(buffer.length>0){this._next(buffer.shift());}else if(this.active===0&&this.hasCompleted){this.destination.complete();}};return MergeMapToSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.MergeMapToSubscriber=MergeMapToSubscriber;//# sourceMappingURL=mergeMapTo.js.map
  
  /***/ }),
  /* 108 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * Applies an accumulator function over the source Observable where the
   * accumulator function itself returns an Observable, then each intermediate
   * Observable returned is merged into the output Observable.
   *
   * <span class="informal">It's like {@link scan}, but the Observables returned
   * by the accumulator are merged into the outer Observable.</span>
   *
   * @example <caption>Count the number of click events</caption>
   * const click$ = Rx.Observable.fromEvent(document, 'click');
   * const one$ = click$.mapTo(1);
   * const seed = 0;
   * const count$ = one$.mergeScan((acc, one) => Rx.Observable.of(acc + one), seed);
   * count$.subscribe(x => console.log(x));
   *
   * // Results:
   * 1
   * 2
   * 3
   * 4
   * // ...and so on for each click
   *
   * @param {function(acc: R, value: T): Observable<R>} accumulator
   * The accumulator function called on each source value.
   * @param seed The initial accumulation value.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of
   * input Observables being subscribed to concurrently.
   * @return {Observable<R>} An observable of the accumulated values.
   * @method mergeScan
   * @owner Observable
   */function mergeScan(accumulator,seed,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return function(source){return source.lift(new MergeScanOperator(accumulator,seed,concurrent));};}exports.mergeScan=mergeScan;var MergeScanOperator=function(){function MergeScanOperator(accumulator,seed,concurrent){this.accumulator=accumulator;this.seed=seed;this.concurrent=concurrent;}MergeScanOperator.prototype.call=function(subscriber,source){return source.subscribe(new MergeScanSubscriber(subscriber,this.accumulator,this.seed,this.concurrent));};return MergeScanOperator;}();exports.MergeScanOperator=MergeScanOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var MergeScanSubscriber=function(_super){__extends(MergeScanSubscriber,_super);function MergeScanSubscriber(destination,accumulator,acc,concurrent){_super.call(this,destination);this.accumulator=accumulator;this.acc=acc;this.concurrent=concurrent;this.hasValue=false;this.hasCompleted=false;this.buffer=[];this.active=0;this.index=0;}MergeScanSubscriber.prototype._next=function(value){if(this.active<this.concurrent){var index=this.index++;var ish=tryCatch_1.tryCatch(this.accumulator)(this.acc,value);var destination=this.destination;if(ish===errorObject_1.errorObject){destination.error(errorObject_1.errorObject.e);}else{this.active++;this._innerSub(ish,value,index);}}else{this.buffer.push(value);}};MergeScanSubscriber.prototype._innerSub=function(ish,value,index){this.add(subscribeToResult_1.subscribeToResult(this,ish,value,index));};MergeScanSubscriber.prototype._complete=function(){this.hasCompleted=true;if(this.active===0&&this.buffer.length===0){if(this.hasValue===false){this.destination.next(this.acc);}this.destination.complete();}};MergeScanSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var destination=this.destination;this.acc=innerValue;this.hasValue=true;destination.next(innerValue);};MergeScanSubscriber.prototype.notifyComplete=function(innerSub){var buffer=this.buffer;this.remove(innerSub);this.active--;if(buffer.length>0){this._next(buffer.shift());}else if(this.active===0&&this.hasCompleted){if(this.hasValue===false){this.destination.next(this.acc);}this.destination.complete();}};return MergeScanSubscriber;}(OuterSubscriber_1.OuterSubscriber);exports.MergeScanSubscriber=MergeScanSubscriber;//# sourceMappingURL=mergeScan.js.map
  
  /***/ }),
  /* 109 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var reduce_1=__webpack_require__(24);/**
   * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
   * and when source Observable completes it emits a single item: the item with the smallest value.
   *
   * <img src="./img/min.png" width="100%">
   *
   * @example <caption>Get the minimal value of a series of numbers</caption>
   * Rx.Observable.of(5, 4, 7, 2, 8)
   *   .min()
   *   .subscribe(x => console.log(x)); // -> 2
   *
   * @example <caption>Use a comparer function to get the minimal item</caption>
   * interface Person {
   *   age: number,
   *   name: string
   * }
   * Observable.of<Person>({age: 7, name: 'Foo'},
   *                       {age: 5, name: 'Bar'},
   *                       {age: 9, name: 'Beer'})
   *           .min<Person>( (a: Person, b: Person) => a.age < b.age ? -1 : 1)
   *           .subscribe((x: Person) => console.log(x.name)); // -> 'Bar'
   * }
   *
   * @see {@link max}
   *
   * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
   * value of two items.
   * @return {Observable<R>} An Observable that emits item with the smallest value.
   * @method min
   * @owner Observable
   */function min(comparer){var min=typeof comparer==='function'?function(x,y){return comparer(x,y)<0?x:y;}:function(x,y){return x<y?x:y;};return reduce_1.reduce(min);}exports.min=min;//# sourceMappingURL=min.js.map
  
  /***/ }),
  /* 110 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var Observable_1=__webpack_require__(0);var Subscriber_1=__webpack_require__(1);var Subscription_1=__webpack_require__(5);var refCount_1=__webpack_require__(54);/**
   * @class ConnectableObservable<T>
   */var ConnectableObservable=function(_super){__extends(ConnectableObservable,_super);function ConnectableObservable(source,subjectFactory){_super.call(this);this.source=source;this.subjectFactory=subjectFactory;this._refCount=0;this._isComplete=false;}ConnectableObservable.prototype._subscribe=function(subscriber){return this.getSubject().subscribe(subscriber);};ConnectableObservable.prototype.getSubject=function(){var subject=this._subject;if(!subject||subject.isStopped){this._subject=this.subjectFactory();}return this._subject;};ConnectableObservable.prototype.connect=function(){var connection=this._connection;if(!connection){this._isComplete=false;connection=this._connection=new Subscription_1.Subscription();connection.add(this.source.subscribe(new ConnectableSubscriber(this.getSubject(),this)));if(connection.closed){this._connection=null;connection=Subscription_1.Subscription.EMPTY;}else{this._connection=connection;}}return connection;};ConnectableObservable.prototype.refCount=function(){return refCount_1.refCount()(this);};return ConnectableObservable;}(Observable_1.Observable);exports.ConnectableObservable=ConnectableObservable;var connectableProto=ConnectableObservable.prototype;exports.connectableObservableDescriptor={operator:{value:null},_refCount:{value:0,writable:true},_subject:{value:null,writable:true},_connection:{value:null,writable:true},_subscribe:{value:connectableProto._subscribe},_isComplete:{value:connectableProto._isComplete,writable:true},getSubject:{value:connectableProto.getSubject},connect:{value:connectableProto.connect},refCount:{value:connectableProto.refCount}};var ConnectableSubscriber=function(_super){__extends(ConnectableSubscriber,_super);function ConnectableSubscriber(destination,connectable){_super.call(this,destination);this.connectable=connectable;}ConnectableSubscriber.prototype._error=function(err){this._unsubscribe();_super.prototype._error.call(this,err);};ConnectableSubscriber.prototype._complete=function(){this.connectable._isComplete=true;this._unsubscribe();_super.prototype._complete.call(this);};ConnectableSubscriber.prototype._unsubscribe=function(){var connectable=this.connectable;if(connectable){this.connectable=null;var connection=connectable._connection;connectable._refCount=0;connectable._subject=null;connectable._connection=null;if(connection){connection.unsubscribe();}}};return ConnectableSubscriber;}(Subject_1.SubjectSubscriber);var RefCountOperator=function(){function RefCountOperator(connectable){this.connectable=connectable;}RefCountOperator.prototype.call=function(subscriber,source){var connectable=this.connectable;connectable._refCount++;var refCounter=new RefCountSubscriber(subscriber,connectable);var subscription=source.subscribe(refCounter);if(!refCounter.closed){refCounter.connection=connectable.connect();}return subscription;};return RefCountOperator;}();var RefCountSubscriber=function(_super){__extends(RefCountSubscriber,_super);function RefCountSubscriber(destination,connectable){_super.call(this,destination);this.connectable=connectable;}RefCountSubscriber.prototype._unsubscribe=function(){var connectable=this.connectable;if(!connectable){this.connection=null;return;}this.connectable=null;var refCount=connectable._refCount;if(refCount<=0){this.connection=null;return;}connectable._refCount=refCount-1;if(refCount>1){this.connection=null;return;}///
  // Compare the local RefCountSubscriber's connection Subscription to the
  // connection Subscription on the shared ConnectableObservable. In cases
  // where the ConnectableObservable source synchronously emits values, and
  // the RefCountSubscriber's downstream Observers synchronously unsubscribe,
  // execution continues to here before the RefCountOperator has a chance to
  // supply the RefCountSubscriber with the shared connection Subscription.
  // For example:
  // ```
  // Observable.range(0, 10)
  //   .publish()
  //   .refCount()
  //   .take(5)
  //   .subscribe();
  // ```
  // In order to account for this case, RefCountSubscriber should only dispose
  // the ConnectableObservable's shared connection Subscription if the
  // connection Subscription exists, *and* either:
  //   a. RefCountSubscriber doesn't have a reference to the shared connection
  //      Subscription yet, or,
  //   b. RefCountSubscriber's connection Subscription reference is identical
  //      to the shared connection Subscription
  ///
  var connection=this.connection;var sharedConnection=connectable._connection;this.connection=null;if(sharedConnection&&(!connection||sharedConnection===connection)){sharedConnection.unsubscribe();}};return RefCountSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=ConnectableObservable.js.map
  
  /***/ }),
  /* 111 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Groups pairs of consecutive emissions together and emits them as an array of
   * two values.
   *
   * <span class="informal">Puts the current value and previous value together as
   * an array, and emits that.</span>
   *
   * <img src="./img/pairwise.png" width="100%">
   *
   * The Nth emission from the source Observable will cause the output Observable
   * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
   * pair. For this reason, `pairwise` emits on the second and subsequent
   * emissions from the source Observable, but not on the first emission, because
   * there is no previous value in that case.
   *
   * @example <caption>On every click (starting from the second), emit the relative distance to the previous click</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var pairs = clicks.pairwise();
   * var distance = pairs.map(pair => {
   *   var x0 = pair[0].clientX;
   *   var y0 = pair[0].clientY;
   *   var x1 = pair[1].clientX;
   *   var y1 = pair[1].clientY;
   *   return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
   * });
   * distance.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   *
   * @return {Observable<Array<T>>} An Observable of pairs (as arrays) of
   * consecutive values from the source Observable.
   * @method pairwise
   * @owner Observable
   */function pairwise(){return function(source){return source.lift(new PairwiseOperator());};}exports.pairwise=pairwise;var PairwiseOperator=function(){function PairwiseOperator(){}PairwiseOperator.prototype.call=function(subscriber,source){return source.subscribe(new PairwiseSubscriber(subscriber));};return PairwiseOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var PairwiseSubscriber=function(_super){__extends(PairwiseSubscriber,_super);function PairwiseSubscriber(destination){_super.call(this,destination);this.hasPrev=false;}PairwiseSubscriber.prototype._next=function(value){if(this.hasPrev){this.destination.next([this.prev,value]);}else{this.hasPrev=true;}this.prev=value;};return PairwiseSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=pairwise.js.map
  
  /***/ }),
  /* 112 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var not_1=__webpack_require__(347);var filter_1=__webpack_require__(49);/**
   * Splits the source Observable into two, one with values that satisfy a
   * predicate, and another with values that don't satisfy the predicate.
   *
   * <span class="informal">It's like {@link filter}, but returns two Observables:
   * one like the output of {@link filter}, and the other with values that did not
   * pass the condition.</span>
   *
   * <img src="./img/partition.png" width="100%">
   *
   * `partition` outputs an array with two Observables that partition the values
   * from the source Observable through the given `predicate` function. The first
   * Observable in that array emits source values for which the predicate argument
   * returns true. The second Observable emits source values for which the
   * predicate returns false. The first behaves like {@link filter} and the second
   * behaves like {@link filter} with the predicate negated.
   *
   * @example <caption>Partition click events into those on DIV elements and those elsewhere</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var parts = clicks.partition(ev => ev.target.tagName === 'DIV');
   * var clicksOnDivs = parts[0];
   * var clicksElsewhere = parts[1];
   * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
   * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
   *
   * @see {@link filter}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates each value emitted by the source Observable. If it returns `true`,
   * the value is emitted on the first Observable in the returned array, if
   * `false` the value is emitted on the second Observable in the array. The
   * `index` parameter is the number `i` for the i-th source emission that has
   * happened since the subscription, starting from the number `0`.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {[Observable<T>, Observable<T>]} An array with two Observables: one
   * with values that passed the predicate, and another with values that did not
   * pass the predicate.
   * @method partition
   * @owner Observable
   */function partition(predicate,thisArg){return function(source){return[filter_1.filter(predicate,thisArg)(source),filter_1.filter(not_1.not(predicate,thisArg))(source)];};}exports.partition=partition;//# sourceMappingURL=partition.js.map
  
  /***/ }),
  /* 113 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var map_1=__webpack_require__(22);/**
   * Maps each source value (an object) to its specified nested property.
   *
   * <span class="informal">Like {@link map}, but meant only for picking one of
   * the nested properties of every emitted object.</span>
   *
   * <img src="./img/pluck.png" width="100%">
   *
   * Given a list of strings describing a path to an object property, retrieves
   * the value of a specified nested property from all values in the source
   * Observable. If a property can't be resolved, it will return `undefined` for
   * that value.
   *
   * @example <caption>Map every click to the tagName of the clicked target element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var tagNames = clicks.pluck('target', 'tagName');
   * tagNames.subscribe(x => console.log(x));
   *
   * @see {@link map}
   *
   * @param {...string} properties The nested properties to pluck from each source
   * value (an object).
   * @return {Observable} A new Observable of property values from the source values.
   * @method pluck
   * @owner Observable
   */function pluck(){var properties=[];for(var _i=0;_i<arguments.length;_i++){properties[_i-0]=arguments[_i];}var length=properties.length;if(length===0){throw new Error('list of properties cannot be empty.');}return function(source){return map_1.map(plucker(properties,length))(source);};}exports.pluck=pluck;function plucker(props,length){var mapper=function mapper(x){var currentProp=x;for(var i=0;i<length;i++){var p=currentProp[props[i]];if(typeof p!=='undefined'){currentProp=p;}else{return undefined;}}return currentProp;};return mapper;}//# sourceMappingURL=pluck.js.map
  
  /***/ }),
  /* 114 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Subject_1=__webpack_require__(6);var multicast_1=__webpack_require__(14);/* tslint:enable:max-line-length *//**
   * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
   * before it begins emitting items to those Observers that have subscribed to it.
   *
   * <img src="./img/publish.png" width="100%">
   *
   * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times
   * as needed, without causing multiple subscriptions to the source sequence.
   * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
   * @return A ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.
   * @method publish
   * @owner Observable
   */function publish(selector){return selector?multicast_1.multicast(function(){return new Subject_1.Subject();},selector):multicast_1.multicast(new Subject_1.Subject());}exports.publish=publish;//# sourceMappingURL=publish.js.map
  
  /***/ }),
  /* 115 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var BehaviorSubject_1=__webpack_require__(116);var multicast_1=__webpack_require__(14);/**
   * @param value
   * @return {ConnectableObservable<T>}
   * @method publishBehavior
   * @owner Observable
   */function publishBehavior(value){return function(source){return multicast_1.multicast(new BehaviorSubject_1.BehaviorSubject(value))(source);};}exports.publishBehavior=publishBehavior;//# sourceMappingURL=publishBehavior.js.map
  
  /***/ }),
  /* 116 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var ObjectUnsubscribedError_1=__webpack_require__(28);/**
   * @class BehaviorSubject<T>
   */var BehaviorSubject=function(_super){__extends(BehaviorSubject,_super);function BehaviorSubject(_value){_super.call(this);this._value=_value;}Object.defineProperty(BehaviorSubject.prototype,"value",{get:function get(){return this.getValue();},enumerable:true,configurable:true});BehaviorSubject.prototype._subscribe=function(subscriber){var subscription=_super.prototype._subscribe.call(this,subscriber);if(subscription&&!subscription.closed){subscriber.next(this._value);}return subscription;};BehaviorSubject.prototype.getValue=function(){if(this.hasError){throw this.thrownError;}else if(this.closed){throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();}else{return this._value;}};BehaviorSubject.prototype.next=function(value){_super.prototype.next.call(this,this._value=value);};return BehaviorSubject;}(Subject_1.Subject);exports.BehaviorSubject=BehaviorSubject;//# sourceMappingURL=BehaviorSubject.js.map
  
  /***/ }),
  /* 117 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ReplaySubject_1=__webpack_require__(36);var multicast_1=__webpack_require__(14);/* tslint:enable:max-line-length */function publishReplay(bufferSize,windowTime,selectorOrScheduler,scheduler){if(selectorOrScheduler&&typeof selectorOrScheduler!=='function'){scheduler=selectorOrScheduler;}var selector=typeof selectorOrScheduler==='function'?selectorOrScheduler:undefined;var subject=new ReplaySubject_1.ReplaySubject(bufferSize,windowTime,scheduler);return function(source){return multicast_1.multicast(function(){return subject;},selector)(source);};}exports.publishReplay=publishReplay;//# sourceMappingURL=publishReplay.js.map
  
  /***/ }),
  /* 118 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var AsyncSubject_1=__webpack_require__(29);var multicast_1=__webpack_require__(14);function publishLast(){return function(source){return multicast_1.multicast(new AsyncSubject_1.AsyncSubject())(source);};}exports.publishLast=publishLast;//# sourceMappingURL=publishLast.js.map
  
  /***/ }),
  /* 119 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var isArray_1=__webpack_require__(11);var race_1=__webpack_require__(44);/* tslint:enable:max-line-length *//**
   * Returns an Observable that mirrors the first source Observable to emit an item
   * from the combination of this Observable and supplied Observables.
   * @param {...Observables} ...observables Sources used to race for which Observable emits first.
   * @return {Observable} An Observable that mirrors the output of the first Observable to emit an item.
   * @method race
   * @owner Observable
   */function race(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return function raceOperatorFunction(source){// if the only argument is an array, it was most likely called with
  // `pair([obs1, obs2, ...])`
  if(observables.length===1&&isArray_1.isArray(observables[0])){observables=observables[0];}return source.lift.call(race_1.race.apply(void 0,[source].concat(observables)));};}exports.race=race;//# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 120 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var EmptyObservable_1=__webpack_require__(13);/**
   * Returns an Observable that repeats the stream of items emitted by the source Observable at most count times.
   *
   * <img src="./img/repeat.png" width="100%">
   *
   * @param {number} [count] The number of times the source Observable items are repeated, a count of 0 will yield
   * an empty Observable.
   * @return {Observable} An Observable that repeats the stream of items emitted by the source Observable at most
   * count times.
   * @method repeat
   * @owner Observable
   */function repeat(count){if(count===void 0){count=-1;}return function(source){if(count===0){return new EmptyObservable_1.EmptyObservable();}else if(count<0){return source.lift(new RepeatOperator(-1,source));}else{return source.lift(new RepeatOperator(count-1,source));}};}exports.repeat=repeat;var RepeatOperator=function(){function RepeatOperator(count,source){this.count=count;this.source=source;}RepeatOperator.prototype.call=function(subscriber,source){return source.subscribe(new RepeatSubscriber(subscriber,this.count,this.source));};return RepeatOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var RepeatSubscriber=function(_super){__extends(RepeatSubscriber,_super);function RepeatSubscriber(destination,count,source){_super.call(this,destination);this.count=count;this.source=source;}RepeatSubscriber.prototype.complete=function(){if(!this.isStopped){var _a=this,source=_a.source,count=_a.count;if(count===0){return _super.prototype.complete.call(this);}else if(count>-1){this.count=count-1;}source.subscribe(this._unsubscribeAndRecycle());}};return RepeatSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=repeat.js.map
  
  /***/ }),
  /* 121 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
   * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
   * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
   * this method will resubscribe to the source Observable.
   *
   * <img src="./img/repeatWhen.png" width="100%">
   *
   * @param {function(notifications: Observable): Observable} notifier - Receives an Observable of notifications with
   * which a user can `complete` or `error`, aborting the repetition.
   * @return {Observable} The source Observable modified with repeat logic.
   * @method repeatWhen
   * @owner Observable
   */function repeatWhen(notifier){return function(source){return source.lift(new RepeatWhenOperator(notifier));};}exports.repeatWhen=repeatWhen;var RepeatWhenOperator=function(){function RepeatWhenOperator(notifier){this.notifier=notifier;}RepeatWhenOperator.prototype.call=function(subscriber,source){return source.subscribe(new RepeatWhenSubscriber(subscriber,this.notifier,source));};return RepeatWhenOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var RepeatWhenSubscriber=function(_super){__extends(RepeatWhenSubscriber,_super);function RepeatWhenSubscriber(destination,notifier,source){_super.call(this,destination);this.notifier=notifier;this.source=source;this.sourceIsBeingSubscribedTo=true;}RepeatWhenSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.sourceIsBeingSubscribedTo=true;this.source.subscribe(this);};RepeatWhenSubscriber.prototype.notifyComplete=function(innerSub){if(this.sourceIsBeingSubscribedTo===false){return _super.prototype.complete.call(this);}};RepeatWhenSubscriber.prototype.complete=function(){this.sourceIsBeingSubscribedTo=false;if(!this.isStopped){if(!this.retries){this.subscribeToRetries();}else if(this.retriesSubscription.closed){return _super.prototype.complete.call(this);}this._unsubscribeAndRecycle();this.notifications.next();}};RepeatWhenSubscriber.prototype._unsubscribe=function(){var _a=this,notifications=_a.notifications,retriesSubscription=_a.retriesSubscription;if(notifications){notifications.unsubscribe();this.notifications=null;}if(retriesSubscription){retriesSubscription.unsubscribe();this.retriesSubscription=null;}this.retries=null;};RepeatWhenSubscriber.prototype._unsubscribeAndRecycle=function(){var _a=this,notifications=_a.notifications,retries=_a.retries,retriesSubscription=_a.retriesSubscription;this.notifications=null;this.retries=null;this.retriesSubscription=null;_super.prototype._unsubscribeAndRecycle.call(this);this.notifications=notifications;this.retries=retries;this.retriesSubscription=retriesSubscription;return this;};RepeatWhenSubscriber.prototype.subscribeToRetries=function(){this.notifications=new Subject_1.Subject();var retries=tryCatch_1.tryCatch(this.notifier)(this.notifications);if(retries===errorObject_1.errorObject){return _super.prototype.complete.call(this);}this.retries=retries;this.retriesSubscription=subscribeToResult_1.subscribeToResult(this,retries);};return RepeatWhenSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=repeatWhen.js.map
  
  /***/ }),
  /* 122 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
   * calls `error`, this method will resubscribe to the source Observable for a maximum of `count` resubscriptions (given
   * as a number parameter) rather than propagating the `error` call.
   *
   * <img src="./img/retry.png" width="100%">
   *
   * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted
   * during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second
   * time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications
   * would be: [1, 2, 1, 2, 3, 4, 5, `complete`].
   * @param {number} count - Number of retry attempts before failing.
   * @return {Observable} The source Observable modified with the retry logic.
   * @method retry
   * @owner Observable
   */function retry(count){if(count===void 0){count=-1;}return function(source){return source.lift(new RetryOperator(count,source));};}exports.retry=retry;var RetryOperator=function(){function RetryOperator(count,source){this.count=count;this.source=source;}RetryOperator.prototype.call=function(subscriber,source){return source.subscribe(new RetrySubscriber(subscriber,this.count,this.source));};return RetryOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var RetrySubscriber=function(_super){__extends(RetrySubscriber,_super);function RetrySubscriber(destination,count,source){_super.call(this,destination);this.count=count;this.source=source;}RetrySubscriber.prototype.error=function(err){if(!this.isStopped){var _a=this,source=_a.source,count=_a.count;if(count===0){return _super.prototype.error.call(this,err);}else if(count>-1){this.count=count-1;}source.subscribe(this._unsubscribeAndRecycle());}};return RetrySubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=retry.js.map
  
  /***/ }),
  /* 123 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
   * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.
   * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
   * subscription. Otherwise this method will resubscribe to the source Observable.
   *
   * <img src="./img/retryWhen.png" width="100%">
   *
   * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a
   * user can `complete` or `error`, aborting the retry.
   * @return {Observable} The source Observable modified with retry logic.
   * @method retryWhen
   * @owner Observable
   */function retryWhen(notifier){return function(source){return source.lift(new RetryWhenOperator(notifier,source));};}exports.retryWhen=retryWhen;var RetryWhenOperator=function(){function RetryWhenOperator(notifier,source){this.notifier=notifier;this.source=source;}RetryWhenOperator.prototype.call=function(subscriber,source){return source.subscribe(new RetryWhenSubscriber(subscriber,this.notifier,this.source));};return RetryWhenOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var RetryWhenSubscriber=function(_super){__extends(RetryWhenSubscriber,_super);function RetryWhenSubscriber(destination,notifier,source){_super.call(this,destination);this.notifier=notifier;this.source=source;}RetryWhenSubscriber.prototype.error=function(err){if(!this.isStopped){var errors=this.errors;var retries=this.retries;var retriesSubscription=this.retriesSubscription;if(!retries){errors=new Subject_1.Subject();retries=tryCatch_1.tryCatch(this.notifier)(errors);if(retries===errorObject_1.errorObject){return _super.prototype.error.call(this,errorObject_1.errorObject.e);}retriesSubscription=subscribeToResult_1.subscribeToResult(this,retries);}else{this.errors=null;this.retriesSubscription=null;}this._unsubscribeAndRecycle();this.errors=errors;this.retries=retries;this.retriesSubscription=retriesSubscription;errors.next(err);}};RetryWhenSubscriber.prototype._unsubscribe=function(){var _a=this,errors=_a.errors,retriesSubscription=_a.retriesSubscription;if(errors){errors.unsubscribe();this.errors=null;}if(retriesSubscription){retriesSubscription.unsubscribe();this.retriesSubscription=null;}this.retries=null;};RetryWhenSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var _a=this,errors=_a.errors,retries=_a.retries,retriesSubscription=_a.retriesSubscription;this.errors=null;this.retries=null;this.retriesSubscription=null;this._unsubscribeAndRecycle();this.errors=errors;this.retries=retries;this.retriesSubscription=retriesSubscription;this.source.subscribe(this);};return RetryWhenSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  /* 124 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Emits the most recently emitted value from the source Observable whenever
   * another Observable, the `notifier`, emits.
   *
   * <span class="informal">It's like {@link sampleTime}, but samples whenever
   * the `notifier` Observable emits something.</span>
   *
   * <img src="./img/sample.png" width="100%">
   *
   * Whenever the `notifier` Observable emits a value or completes, `sample`
   * looks at the source Observable and emits whichever value it has most recently
   * emitted since the previous sampling, unless the source has not emitted
   * anything since the previous sampling. The `notifier` is subscribed to as soon
   * as the output Observable is subscribed.
   *
   * @example <caption>On every click, sample the most recent "seconds" timer</caption>
   * var seconds = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = seconds.sample(clicks);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounce}
   * @see {@link sampleTime}
   * @see {@link throttle}
   *
   * @param {Observable<any>} notifier The Observable to use for sampling the
   * source Observable.
   * @return {Observable<T>} An Observable that emits the results of sampling the
   * values emitted by the source Observable whenever the notifier Observable
   * emits value or completes.
   * @method sample
   * @owner Observable
   */function sample(notifier){return function(source){return source.lift(new SampleOperator(notifier));};}exports.sample=sample;var SampleOperator=function(){function SampleOperator(notifier){this.notifier=notifier;}SampleOperator.prototype.call=function(subscriber,source){var sampleSubscriber=new SampleSubscriber(subscriber);var subscription=source.subscribe(sampleSubscriber);subscription.add(subscribeToResult_1.subscribeToResult(sampleSubscriber,this.notifier));return subscription;};return SampleOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SampleSubscriber=function(_super){__extends(SampleSubscriber,_super);function SampleSubscriber(){_super.apply(this,arguments);this.hasValue=false;}SampleSubscriber.prototype._next=function(value){this.value=value;this.hasValue=true;};SampleSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.emitValue();};SampleSubscriber.prototype.notifyComplete=function(){this.emitValue();};SampleSubscriber.prototype.emitValue=function(){if(this.hasValue){this.hasValue=false;this.destination.next(this.value);}};return SampleSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=sample.js.map
  
  /***/ }),
  /* 125 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var async_1=__webpack_require__(4);/**
   * Emits the most recently emitted value from the source Observable within
   * periodic time intervals.
   *
   * <span class="informal">Samples the source Observable at periodic time
   * intervals, emitting what it samples.</span>
   *
   * <img src="./img/sampleTime.png" width="100%">
   *
   * `sampleTime` periodically looks at the source Observable and emits whichever
   * value it has most recently emitted since the previous sampling, unless the
   * source has not emitted anything since the previous sampling. The sampling
   * happens periodically in time every `period` milliseconds (or the time unit
   * defined by the optional `scheduler` argument). The sampling starts as soon as
   * the output Observable is subscribed.
   *
   * @example <caption>Every second, emit the most recent click at most once</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.sampleTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sample}
   * @see {@link throttleTime}
   *
   * @param {number} period The sampling period expressed in milliseconds or the
   * time unit determined internally by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the sampling.
   * @return {Observable<T>} An Observable that emits the results of sampling the
   * values emitted by the source Observable at the specified time interval.
   * @method sampleTime
   * @owner Observable
   */function sampleTime(period,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return function(source){return source.lift(new SampleTimeOperator(period,scheduler));};}exports.sampleTime=sampleTime;var SampleTimeOperator=function(){function SampleTimeOperator(period,scheduler){this.period=period;this.scheduler=scheduler;}SampleTimeOperator.prototype.call=function(subscriber,source){return source.subscribe(new SampleTimeSubscriber(subscriber,this.period,this.scheduler));};return SampleTimeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SampleTimeSubscriber=function(_super){__extends(SampleTimeSubscriber,_super);function SampleTimeSubscriber(destination,period,scheduler){_super.call(this,destination);this.period=period;this.scheduler=scheduler;this.hasValue=false;this.add(scheduler.schedule(dispatchNotification,period,{subscriber:this,period:period}));}SampleTimeSubscriber.prototype._next=function(value){this.lastValue=value;this.hasValue=true;};SampleTimeSubscriber.prototype.notifyNext=function(){if(this.hasValue){this.hasValue=false;this.destination.next(this.lastValue);}};return SampleTimeSubscriber;}(Subscriber_1.Subscriber);function dispatchNotification(state){var subscriber=state.subscriber,period=state.period;subscriber.notifyNext();this.schedule(state,period);}//# sourceMappingURL=sampleTime.js.map
  
  /***/ }),
  /* 126 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);/**
   * Compares all values of two observables in sequence using an optional comparor function
   * and returns an observable of a single boolean value representing whether or not the two sequences
   * are equal.
   *
   * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
   *
   * <img src="./img/sequenceEqual.png" width="100%">
   *
   * `sequenceEqual` subscribes to two observables and buffers incoming values from each observable. Whenever either
   * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
   * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
   * observables completes, the operator will wait for the other observable to complete; If the other
   * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
   * completes or emits after the other complets, the returned observable will never complete.
   *
   * @example <caption>figure out if the Konami code matches</caption>
   * var code = Rx.Observable.from([
   *  "ArrowUp",
   *  "ArrowUp",
   *  "ArrowDown",
   *  "ArrowDown",
   *  "ArrowLeft",
   *  "ArrowRight",
   *  "ArrowLeft",
   *  "ArrowRight",
   *  "KeyB",
   *  "KeyA",
   *  "Enter" // no start key, clearly.
   * ]);
   *
   * var keys = Rx.Observable.fromEvent(document, 'keyup')
   *  .map(e => e.code);
   * var matches = keys.bufferCount(11, 1)
   *  .mergeMap(
   *    last11 =>
   *      Rx.Observable.from(last11)
   *        .sequenceEqual(code)
   *   );
   * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
   *
   * @see {@link combineLatest}
   * @see {@link zip}
   * @see {@link withLatestFrom}
   *
   * @param {Observable} compareTo The observable sequence to compare the source sequence to.
   * @param {function} [comparor] An optional function to compare each value pair
   * @return {Observable} An Observable of a single boolean value representing whether or not
   * the values emitted by both observables were equal in sequence.
   * @method sequenceEqual
   * @owner Observable
   */function sequenceEqual(compareTo,comparor){return function(source){return source.lift(new SequenceEqualOperator(compareTo,comparor));};}exports.sequenceEqual=sequenceEqual;var SequenceEqualOperator=function(){function SequenceEqualOperator(compareTo,comparor){this.compareTo=compareTo;this.comparor=comparor;}SequenceEqualOperator.prototype.call=function(subscriber,source){return source.subscribe(new SequenceEqualSubscriber(subscriber,this.compareTo,this.comparor));};return SequenceEqualOperator;}();exports.SequenceEqualOperator=SequenceEqualOperator;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SequenceEqualSubscriber=function(_super){__extends(SequenceEqualSubscriber,_super);function SequenceEqualSubscriber(destination,compareTo,comparor){_super.call(this,destination);this.compareTo=compareTo;this.comparor=comparor;this._a=[];this._b=[];this._oneComplete=false;this.add(compareTo.subscribe(new SequenceEqualCompareToSubscriber(destination,this)));}SequenceEqualSubscriber.prototype._next=function(value){if(this._oneComplete&&this._b.length===0){this.emit(false);}else{this._a.push(value);this.checkValues();}};SequenceEqualSubscriber.prototype._complete=function(){if(this._oneComplete){this.emit(this._a.length===0&&this._b.length===0);}else{this._oneComplete=true;}};SequenceEqualSubscriber.prototype.checkValues=function(){var _c=this,_a=_c._a,_b=_c._b,comparor=_c.comparor;while(_a.length>0&&_b.length>0){var a=_a.shift();var b=_b.shift();var areEqual=false;if(comparor){areEqual=tryCatch_1.tryCatch(comparor)(a,b);if(areEqual===errorObject_1.errorObject){this.destination.error(errorObject_1.errorObject.e);}}else{areEqual=a===b;}if(!areEqual){this.emit(false);}}};SequenceEqualSubscriber.prototype.emit=function(value){var destination=this.destination;destination.next(value);destination.complete();};SequenceEqualSubscriber.prototype.nextB=function(value){if(this._oneComplete&&this._a.length===0){this.emit(false);}else{this._b.push(value);this.checkValues();}};return SequenceEqualSubscriber;}(Subscriber_1.Subscriber);exports.SequenceEqualSubscriber=SequenceEqualSubscriber;var SequenceEqualCompareToSubscriber=function(_super){__extends(SequenceEqualCompareToSubscriber,_super);function SequenceEqualCompareToSubscriber(destination,parent){_super.call(this,destination);this.parent=parent;}SequenceEqualCompareToSubscriber.prototype._next=function(value){this.parent.nextB(value);};SequenceEqualCompareToSubscriber.prototype._error=function(err){this.parent.error(err);};SequenceEqualCompareToSubscriber.prototype._complete=function(){this.parent._complete();};return SequenceEqualCompareToSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=sequenceEqual.js.map
  
  /***/ }),
  /* 127 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var multicast_1=__webpack_require__(14);var refCount_1=__webpack_require__(54);var Subject_1=__webpack_require__(6);function shareSubjectFactory(){return new Subject_1.Subject();}/**
   * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one
   * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will
   * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.
   * This is an alias for .multicast(() => new Subject()).refCount().
   *
   * <img src="./img/share.png" width="100%">
   *
   * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.
   * @method share
   * @owner Observable
   */function share(){return function(source){return refCount_1.refCount()(multicast_1.multicast(shareSubjectFactory)(source));};}exports.share=share;;//# sourceMappingURL=share.js.map
  
  /***/ }),
  /* 128 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ReplaySubject_1=__webpack_require__(36);/**
   * @method shareReplay
   * @owner Observable
   */function shareReplay(bufferSize,windowTime,scheduler){return function(source){return source.lift(shareReplayOperator(bufferSize,windowTime,scheduler));};}exports.shareReplay=shareReplay;function shareReplayOperator(bufferSize,windowTime,scheduler){var subject;var refCount=0;var subscription;var hasError=false;var isComplete=false;return function shareReplayOperation(source){refCount++;if(!subject||hasError){hasError=false;subject=new ReplaySubject_1.ReplaySubject(bufferSize,windowTime,scheduler);subscription=source.subscribe({next:function next(value){subject.next(value);},error:function error(err){hasError=true;subject.error(err);},complete:function complete(){isComplete=true;subject.complete();}});}var innerSub=subject.subscribe(this);return function(){refCount--;innerSub.unsubscribe();if(subscription&&refCount===0&&isComplete){subscription.unsubscribe();}};};};//# sourceMappingURL=shareReplay.js.map
  
  /***/ }),
  /* 129 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var EmptyError_1=__webpack_require__(37);/**
   * Returns an Observable that emits the single item emitted by the source Observable that matches a specified
   * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no
   * such items, notify of an IllegalArgumentException or NoSuchElementException respectively.
   *
   * <img src="./img/single.png" width="100%">
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits the single item emitted by the source Observable that matches
   * the predicate.
   .
   * @method single
   * @owner Observable
   */function single(predicate){return function(source){return source.lift(new SingleOperator(predicate,source));};}exports.single=single;var SingleOperator=function(){function SingleOperator(predicate,source){this.predicate=predicate;this.source=source;}SingleOperator.prototype.call=function(subscriber,source){return source.subscribe(new SingleSubscriber(subscriber,this.predicate,this.source));};return SingleOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SingleSubscriber=function(_super){__extends(SingleSubscriber,_super);function SingleSubscriber(destination,predicate,source){_super.call(this,destination);this.predicate=predicate;this.source=source;this.seenValue=false;this.index=0;}SingleSubscriber.prototype.applySingleValue=function(value){if(this.seenValue){this.destination.error('Sequence contains more than one element');}else{this.seenValue=true;this.singleValue=value;}};SingleSubscriber.prototype._next=function(value){var index=this.index++;if(this.predicate){this.tryNext(value,index);}else{this.applySingleValue(value);}};SingleSubscriber.prototype.tryNext=function(value,index){try{if(this.predicate(value,index,this.source)){this.applySingleValue(value);}}catch(err){this.destination.error(err);}};SingleSubscriber.prototype._complete=function(){var destination=this.destination;if(this.index>0){destination.next(this.seenValue?this.singleValue:undefined);destination.complete();}else{destination.error(new EmptyError_1.EmptyError());}};return SingleSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=single.js.map
  
  /***/ }),
  /* 130 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Returns an Observable that skips the first `count` items emitted by the source Observable.
   *
   * <img src="./img/skip.png" width="100%">
   *
   * @param {Number} count - The number of times, items emitted by source Observable should be skipped.
   * @return {Observable} An Observable that skips values emitted by the source Observable.
   *
   * @method skip
   * @owner Observable
   */function skip(count){return function(source){return source.lift(new SkipOperator(count));};}exports.skip=skip;var SkipOperator=function(){function SkipOperator(total){this.total=total;}SkipOperator.prototype.call=function(subscriber,source){return source.subscribe(new SkipSubscriber(subscriber,this.total));};return SkipOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SkipSubscriber=function(_super){__extends(SkipSubscriber,_super);function SkipSubscriber(destination,total){_super.call(this,destination);this.total=total;this.count=0;}SkipSubscriber.prototype._next=function(x){if(++this.count>this.total){this.destination.next(x);}};return SkipSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=skip.js.map
  
  /***/ }),
  /* 131 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var ArgumentOutOfRangeError_1=__webpack_require__(23);/**
   * Skip the last `count` values emitted by the source Observable.
   *
   * <img src="./img/skipLast.png" width="100%">
   *
   * `skipLast` returns an Observable that accumulates a queue with a length
   * enough to store the first `count` values. As more values are received,
   * values are taken from the front of the queue and produced on the result
   * sequence. This causes values to be delayed.
   *
   * @example <caption>Skip the last 2 values of an Observable with many values</caption>
   * var many = Rx.Observable.range(1, 5);
   * var skipLastTwo = many.skipLast(2);
   * skipLastTwo.subscribe(x => console.log(x));
   *
   * // Results in:
   * // 1 2 3
   *
   * @see {@link skip}
   * @see {@link skipUntil}
   * @see {@link skipWhile}
   * @see {@link take}
   *
   * @throws {ArgumentOutOfRangeError} When using `skipLast(i)`, it throws
   * ArgumentOutOrRangeError if `i < 0`.
   *
   * @param {number} count Number of elements to skip from the end of the source Observable.
   * @returns {Observable<T>} An Observable that skips the last count values
   * emitted by the source Observable.
   * @method skipLast
   * @owner Observable
   */function skipLast(count){return function(source){return source.lift(new SkipLastOperator(count));};}exports.skipLast=skipLast;var SkipLastOperator=function(){function SkipLastOperator(_skipCount){this._skipCount=_skipCount;if(this._skipCount<0){throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError();}}SkipLastOperator.prototype.call=function(subscriber,source){if(this._skipCount===0){// If we don't want to skip any values then just subscribe
  // to Subscriber without any further logic.
  return source.subscribe(new Subscriber_1.Subscriber(subscriber));}else{return source.subscribe(new SkipLastSubscriber(subscriber,this._skipCount));}};return SkipLastOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SkipLastSubscriber=function(_super){__extends(SkipLastSubscriber,_super);function SkipLastSubscriber(destination,_skipCount){_super.call(this,destination);this._skipCount=_skipCount;this._count=0;this._ring=new Array(_skipCount);}SkipLastSubscriber.prototype._next=function(value){var skipCount=this._skipCount;var count=this._count++;if(count<skipCount){this._ring[count]=value;}else{var currentIndex=count%skipCount;var ring=this._ring;var oldValue=ring[currentIndex];ring[currentIndex]=value;this.destination.next(oldValue);}};return SkipLastSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=skipLast.js.map
  
  /***/ }),
  /* 132 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
   *
   * <img src="./img/skipUntil.png" width="100%">
   *
   * @param {Observable} notifier - The second Observable that has to emit an item before the source Observable's elements begin to
   * be mirrored by the resulting Observable.
   * @return {Observable<T>} An Observable that skips items from the source Observable until the second Observable emits
   * an item, then emits the remaining items.
   * @method skipUntil
   * @owner Observable
   */function skipUntil(notifier){return function(source){return source.lift(new SkipUntilOperator(notifier));};}exports.skipUntil=skipUntil;var SkipUntilOperator=function(){function SkipUntilOperator(notifier){this.notifier=notifier;}SkipUntilOperator.prototype.call=function(subscriber,source){return source.subscribe(new SkipUntilSubscriber(subscriber,this.notifier));};return SkipUntilOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SkipUntilSubscriber=function(_super){__extends(SkipUntilSubscriber,_super);function SkipUntilSubscriber(destination,notifier){_super.call(this,destination);this.hasValue=false;this.isInnerStopped=false;this.add(subscribeToResult_1.subscribeToResult(this,notifier));}SkipUntilSubscriber.prototype._next=function(value){if(this.hasValue){_super.prototype._next.call(this,value);}};SkipUntilSubscriber.prototype._complete=function(){if(this.isInnerStopped){_super.prototype._complete.call(this);}else{this.unsubscribe();}};SkipUntilSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.hasValue=true;};SkipUntilSubscriber.prototype.notifyComplete=function(){this.isInnerStopped=true;if(this.isStopped){_super.prototype._complete.call(this);}};return SkipUntilSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=skipUntil.js.map
  
  /***/ }),
  /* 133 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds
   * true, but emits all further source items as soon as the condition becomes false.
   *
   * <img src="./img/skipWhile.png" width="100%">
   *
   * @param {Function} predicate - A function to test each item emitted from the source Observable.
   * @return {Observable<T>} An Observable that begins emitting items emitted by the source Observable when the
   * specified predicate becomes false.
   * @method skipWhile
   * @owner Observable
   */function skipWhile(predicate){return function(source){return source.lift(new SkipWhileOperator(predicate));};}exports.skipWhile=skipWhile;var SkipWhileOperator=function(){function SkipWhileOperator(predicate){this.predicate=predicate;}SkipWhileOperator.prototype.call=function(subscriber,source){return source.subscribe(new SkipWhileSubscriber(subscriber,this.predicate));};return SkipWhileOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SkipWhileSubscriber=function(_super){__extends(SkipWhileSubscriber,_super);function SkipWhileSubscriber(destination,predicate){_super.call(this,destination);this.predicate=predicate;this.skipping=true;this.index=0;}SkipWhileSubscriber.prototype._next=function(value){var destination=this.destination;if(this.skipping){this.tryCallPredicate(value);}if(!this.skipping){destination.next(value);}};SkipWhileSubscriber.prototype.tryCallPredicate=function(value){try{var result=this.predicate(value,this.index++);this.skipping=Boolean(result);}catch(err){this.destination.error(err);}};return SkipWhileSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=skipWhile.js.map
  
  /***/ }),
  /* 134 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ArrayObservable_1=__webpack_require__(12);var ScalarObservable_1=__webpack_require__(42);var EmptyObservable_1=__webpack_require__(13);var concat_1=__webpack_require__(16);var isScheduler_1=__webpack_require__(10);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits the items you specify as arguments before it begins to emit
   * items emitted by the source Observable.
   *
   * <img src="./img/startWith.png" width="100%">
   *
   * @param {...T} values - Items you want the modified Observable to emit first.
   * @param {Scheduler} [scheduler] - A {@link IScheduler} to use for scheduling
   * the emissions of the `next` notifications.
   * @return {Observable} An Observable that emits the items in the specified Iterable and then emits the items
   * emitted by the source Observable.
   * @method startWith
   * @owner Observable
   */function startWith(){var array=[];for(var _i=0;_i<arguments.length;_i++){array[_i-0]=arguments[_i];}return function(source){var scheduler=array[array.length-1];if(isScheduler_1.isScheduler(scheduler)){array.pop();}else{scheduler=null;}var len=array.length;if(len===1){return concat_1.concat(new ScalarObservable_1.ScalarObservable(array[0],scheduler),source);}else if(len>1){return concat_1.concat(new ArrayObservable_1.ArrayObservable(array,scheduler),source);}else{return concat_1.concat(new EmptyObservable_1.EmptyObservable(scheduler),source);}};}exports.startWith=startWith;//# sourceMappingURL=startWith.js.map
  
  /***/ }),
  /* 135 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var AsapAction_1=__webpack_require__(398);var AsapScheduler_1=__webpack_require__(402);/**
   *
   * Asap Scheduler
   *
   * <span class="informal">Perform task as fast as it can be performed asynchronously</span>
   *
   * `asap` scheduler behaves the same as {@link async} scheduler when you use it to delay task
   * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing
   * code to end and then it will try to execute given task as fast as possible.
   *
   * `asap` scheduler will do its best to minimize time between end of currently executing code
   * and start of scheduled task. This makes it best candidate for performing so called "deferring".
   * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves
   * some (although minimal) unwanted delay.
   *
   * Note that using `asap` scheduler does not necessarily mean that your task will be first to process
   * after currently executing code. In particular, if some task was also scheduled with `asap` before,
   * that task will execute first. That being said, if you need to schedule task asynchronously, but
   * as soon as possible, `asap` scheduler is your best bet.
   *
   * @example <caption>Compare async and asap scheduler</caption>
   *
   * Rx.Scheduler.async.schedule(() => console.log('async')); // scheduling 'async' first...
   * Rx.Scheduler.asap.schedule(() => console.log('asap'));
   *
   * // Logs:
   * // "asap"
   * // "async"
   * // ... but 'asap' goes first!
   *
   * @static true
   * @name asap
   * @owner Scheduler
   */exports.asap=new AsapScheduler_1.AsapScheduler(AsapAction_1.AsapAction);//# sourceMappingURL=asap.js.map
  
  /***/ }),
  /* 136 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var apply=Function.prototype.apply;// DOM APIs, for completeness
  exports.setTimeout=function(){return new Timeout(apply.call(setTimeout,window,arguments),clearTimeout);};exports.setInterval=function(){return new Timeout(apply.call(setInterval,window,arguments),clearInterval);};exports.clearTimeout=exports.clearInterval=function(timeout){if(timeout){timeout.close();}};function Timeout(id,clearFn){this._id=id;this._clearFn=clearFn;}Timeout.prototype.unref=Timeout.prototype.ref=function(){};Timeout.prototype.close=function(){this._clearFn.call(window,this._id);};// Does not start the time, just sets up the members needed.
  exports.enroll=function(item,msecs){clearTimeout(item._idleTimeoutId);item._idleTimeout=msecs;};exports.unenroll=function(item){clearTimeout(item._idleTimeoutId);item._idleTimeout=-1;};exports._unrefActive=exports.active=function(item){clearTimeout(item._idleTimeoutId);var msecs=item._idleTimeout;if(msecs>=0){item._idleTimeoutId=setTimeout(function onTimeout(){if(item._onTimeout)item._onTimeout();},msecs);}};// setimmediate attaches itself to the global object
  __webpack_require__(400);exports.setImmediate=setImmediate;exports.clearImmediate=clearImmediate;
  
  /***/ }),
  /* 137 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var switchMap_1=__webpack_require__(55);var identity_1=__webpack_require__(68);function switchAll(){return switchMap_1.switchMap(identity_1.identity);}exports.switchAll=switchAll;//# sourceMappingURL=switchAll.js.map
  
  /***/ }),
  /* 138 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is flattened multiple
   * times with {@link switch} in the output Observable.
   *
   * <span class="informal">It's like {@link switchMap}, but maps each value
   * always to the same inner Observable.</span>
   *
   * <img src="./img/switchMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then flattens those resulting Observables into one
   * single Observable, which is the output Observable. The output Observables
   * emits values only from the most recently emitted instance of
   * `innerObservable`.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMapTo(Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMapTo}
   * @see {@link switch}
   * @see {@link switchMap}
   * @see {@link mergeMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable, and taking only the values
   * from the most recently projected inner Observable.
   * @method switchMapTo
   * @owner Observable
   */function switchMapTo(innerObservable,resultSelector){return function(source){return source.lift(new SwitchMapToOperator(innerObservable,resultSelector));};}exports.switchMapTo=switchMapTo;var SwitchMapToOperator=function(){function SwitchMapToOperator(observable,resultSelector){this.observable=observable;this.resultSelector=resultSelector;}SwitchMapToOperator.prototype.call=function(subscriber,source){return source.subscribe(new SwitchMapToSubscriber(subscriber,this.observable,this.resultSelector));};return SwitchMapToOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var SwitchMapToSubscriber=function(_super){__extends(SwitchMapToSubscriber,_super);function SwitchMapToSubscriber(destination,inner,resultSelector){_super.call(this,destination);this.inner=inner;this.resultSelector=resultSelector;this.index=0;}SwitchMapToSubscriber.prototype._next=function(value){var innerSubscription=this.innerSubscription;if(innerSubscription){innerSubscription.unsubscribe();}this.add(this.innerSubscription=subscribeToResult_1.subscribeToResult(this,this.inner,value,this.index++));};SwitchMapToSubscriber.prototype._complete=function(){var innerSubscription=this.innerSubscription;if(!innerSubscription||innerSubscription.closed){_super.prototype._complete.call(this);}};SwitchMapToSubscriber.prototype._unsubscribe=function(){this.innerSubscription=null;};SwitchMapToSubscriber.prototype.notifyComplete=function(innerSub){this.remove(innerSub);this.innerSubscription=null;if(this.isStopped){_super.prototype._complete.call(this);}};SwitchMapToSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;if(resultSelector){this.tryResultSelector(outerValue,innerValue,outerIndex,innerIndex);}else{destination.next(innerValue);}};SwitchMapToSubscriber.prototype.tryResultSelector=function(outerValue,innerValue,outerIndex,innerIndex){var _a=this,resultSelector=_a.resultSelector,destination=_a.destination;var result;try{result=resultSelector(outerValue,innerValue,outerIndex,innerIndex);}catch(err){destination.error(err);return;}destination.next(result);};return SwitchMapToSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=switchMapTo.js.map
  
  /***/ }),
  /* 139 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var ArgumentOutOfRangeError_1=__webpack_require__(23);var EmptyObservable_1=__webpack_require__(13);/**
   * Emits only the first `count` values emitted by the source Observable.
   *
   * <span class="informal">Takes the first `count` values from the source, then
   * completes.</span>
   *
   * <img src="./img/take.png" width="100%">
   *
   * `take` returns an Observable that emits only the first `count` values emitted
   * by the source Observable. If the source emits fewer than `count` values then
   * all of its values are emitted. After that, it completes, regardless if the
   * source completes.
   *
   * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>
   * var interval = Rx.Observable.interval(1000);
   * var five = interval.take(5);
   * five.subscribe(x => console.log(x));
   *
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of `next` values to emit.
   * @return {Observable<T>} An Observable that emits only the first `count`
   * values emitted by the source Observable, or all of the values from the source
   * if the source emits fewer than `count` values.
   * @method take
   * @owner Observable
   */function take(count){return function(source){if(count===0){return new EmptyObservable_1.EmptyObservable();}else{return source.lift(new TakeOperator(count));}};}exports.take=take;var TakeOperator=function(){function TakeOperator(total){this.total=total;if(this.total<0){throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError();}}TakeOperator.prototype.call=function(subscriber,source){return source.subscribe(new TakeSubscriber(subscriber,this.total));};return TakeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TakeSubscriber=function(_super){__extends(TakeSubscriber,_super);function TakeSubscriber(destination,total){_super.call(this,destination);this.total=total;this.count=0;}TakeSubscriber.prototype._next=function(value){var total=this.total;var count=++this.count;if(count<=total){this.destination.next(value);if(count===total){this.destination.complete();this.unsubscribe();}}};return TakeSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=take.js.map
  
  /***/ }),
  /* 140 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Emits the values emitted by the source Observable until a `notifier`
   * Observable emits a value.
   *
   * <span class="informal">Lets values pass until a second Observable,
   * `notifier`, emits something. Then, it completes.</span>
   *
   * <img src="./img/takeUntil.png" width="100%">
   *
   * `takeUntil` subscribes and begins mirroring the source Observable. It also
   * monitors a second Observable, `notifier` that you provide. If the `notifier`
   * emits a value or a complete notification, the output Observable stops
   * mirroring the source Observable and completes.
   *
   * @example <caption>Tick every second until the first click happens</caption>
   * var interval = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = interval.takeUntil(clicks);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeLast}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @param {Observable} notifier The Observable whose first emitted value will
   * cause the output Observable of `takeUntil` to stop emitting values from the
   * source Observable.
   * @return {Observable<T>} An Observable that emits the values from the source
   * Observable until such time as `notifier` emits its first value.
   * @method takeUntil
   * @owner Observable
   */function takeUntil(notifier){return function(source){return source.lift(new TakeUntilOperator(notifier));};}exports.takeUntil=takeUntil;var TakeUntilOperator=function(){function TakeUntilOperator(notifier){this.notifier=notifier;}TakeUntilOperator.prototype.call=function(subscriber,source){return source.subscribe(new TakeUntilSubscriber(subscriber,this.notifier));};return TakeUntilOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TakeUntilSubscriber=function(_super){__extends(TakeUntilSubscriber,_super);function TakeUntilSubscriber(destination,notifier){_super.call(this,destination);this.notifier=notifier;this.add(subscribeToResult_1.subscribeToResult(this,notifier));}TakeUntilSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.complete();};TakeUntilSubscriber.prototype.notifyComplete=function(){// noop
  };return TakeUntilSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=takeUntil.js.map
  
  /***/ }),
  /* 141 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * Emits values emitted by the source Observable so long as each value satisfies
   * the given `predicate`, and then completes as soon as this `predicate` is not
   * satisfied.
   *
   * <span class="informal">Takes values from the source only while they pass the
   * condition given. When the first value does not satisfy, it completes.</span>
   *
   * <img src="./img/takeWhile.png" width="100%">
   *
   * `takeWhile` subscribes and begins mirroring the source Observable. Each value
   * emitted on the source is given to the `predicate` function which returns a
   * boolean, representing a condition to be satisfied by the source values. The
   * output Observable emits the source values until such time as the `predicate`
   * returns false, at which point `takeWhile` stops mirroring the source
   * Observable and completes the output Observable.
   *
   * @example <caption>Emit click events only while the clientX property is greater than 200</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.takeWhile(ev => ev.clientX > 200);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link skip}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates a value emitted by the source Observable and returns a boolean.
   * Also takes the (zero-based) index as the second argument.
   * @return {Observable<T>} An Observable that emits the values from the source
   * Observable so long as each value satisfies the condition defined by the
   * `predicate`, then completes.
   * @method takeWhile
   * @owner Observable
   */function takeWhile(predicate){return function(source){return source.lift(new TakeWhileOperator(predicate));};}exports.takeWhile=takeWhile;var TakeWhileOperator=function(){function TakeWhileOperator(predicate){this.predicate=predicate;}TakeWhileOperator.prototype.call=function(subscriber,source){return source.subscribe(new TakeWhileSubscriber(subscriber,this.predicate));};return TakeWhileOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TakeWhileSubscriber=function(_super){__extends(TakeWhileSubscriber,_super);function TakeWhileSubscriber(destination,predicate){_super.call(this,destination);this.predicate=predicate;this.index=0;}TakeWhileSubscriber.prototype._next=function(value){var destination=this.destination;var result;try{result=this.predicate(value,this.index++);}catch(err){destination.error(err);return;}this.nextOrComplete(value,result);};TakeWhileSubscriber.prototype.nextOrComplete=function(value,predicateResult){var destination=this.destination;if(Boolean(predicateResult)){destination.next(value);}else{destination.complete();}};return TakeWhileSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=takeWhile.js.map
  
  /***/ }),
  /* 142 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var async_1=__webpack_require__(4);var throttle_1=__webpack_require__(38);/**
   * Emits a value from the source Observable, then ignores subsequent source
   * values for `duration` milliseconds, then repeats this process.
   *
   * <span class="informal">Lets a value pass, then ignores source values for the
   * next `duration` milliseconds.</span>
   *
   * <img src="./img/throttleTime.png" width="100%">
   *
   * `throttleTime` emits the source Observable values on the output Observable
   * when its internal timer is disabled, and ignores source values when the timer
   * is enabled. Initially, the timer is disabled. As soon as the first source
   * value arrives, it is forwarded to the output Observable, and then the timer
   * is enabled. After `duration` milliseconds (or the time unit determined
   * internally by the optional `scheduler`) has passed, the timer is disabled,
   * and this process repeats for the next source value. Optionally takes a
   * {@link IScheduler} for managing timers.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.throttleTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttle}
   *
   * @param {number} duration Time to wait before emitting another value after
   * emitting the last value, measured in milliseconds or the time unit determined
   * internally by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the throttling.
   * @return {Observable<T>} An Observable that performs the throttle operation to
   * limit the rate of emissions from the source.
   * @method throttleTime
   * @owner Observable
   */function throttleTime(duration,scheduler,config){if(scheduler===void 0){scheduler=async_1.async;}if(config===void 0){config=throttle_1.defaultThrottleConfig;}return function(source){return source.lift(new ThrottleTimeOperator(duration,scheduler,config.leading,config.trailing));};}exports.throttleTime=throttleTime;var ThrottleTimeOperator=function(){function ThrottleTimeOperator(duration,scheduler,leading,trailing){this.duration=duration;this.scheduler=scheduler;this.leading=leading;this.trailing=trailing;}ThrottleTimeOperator.prototype.call=function(subscriber,source){return source.subscribe(new ThrottleTimeSubscriber(subscriber,this.duration,this.scheduler,this.leading,this.trailing));};return ThrottleTimeOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ThrottleTimeSubscriber=function(_super){__extends(ThrottleTimeSubscriber,_super);function ThrottleTimeSubscriber(destination,duration,scheduler,leading,trailing){_super.call(this,destination);this.duration=duration;this.scheduler=scheduler;this.leading=leading;this.trailing=trailing;this._hasTrailingValue=false;this._trailingValue=null;}ThrottleTimeSubscriber.prototype._next=function(value){if(this.throttled){if(this.trailing){this._trailingValue=value;this._hasTrailingValue=true;}}else{this.add(this.throttled=this.scheduler.schedule(dispatchNext,this.duration,{subscriber:this}));if(this.leading){this.destination.next(value);}}};ThrottleTimeSubscriber.prototype.clearThrottle=function(){var throttled=this.throttled;if(throttled){if(this.trailing&&this._hasTrailingValue){this.destination.next(this._trailingValue);this._trailingValue=null;this._hasTrailingValue=false;}throttled.unsubscribe();this.remove(throttled);this.throttled=null;}};return ThrottleTimeSubscriber;}(Subscriber_1.Subscriber);function dispatchNext(arg){var subscriber=arg.subscriber;subscriber.clearThrottle();}//# sourceMappingURL=throttleTime.js.map
  
  /***/ }),
  /* 143 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var timeInterval_1=__webpack_require__(144);exports.TimeInterval=timeInterval_1.TimeInterval;/**
   * @param scheduler
   * @return {Observable<TimeInterval<any>>|WebSocketSubject<T>|Observable<T>}
   * @method timeInterval
   * @owner Observable
   */function timeInterval(scheduler){if(scheduler===void 0){scheduler=async_1.async;}return timeInterval_1.timeInterval(scheduler)(this);}exports.timeInterval=timeInterval;//# sourceMappingURL=timeInterval.js.map
  
  /***/ }),
  /* 144 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var async_1=__webpack_require__(4);function timeInterval(scheduler){if(scheduler===void 0){scheduler=async_1.async;}return function(source){return source.lift(new TimeIntervalOperator(scheduler));};}exports.timeInterval=timeInterval;var TimeInterval=function(){function TimeInterval(value,interval){this.value=value;this.interval=interval;}return TimeInterval;}();exports.TimeInterval=TimeInterval;;var TimeIntervalOperator=function(){function TimeIntervalOperator(scheduler){this.scheduler=scheduler;}TimeIntervalOperator.prototype.call=function(observer,source){return source.subscribe(new TimeIntervalSubscriber(observer,this.scheduler));};return TimeIntervalOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TimeIntervalSubscriber=function(_super){__extends(TimeIntervalSubscriber,_super);function TimeIntervalSubscriber(destination,scheduler){_super.call(this,destination);this.scheduler=scheduler;this.lastTime=0;this.lastTime=scheduler.now();}TimeIntervalSubscriber.prototype._next=function(value){var now=this.scheduler.now();var span=now-this.lastTime;this.lastTime=now;this.destination.next(new TimeInterval(value,span));};return TimeIntervalSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=timeInterval.js.map
  
  /***/ }),
  /* 145 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var async_1=__webpack_require__(4);var isDate_1=__webpack_require__(34);var Subscriber_1=__webpack_require__(1);var TimeoutError_1=__webpack_require__(146);/**
   *
   * Errors if Observable does not emit a value in given time span.
   *
   * <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span>
   *
   * <img src="./img/timeout.png" width="100%">
   *
   * `timeout` operator accepts as an argument either a number or a Date.
   *
   * If number was provided, it returns an Observable that behaves like a source
   * Observable, unless there is a period of time where there is no value emitted.
   * So if you provide `100` as argument and first value comes after 50ms from
   * the moment of subscription, this value will be simply re-emitted by the resulting
   * Observable. If however after that 100ms passes without a second value being emitted,
   * stream will end with an error and source Observable will be unsubscribed.
   * These checks are performed throughout whole lifecycle of Observable - from the moment
   * it was subscribed to, until it completes or errors itself. Thus every value must be
   * emitted within specified period since previous value.
   *
   * If provided argument was Date, returned Observable behaves differently. It throws
   * if Observable did not complete before provided Date. This means that periods between
   * emission of particular values do not matter in this case. If Observable did not complete
   * before provided Date, source Observable will be unsubscribed. Other than that, resulting
   * stream behaves just as source Observable.
   *
   * `timeout` accepts also a Scheduler as a second parameter. It is used to schedule moment (or moments)
   * when returned Observable will check if source stream emitted value or completed.
   *
   * @example <caption>Check if ticks are emitted within certain timespan</caption>
   * const seconds = Rx.Observable.interval(1000);
   *
   * seconds.timeout(1100) // Let's use bigger timespan to be safe,
   *                       // since `interval` might fire a bit later then scheduled.
   * .subscribe(
   *     value => console.log(value), // Will emit numbers just as regular `interval` would.
   *     err => console.log(err) // Will never be called.
   * );
   *
   * seconds.timeout(900).subscribe(
   *     value => console.log(value), // Will never be called.
   *     err => console.log(err) // Will emit error before even first value is emitted,
   *                             // since it did not arrive within 900ms period.
   * );
   *
   * @example <caption>Use Date to check if Observable completed</caption>
   * const seconds = Rx.Observable.interval(1000);
   *
   * seconds.timeout(new Date("December 17, 2020 03:24:00"))
   * .subscribe(
   *     value => console.log(value), // Will emit values as regular `interval` would
   *                                  // until December 17, 2020 at 03:24:00.
   *     err => console.log(err) // On December 17, 2020 at 03:24:00 it will emit an error,
   *                             // since Observable did not complete by then.
   * );
   *
   * @see {@link timeoutWith}
   *
   * @param {number|Date} due Number specifying period within which Observable must emit values
   *                          or Date specifying before when Observable should complete
   * @param {Scheduler} [scheduler] Scheduler controlling when timeout checks occur.
   * @return {Observable<T>} Observable that mirrors behaviour of source, unless timeout checks fail.
   * @method timeout
   * @owner Observable
   */function timeout(due,scheduler){if(scheduler===void 0){scheduler=async_1.async;}var absoluteTimeout=isDate_1.isDate(due);var waitFor=absoluteTimeout?+due-scheduler.now():Math.abs(due);return function(source){return source.lift(new TimeoutOperator(waitFor,absoluteTimeout,scheduler,new TimeoutError_1.TimeoutError()));};}exports.timeout=timeout;var TimeoutOperator=function(){function TimeoutOperator(waitFor,absoluteTimeout,scheduler,errorInstance){this.waitFor=waitFor;this.absoluteTimeout=absoluteTimeout;this.scheduler=scheduler;this.errorInstance=errorInstance;}TimeoutOperator.prototype.call=function(subscriber,source){return source.subscribe(new TimeoutSubscriber(subscriber,this.absoluteTimeout,this.waitFor,this.scheduler,this.errorInstance));};return TimeoutOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TimeoutSubscriber=function(_super){__extends(TimeoutSubscriber,_super);function TimeoutSubscriber(destination,absoluteTimeout,waitFor,scheduler,errorInstance){_super.call(this,destination);this.absoluteTimeout=absoluteTimeout;this.waitFor=waitFor;this.scheduler=scheduler;this.errorInstance=errorInstance;this.action=null;this.scheduleTimeout();}TimeoutSubscriber.dispatchTimeout=function(subscriber){subscriber.error(subscriber.errorInstance);};TimeoutSubscriber.prototype.scheduleTimeout=function(){var action=this.action;if(action){// Recycle the action if we've already scheduled one. All the production
  // Scheduler Actions mutate their state/delay time and return themeselves.
  // VirtualActions are immutable, so they create and return a clone. In this
  // case, we need to set the action reference to the most recent VirtualAction,
  // to ensure that's the one we clone from next time.
  this.action=action.schedule(this,this.waitFor);}else{this.add(this.action=this.scheduler.schedule(TimeoutSubscriber.dispatchTimeout,this.waitFor,this));}};TimeoutSubscriber.prototype._next=function(value){if(!this.absoluteTimeout){this.scheduleTimeout();}_super.prototype._next.call(this,value);};TimeoutSubscriber.prototype._unsubscribe=function(){this.action=null;this.scheduler=null;this.errorInstance=null;};return TimeoutSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=timeout.js.map
  
  /***/ }),
  /* 146 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};/**
   * An error thrown when duetime elapses.
   *
   * @see {@link timeout}
   *
   * @class TimeoutError
   */var TimeoutError=function(_super){__extends(TimeoutError,_super);function TimeoutError(){var err=_super.call(this,'Timeout has occurred');this.name=err.name='TimeoutError';this.stack=err.stack;this.message=err.message;}return TimeoutError;}(Error);exports.TimeoutError=TimeoutError;//# sourceMappingURL=TimeoutError.js.map
  
  /***/ }),
  /* 147 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var async_1=__webpack_require__(4);var isDate_1=__webpack_require__(34);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   *
   * Errors if Observable does not emit a value in given time span, in case of which
   * subscribes to the second Observable.
   *
   * <span class="informal">It's a version of `timeout` operator that let's you specify fallback Observable.</span>
   *
   * <img src="./img/timeoutWith.png" width="100%">
   *
   * `timeoutWith` is a variation of `timeout` operator. It behaves exactly the same,
   * still accepting as a first argument either a number or a Date, which control - respectively -
   * when values of source Observable should be emitted or when it should complete.
   *
   * The only difference is that it accepts a second, required parameter. This parameter
   * should be an Observable which will be subscribed when source Observable fails any timeout check.
   * So whenever regular `timeout` would emit an error, `timeoutWith` will instead start re-emitting
   * values from second Observable. Note that this fallback Observable is not checked for timeouts
   * itself, so it can emit values and complete at arbitrary points in time. From the moment of a second
   * subscription, Observable returned from `timeoutWith` simply mirrors fallback stream. When that
   * stream completes, it completes as well.
   *
   * Scheduler, which in case of `timeout` is provided as as second argument, can be still provided
   * here - as a third, optional parameter. It still is used to schedule timeout checks and -
   * as a consequence - when second Observable will be subscribed, since subscription happens
   * immediately after failing check.
   *
   * @example <caption>Add fallback observable</caption>
   * const seconds = Rx.Observable.interval(1000);
   * const minutes = Rx.Observable.interval(60 * 1000);
   *
   * seconds.timeoutWith(900, minutes)
   *     .subscribe(
   *         value => console.log(value), // After 900ms, will start emitting `minutes`,
   *                                      // since first value of `seconds` will not arrive fast enough.
   *         err => console.log(err) // Would be called after 900ms in case of `timeout`,
   *                                 // but here will never be called.
   *     );
   *
   * @param {number|Date} due Number specifying period within which Observable must emit values
   *                          or Date specifying before when Observable should complete
   * @param {Observable<T>} withObservable Observable which will be subscribed if source fails timeout check.
   * @param {Scheduler} [scheduler] Scheduler controlling when timeout checks occur.
   * @return {Observable<T>} Observable that mirrors behaviour of source or, when timeout check fails, of an Observable
   *                          passed as a second parameter.
   * @method timeoutWith
   * @owner Observable
   */function timeoutWith(due,withObservable,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return function(source){var absoluteTimeout=isDate_1.isDate(due);var waitFor=absoluteTimeout?+due-scheduler.now():Math.abs(due);return source.lift(new TimeoutWithOperator(waitFor,absoluteTimeout,withObservable,scheduler));};}exports.timeoutWith=timeoutWith;var TimeoutWithOperator=function(){function TimeoutWithOperator(waitFor,absoluteTimeout,withObservable,scheduler){this.waitFor=waitFor;this.absoluteTimeout=absoluteTimeout;this.withObservable=withObservable;this.scheduler=scheduler;}TimeoutWithOperator.prototype.call=function(subscriber,source){return source.subscribe(new TimeoutWithSubscriber(subscriber,this.absoluteTimeout,this.waitFor,this.withObservable,this.scheduler));};return TimeoutWithOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var TimeoutWithSubscriber=function(_super){__extends(TimeoutWithSubscriber,_super);function TimeoutWithSubscriber(destination,absoluteTimeout,waitFor,withObservable,scheduler){_super.call(this,destination);this.absoluteTimeout=absoluteTimeout;this.waitFor=waitFor;this.withObservable=withObservable;this.scheduler=scheduler;this.action=null;this.scheduleTimeout();}TimeoutWithSubscriber.dispatchTimeout=function(subscriber){var withObservable=subscriber.withObservable;subscriber._unsubscribeAndRecycle();subscriber.add(subscribeToResult_1.subscribeToResult(subscriber,withObservable));};TimeoutWithSubscriber.prototype.scheduleTimeout=function(){var action=this.action;if(action){// Recycle the action if we've already scheduled one. All the production
  // Scheduler Actions mutate their state/delay time and return themeselves.
  // VirtualActions are immutable, so they create and return a clone. In this
  // case, we need to set the action reference to the most recent VirtualAction,
  // to ensure that's the one we clone from next time.
  this.action=action.schedule(this,this.waitFor);}else{this.add(this.action=this.scheduler.schedule(TimeoutWithSubscriber.dispatchTimeout,this.waitFor,this));}};TimeoutWithSubscriber.prototype._next=function(value){if(!this.absoluteTimeout){this.scheduleTimeout();}_super.prototype._next.call(this,value);};TimeoutWithSubscriber.prototype._unsubscribe=function(){this.action=null;this.scheduler=null;this.withObservable=null;};return TimeoutWithSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=timeoutWith.js.map
  
  /***/ }),
  /* 148 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var reduce_1=__webpack_require__(24);function toArrayReducer(arr,item,index){arr.push(item);return arr;}function toArray(){return reduce_1.reduce(toArrayReducer,[]);}exports.toArray=toArray;//# sourceMappingURL=toArray.js.map
  
  /***/ }),
  /* 149 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Branch out the source Observable values as a nested Observable whenever
   * `windowBoundaries` emits.
   *
   * <span class="informal">It's like {@link buffer}, but emits a nested Observable
   * instead of an array.</span>
   *
   * <img src="./img/window.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits connected, non-overlapping
   * windows. It emits the current window and opens a new one whenever the
   * Observable `windowBoundaries` emits an item. Because each window is an
   * Observable, the output is a higher-order Observable.
   *
   * @example <caption>In every window of 1 second each, emit at most 2 click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var interval = Rx.Observable.interval(1000);
   * var result = clicks.window(interval)
   *   .map(win => win.take(2)) // each window has at most 2 emissions
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link windowWhen}
   * @see {@link buffer}
   *
   * @param {Observable<any>} windowBoundaries An Observable that completes the
   * previous window and starts a new window.
   * @return {Observable<Observable<T>>} An Observable of windows, which are
   * Observables emitting values of the source Observable.
   * @method window
   * @owner Observable
   */function window(windowBoundaries){return function windowOperatorFunction(source){return source.lift(new WindowOperator(windowBoundaries));};}exports.window=window;var WindowOperator=function(){function WindowOperator(windowBoundaries){this.windowBoundaries=windowBoundaries;}WindowOperator.prototype.call=function(subscriber,source){var windowSubscriber=new WindowSubscriber(subscriber);var sourceSubscription=source.subscribe(windowSubscriber);if(!sourceSubscription.closed){windowSubscriber.add(subscribeToResult_1.subscribeToResult(windowSubscriber,this.windowBoundaries));}return sourceSubscription;};return WindowOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WindowSubscriber=function(_super){__extends(WindowSubscriber,_super);function WindowSubscriber(destination){_super.call(this,destination);this.window=new Subject_1.Subject();destination.next(this.window);}WindowSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.openWindow();};WindowSubscriber.prototype.notifyError=function(error,innerSub){this._error(error);};WindowSubscriber.prototype.notifyComplete=function(innerSub){this._complete();};WindowSubscriber.prototype._next=function(value){this.window.next(value);};WindowSubscriber.prototype._error=function(err){this.window.error(err);this.destination.error(err);};WindowSubscriber.prototype._complete=function(){this.window.complete();this.destination.complete();};WindowSubscriber.prototype._unsubscribe=function(){this.window=null;};WindowSubscriber.prototype.openWindow=function(){var prevWindow=this.window;if(prevWindow){prevWindow.complete();}var destination=this.destination;var newWindow=this.window=new Subject_1.Subject();destination.next(newWindow);};return WindowSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=window.js.map
  
  /***/ }),
  /* 150 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);var Subject_1=__webpack_require__(6);/**
   * Branch out the source Observable values as a nested Observable with each
   * nested Observable emitting at most `windowSize` values.
   *
   * <span class="informal">It's like {@link bufferCount}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowCount.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits windows every `startWindowEvery`
   * items, each containing no more than `windowSize` items. When the source
   * Observable completes or encounters an error, the output Observable emits
   * the current window and propagates the notification from the source
   * Observable. If `startWindowEvery` is not provided, then new windows are
   * started immediately at the start of the source and when each window completes
   * with size `windowSize`.
   *
   * @example <caption>Ignore every 3rd click event, starting from the first one</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.windowCount(3)
   *   .map(win => win.skip(1)) // skip first of every 3 clicks
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Ignore every 3rd click event, starting from the third one</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.windowCount(2, 3)
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link windowWhen}
   * @see {@link bufferCount}
   *
   * @param {number} windowSize The maximum number of values emitted by each
   * window.
   * @param {number} [startWindowEvery] Interval at which to start a new window.
   * For example if `startWindowEvery` is `2`, then a new window will be started
   * on every other value from the source. A new window is started at the
   * beginning of the source by default.
   * @return {Observable<Observable<T>>} An Observable of windows, which in turn
   * are Observable of values.
   * @method windowCount
   * @owner Observable
   */function windowCount(windowSize,startWindowEvery){if(startWindowEvery===void 0){startWindowEvery=0;}return function windowCountOperatorFunction(source){return source.lift(new WindowCountOperator(windowSize,startWindowEvery));};}exports.windowCount=windowCount;var WindowCountOperator=function(){function WindowCountOperator(windowSize,startWindowEvery){this.windowSize=windowSize;this.startWindowEvery=startWindowEvery;}WindowCountOperator.prototype.call=function(subscriber,source){return source.subscribe(new WindowCountSubscriber(subscriber,this.windowSize,this.startWindowEvery));};return WindowCountOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WindowCountSubscriber=function(_super){__extends(WindowCountSubscriber,_super);function WindowCountSubscriber(destination,windowSize,startWindowEvery){_super.call(this,destination);this.destination=destination;this.windowSize=windowSize;this.startWindowEvery=startWindowEvery;this.windows=[new Subject_1.Subject()];this.count=0;destination.next(this.windows[0]);}WindowCountSubscriber.prototype._next=function(value){var startWindowEvery=this.startWindowEvery>0?this.startWindowEvery:this.windowSize;var destination=this.destination;var windowSize=this.windowSize;var windows=this.windows;var len=windows.length;for(var i=0;i<len&&!this.closed;i++){windows[i].next(value);}var c=this.count-windowSize+1;if(c>=0&&c%startWindowEvery===0&&!this.closed){windows.shift().complete();}if(++this.count%startWindowEvery===0&&!this.closed){var window_1=new Subject_1.Subject();windows.push(window_1);destination.next(window_1);}};WindowCountSubscriber.prototype._error=function(err){var windows=this.windows;if(windows){while(windows.length>0&&!this.closed){windows.shift().error(err);}}this.destination.error(err);};WindowCountSubscriber.prototype._complete=function(){var windows=this.windows;if(windows){while(windows.length>0&&!this.closed){windows.shift().complete();}}this.destination.complete();};WindowCountSubscriber.prototype._unsubscribe=function(){this.count=0;this.windows=null;};return WindowCountSubscriber;}(Subscriber_1.Subscriber);//# sourceMappingURL=windowCount.js.map
  
  /***/ }),
  /* 151 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var async_1=__webpack_require__(4);var Subscriber_1=__webpack_require__(1);var isNumeric_1=__webpack_require__(19);var isScheduler_1=__webpack_require__(10);function windowTime(windowTimeSpan){var scheduler=async_1.async;var windowCreationInterval=null;var maxWindowSize=Number.POSITIVE_INFINITY;if(isScheduler_1.isScheduler(arguments[3])){scheduler=arguments[3];}if(isScheduler_1.isScheduler(arguments[2])){scheduler=arguments[2];}else if(isNumeric_1.isNumeric(arguments[2])){maxWindowSize=arguments[2];}if(isScheduler_1.isScheduler(arguments[1])){scheduler=arguments[1];}else if(isNumeric_1.isNumeric(arguments[1])){windowCreationInterval=arguments[1];}return function windowTimeOperatorFunction(source){return source.lift(new WindowTimeOperator(windowTimeSpan,windowCreationInterval,maxWindowSize,scheduler));};}exports.windowTime=windowTime;var WindowTimeOperator=function(){function WindowTimeOperator(windowTimeSpan,windowCreationInterval,maxWindowSize,scheduler){this.windowTimeSpan=windowTimeSpan;this.windowCreationInterval=windowCreationInterval;this.maxWindowSize=maxWindowSize;this.scheduler=scheduler;}WindowTimeOperator.prototype.call=function(subscriber,source){return source.subscribe(new WindowTimeSubscriber(subscriber,this.windowTimeSpan,this.windowCreationInterval,this.maxWindowSize,this.scheduler));};return WindowTimeOperator;}();var CountedSubject=function(_super){__extends(CountedSubject,_super);function CountedSubject(){_super.apply(this,arguments);this._numberOfNextedValues=0;}CountedSubject.prototype.next=function(value){this._numberOfNextedValues++;_super.prototype.next.call(this,value);};Object.defineProperty(CountedSubject.prototype,"numberOfNextedValues",{get:function get(){return this._numberOfNextedValues;},enumerable:true,configurable:true});return CountedSubject;}(Subject_1.Subject);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WindowTimeSubscriber=function(_super){__extends(WindowTimeSubscriber,_super);function WindowTimeSubscriber(destination,windowTimeSpan,windowCreationInterval,maxWindowSize,scheduler){_super.call(this,destination);this.destination=destination;this.windowTimeSpan=windowTimeSpan;this.windowCreationInterval=windowCreationInterval;this.maxWindowSize=maxWindowSize;this.scheduler=scheduler;this.windows=[];var window=this.openWindow();if(windowCreationInterval!==null&&windowCreationInterval>=0){var closeState={subscriber:this,window:window,context:null};var creationState={windowTimeSpan:windowTimeSpan,windowCreationInterval:windowCreationInterval,subscriber:this,scheduler:scheduler};this.add(scheduler.schedule(dispatchWindowClose,windowTimeSpan,closeState));this.add(scheduler.schedule(dispatchWindowCreation,windowCreationInterval,creationState));}else{var timeSpanOnlyState={subscriber:this,window:window,windowTimeSpan:windowTimeSpan};this.add(scheduler.schedule(dispatchWindowTimeSpanOnly,windowTimeSpan,timeSpanOnlyState));}}WindowTimeSubscriber.prototype._next=function(value){var windows=this.windows;var len=windows.length;for(var i=0;i<len;i++){var window_1=windows[i];if(!window_1.closed){window_1.next(value);if(window_1.numberOfNextedValues>=this.maxWindowSize){this.closeWindow(window_1);}}}};WindowTimeSubscriber.prototype._error=function(err){var windows=this.windows;while(windows.length>0){windows.shift().error(err);}this.destination.error(err);};WindowTimeSubscriber.prototype._complete=function(){var windows=this.windows;while(windows.length>0){var window_2=windows.shift();if(!window_2.closed){window_2.complete();}}this.destination.complete();};WindowTimeSubscriber.prototype.openWindow=function(){var window=new CountedSubject();this.windows.push(window);var destination=this.destination;destination.next(window);return window;};WindowTimeSubscriber.prototype.closeWindow=function(window){window.complete();var windows=this.windows;windows.splice(windows.indexOf(window),1);};return WindowTimeSubscriber;}(Subscriber_1.Subscriber);function dispatchWindowTimeSpanOnly(state){var subscriber=state.subscriber,windowTimeSpan=state.windowTimeSpan,window=state.window;if(window){subscriber.closeWindow(window);}state.window=subscriber.openWindow();this.schedule(state,windowTimeSpan);}function dispatchWindowCreation(state){var windowTimeSpan=state.windowTimeSpan,subscriber=state.subscriber,scheduler=state.scheduler,windowCreationInterval=state.windowCreationInterval;var window=subscriber.openWindow();var action=this;var context={action:action,subscription:null};var timeSpanState={subscriber:subscriber,window:window,context:context};context.subscription=scheduler.schedule(dispatchWindowClose,windowTimeSpan,timeSpanState);action.add(context.subscription);action.schedule(state,windowCreationInterval);}function dispatchWindowClose(state){var subscriber=state.subscriber,window=state.window,context=state.context;if(context&&context.action&&context.subscription){context.action.remove(context.subscription);}subscriber.closeWindow(window);}//# sourceMappingURL=windowTime.js.map
  
  /***/ }),
  /* 152 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var Subscription_1=__webpack_require__(5);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Branch out the source Observable values as a nested Observable starting from
   * an emission from `openings` and ending when the output of `closingSelector`
   * emits.
   *
   * <span class="informal">It's like {@link bufferToggle}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowToggle.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits windows that contain those items
   * emitted by the source Observable between the time when the `openings`
   * Observable emits an item and when the Observable returned by
   * `closingSelector` emits an item.
   *
   * @example <caption>Every other second, emit the click events from the next 500ms</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var openings = Rx.Observable.interval(1000);
   * var result = clicks.windowToggle(openings, i =>
   *   i % 2 ? Rx.Observable.interval(500) : Rx.Observable.empty()
   * ).mergeAll();
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowWhen}
   * @see {@link bufferToggle}
   *
   * @param {Observable<O>} openings An observable of notifications to start new
   * windows.
   * @param {function(value: O): Observable} closingSelector A function that takes
   * the value emitted by the `openings` observable and returns an Observable,
   * which, when it emits (either `next` or `complete`), signals that the
   * associated window should complete.
   * @return {Observable<Observable<T>>} An observable of windows, which in turn
   * are Observables.
   * @method windowToggle
   * @owner Observable
   */function windowToggle(openings,closingSelector){return function(source){return source.lift(new WindowToggleOperator(openings,closingSelector));};}exports.windowToggle=windowToggle;var WindowToggleOperator=function(){function WindowToggleOperator(openings,closingSelector){this.openings=openings;this.closingSelector=closingSelector;}WindowToggleOperator.prototype.call=function(subscriber,source){return source.subscribe(new WindowToggleSubscriber(subscriber,this.openings,this.closingSelector));};return WindowToggleOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WindowToggleSubscriber=function(_super){__extends(WindowToggleSubscriber,_super);function WindowToggleSubscriber(destination,openings,closingSelector){_super.call(this,destination);this.openings=openings;this.closingSelector=closingSelector;this.contexts=[];this.add(this.openSubscription=subscribeToResult_1.subscribeToResult(this,openings,openings));}WindowToggleSubscriber.prototype._next=function(value){var contexts=this.contexts;if(contexts){var len=contexts.length;for(var i=0;i<len;i++){contexts[i].window.next(value);}}};WindowToggleSubscriber.prototype._error=function(err){var contexts=this.contexts;this.contexts=null;if(contexts){var len=contexts.length;var index=-1;while(++index<len){var context=contexts[index];context.window.error(err);context.subscription.unsubscribe();}}_super.prototype._error.call(this,err);};WindowToggleSubscriber.prototype._complete=function(){var contexts=this.contexts;this.contexts=null;if(contexts){var len=contexts.length;var index=-1;while(++index<len){var context=contexts[index];context.window.complete();context.subscription.unsubscribe();}}_super.prototype._complete.call(this);};WindowToggleSubscriber.prototype._unsubscribe=function(){var contexts=this.contexts;this.contexts=null;if(contexts){var len=contexts.length;var index=-1;while(++index<len){var context=contexts[index];context.window.unsubscribe();context.subscription.unsubscribe();}}};WindowToggleSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){if(outerValue===this.openings){var closingSelector=this.closingSelector;var closingNotifier=tryCatch_1.tryCatch(closingSelector)(innerValue);if(closingNotifier===errorObject_1.errorObject){return this.error(errorObject_1.errorObject.e);}else{var window_1=new Subject_1.Subject();var subscription=new Subscription_1.Subscription();var context={window:window_1,subscription:subscription};this.contexts.push(context);var innerSubscription=subscribeToResult_1.subscribeToResult(this,closingNotifier,context);if(innerSubscription.closed){this.closeWindow(this.contexts.length-1);}else{innerSubscription.context=context;subscription.add(innerSubscription);}this.destination.next(window_1);}}else{this.closeWindow(this.contexts.indexOf(outerValue));}};WindowToggleSubscriber.prototype.notifyError=function(err){this.error(err);};WindowToggleSubscriber.prototype.notifyComplete=function(inner){if(inner!==this.openSubscription){this.closeWindow(this.contexts.indexOf(inner.context));}};WindowToggleSubscriber.prototype.closeWindow=function(index){if(index===-1){return;}var contexts=this.contexts;var context=contexts[index];var window=context.window,subscription=context.subscription;contexts.splice(index,1);window.complete();subscription.unsubscribe();};return WindowToggleSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=windowToggle.js.map
  
  /***/ }),
  /* 153 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/**
   * Branch out the source Observable values as a nested Observable using a
   * factory function of closing Observables to determine when to start a new
   * window.
   *
   * <span class="informal">It's like {@link bufferWhen}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowWhen.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits connected, non-overlapping windows.
   * It emits the current window and opens a new one whenever the Observable
   * produced by the specified `closingSelector` function emits an item. The first
   * window is opened immediately when subscribing to the output Observable.
   *
   * @example <caption>Emit only the first two clicks events in every window of [1-5] random seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks
   *   .windowWhen(() => Rx.Observable.interval(1000 + Math.random() * 4000))
   *   .map(win => win.take(2)) // each window has at most 2 emissions
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link bufferWhen}
   *
   * @param {function(): Observable} closingSelector A function that takes no
   * arguments and returns an Observable that signals (on either `next` or
   * `complete`) when to close the previous window and start a new one.
   * @return {Observable<Observable<T>>} An observable of windows, which in turn
   * are Observables.
   * @method windowWhen
   * @owner Observable
   */function windowWhen(closingSelector){return function windowWhenOperatorFunction(source){return source.lift(new WindowOperator(closingSelector));};}exports.windowWhen=windowWhen;var WindowOperator=function(){function WindowOperator(closingSelector){this.closingSelector=closingSelector;}WindowOperator.prototype.call=function(subscriber,source){return source.subscribe(new WindowSubscriber(subscriber,this.closingSelector));};return WindowOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WindowSubscriber=function(_super){__extends(WindowSubscriber,_super);function WindowSubscriber(destination,closingSelector){_super.call(this,destination);this.destination=destination;this.closingSelector=closingSelector;this.openWindow();}WindowSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.openWindow(innerSub);};WindowSubscriber.prototype.notifyError=function(error,innerSub){this._error(error);};WindowSubscriber.prototype.notifyComplete=function(innerSub){this.openWindow(innerSub);};WindowSubscriber.prototype._next=function(value){this.window.next(value);};WindowSubscriber.prototype._error=function(err){this.window.error(err);this.destination.error(err);this.unsubscribeClosingNotification();};WindowSubscriber.prototype._complete=function(){this.window.complete();this.destination.complete();this.unsubscribeClosingNotification();};WindowSubscriber.prototype.unsubscribeClosingNotification=function(){if(this.closingNotification){this.closingNotification.unsubscribe();}};WindowSubscriber.prototype.openWindow=function(innerSub){if(innerSub===void 0){innerSub=null;}if(innerSub){this.remove(innerSub);innerSub.unsubscribe();}var prevWindow=this.window;if(prevWindow){prevWindow.complete();}var window=this.window=new Subject_1.Subject();this.destination.next(window);var closingNotifier=tryCatch_1.tryCatch(this.closingSelector)();if(closingNotifier===errorObject_1.errorObject){var err=errorObject_1.errorObject.e;this.destination.error(err);this.window.error(err);}else{this.add(this.closingNotification=subscribeToResult_1.subscribeToResult(this,closingNotifier));}};return WindowSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=windowWhen.js.map
  
  /***/ }),
  /* 154 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var OuterSubscriber_1=__webpack_require__(2);var subscribeToResult_1=__webpack_require__(3);/* tslint:enable:max-line-length *//**
   * Combines the source Observable with other Observables to create an Observable
   * whose values are calculated from the latest values of each, only when the
   * source emits.
   *
   * <span class="informal">Whenever the source Observable emits a value, it
   * computes a formula using that value plus the latest values from other input
   * Observables, then emits the output of that formula.</span>
   *
   * <img src="./img/withLatestFrom.png" width="100%">
   *
   * `withLatestFrom` combines each value from the source Observable (the
   * instance) with the latest values from the other input Observables only when
   * the source emits a value, optionally using a `project` function to determine
   * the value to be emitted on the output Observable. All input Observables must
   * emit at least one value before the output Observable will emit a value.
   *
   * @example <caption>On every click event, emit an array with the latest timer event plus the click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var result = clicks.withLatestFrom(timer);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineLatest}
   *
   * @param {ObservableInput} other An input Observable to combine with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Function} [project] Projection function for combining values
   * together. Receives all values in order of the Observables passed, where the
   * first parameter is a value from the source Observable. (e.g.
   * `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not
   * passed, arrays will be emitted on the output Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @method withLatestFrom
   * @owner Observable
   */function withLatestFrom(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}return function(source){var project;if(typeof args[args.length-1]==='function'){project=args.pop();}var observables=args;return source.lift(new WithLatestFromOperator(observables,project));};}exports.withLatestFrom=withLatestFrom;var WithLatestFromOperator=function(){function WithLatestFromOperator(observables,project){this.observables=observables;this.project=project;}WithLatestFromOperator.prototype.call=function(subscriber,source){return source.subscribe(new WithLatestFromSubscriber(subscriber,this.observables,this.project));};return WithLatestFromOperator;}();/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var WithLatestFromSubscriber=function(_super){__extends(WithLatestFromSubscriber,_super);function WithLatestFromSubscriber(destination,observables,project){_super.call(this,destination);this.observables=observables;this.project=project;this.toRespond=[];var len=observables.length;this.values=new Array(len);for(var i=0;i<len;i++){this.toRespond.push(i);}for(var i=0;i<len;i++){var observable=observables[i];this.add(subscribeToResult_1.subscribeToResult(this,observable,observable,i));}}WithLatestFromSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.values[outerIndex]=innerValue;var toRespond=this.toRespond;if(toRespond.length>0){var found=toRespond.indexOf(outerIndex);if(found!==-1){toRespond.splice(found,1);}}};WithLatestFromSubscriber.prototype.notifyComplete=function(){// noop
  };WithLatestFromSubscriber.prototype._next=function(value){if(this.toRespond.length===0){var args=[value].concat(this.values);if(this.project){this._tryProject(args);}else{this.destination.next(args);}}};WithLatestFromSubscriber.prototype._tryProject=function(args){var result;try{result=this.project.apply(this,args);}catch(err){this.destination.error(err);return;}this.destination.next(result);};return WithLatestFromSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=withLatestFrom.js.map
  
  /***/ }),
  /* 155 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var zip_1=__webpack_require__(35);function zipAll(project){return function(source){return source.lift(new zip_1.ZipOperator(project));};}exports.zipAll=zipAll;//# sourceMappingURL=zipAll.js.map
  
  /***/ }),
  /* 156 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var SubscriptionLog_1=__webpack_require__(157);var SubscriptionLoggable=function(){function SubscriptionLoggable(){this.subscriptions=[];}SubscriptionLoggable.prototype.logSubscribedFrame=function(){this.subscriptions.push(new SubscriptionLog_1.SubscriptionLog(this.scheduler.now()));return this.subscriptions.length-1;};SubscriptionLoggable.prototype.logUnsubscribedFrame=function(index){var subscriptionLogs=this.subscriptions;var oldSubscriptionLog=subscriptionLogs[index];subscriptionLogs[index]=new SubscriptionLog_1.SubscriptionLog(oldSubscriptionLog.subscribedFrame,this.scheduler.now());};return SubscriptionLoggable;}();exports.SubscriptionLoggable=SubscriptionLoggable;//# sourceMappingURL=SubscriptionLoggable.js.map
  
  /***/ }),
  /* 157 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var SubscriptionLog=function(){function SubscriptionLog(subscribedFrame,unsubscribedFrame){if(unsubscribedFrame===void 0){unsubscribedFrame=Number.POSITIVE_INFINITY;}this.subscribedFrame=subscribedFrame;this.unsubscribedFrame=unsubscribedFrame;}return SubscriptionLog;}();exports.SubscriptionLog=SubscriptionLog;//# sourceMappingURL=SubscriptionLog.js.map
  
  /***/ }),
  /* 158 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function applyMixins(derivedCtor,baseCtors){for(var i=0,len=baseCtors.length;i<len;i++){var baseCtor=baseCtors[i];var propertyKeys=Object.getOwnPropertyNames(baseCtor.prototype);for(var j=0,len2=propertyKeys.length;j<len2;j++){var name_1=propertyKeys[j];derivedCtor.prototype[name_1]=baseCtor.prototype[name_1];}}}exports.applyMixins=applyMixins;//# sourceMappingURL=applyMixins.js.map
  
  /***/ }),
  /* 159 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncAction_1=__webpack_require__(20);var AsyncScheduler_1=__webpack_require__(21);var VirtualTimeScheduler=function(_super){__extends(VirtualTimeScheduler,_super);function VirtualTimeScheduler(SchedulerAction,maxFrames){var _this=this;if(SchedulerAction===void 0){SchedulerAction=VirtualAction;}if(maxFrames===void 0){maxFrames=Number.POSITIVE_INFINITY;}_super.call(this,SchedulerAction,function(){return _this.frame;});this.maxFrames=maxFrames;this.frame=0;this.index=-1;}/**
       * Prompt the Scheduler to execute all of its queued actions, therefore
       * clearing its queue.
       * @return {void}
       */VirtualTimeScheduler.prototype.flush=function(){var _a=this,actions=_a.actions,maxFrames=_a.maxFrames;var error,action;while((action=actions.shift())&&(this.frame=action.delay)<=maxFrames){if(error=action.execute(action.state,action.delay)){break;}}if(error){while(action=actions.shift()){action.unsubscribe();}throw error;}};VirtualTimeScheduler.frameTimeFactor=10;return VirtualTimeScheduler;}(AsyncScheduler_1.AsyncScheduler);exports.VirtualTimeScheduler=VirtualTimeScheduler;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var VirtualAction=function(_super){__extends(VirtualAction,_super);function VirtualAction(scheduler,work,index){if(index===void 0){index=scheduler.index+=1;}_super.call(this,scheduler,work);this.scheduler=scheduler;this.work=work;this.index=index;this.active=true;this.index=scheduler.index=index;}VirtualAction.prototype.schedule=function(state,delay){if(delay===void 0){delay=0;}if(!this.id){return _super.prototype.schedule.call(this,state,delay);}this.active=false;// If an action is rescheduled, we save allocations by mutating its state,
  // pushing it to the end of the scheduler queue, and recycling the action.
  // But since the VirtualTimeScheduler is used for testing, VirtualActions
  // must be immutable so they can be inspected later.
  var action=new VirtualAction(this.scheduler,this.work);this.add(action);return action.schedule(state,delay);};VirtualAction.prototype.requestAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}this.delay=scheduler.frame+delay;var actions=scheduler.actions;actions.push(this);actions.sort(VirtualAction.sortActions);return true;};VirtualAction.prototype.recycleAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}return undefined;};VirtualAction.prototype._execute=function(state,delay){if(this.active===true){return _super.prototype._execute.call(this,state,delay);}};VirtualAction.sortActions=function(a,b){if(a.delay===b.delay){if(a.index===b.index){return 0;}else if(a.index>b.index){return 1;}else{return-1;}}else if(a.delay>b.delay){return 1;}else{return-1;}};return VirtualAction;}(AsyncAction_1.AsyncAction);exports.VirtualAction=VirtualAction;//# sourceMappingURL=VirtualTimeScheduler.js.map
  
  /***/ }),
  /* 160 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Subscriber_1=__webpack_require__(1);var rxSubscriber_1=__webpack_require__(26);var Observer_1=__webpack_require__(60);function toSubscriber(nextOrObserver,error,complete){if(nextOrObserver){if(nextOrObserver instanceof Subscriber_1.Subscriber){return nextOrObserver;}if(nextOrObserver[rxSubscriber_1.rxSubscriber]){return nextOrObserver[rxSubscriber_1.rxSubscriber]();}}if(!nextOrObserver&&!error&&!complete){return new Subscriber_1.Subscriber(Observer_1.empty);}return new Subscriber_1.Subscriber(nextOrObserver,error,complete);}exports.toSubscriber=toSubscriber;//# sourceMappingURL=toSubscriber.js.map
  
  /***/ }),
  /* 161 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bindCallback_1=__webpack_require__(162);Observable_1.Observable.bindCallback=bindCallback_1.bindCallback;//# sourceMappingURL=bindCallback.js.map
  
  /***/ }),
  /* 162 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var BoundCallbackObservable_1=__webpack_require__(163);exports.bindCallback=BoundCallbackObservable_1.BoundCallbackObservable.create;//# sourceMappingURL=bindCallback.js.map
  
  /***/ }),
  /* 163 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var AsyncSubject_1=__webpack_require__(29);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var BoundCallbackObservable=function(_super){__extends(BoundCallbackObservable,_super);function BoundCallbackObservable(callbackFunc,selector,args,context,scheduler){_super.call(this);this.callbackFunc=callbackFunc;this.selector=selector;this.args=args;this.context=context;this.scheduler=scheduler;}/* tslint:enable:max-line-length *//**
       * Converts a callback API to a function that returns an Observable.
       *
       * <span class="informal">Give it a function `f` of type `f(x, callback)` and
       * it will return a function `g` that when called as `g(x)` will output an
       * Observable.</span>
       *
       * `bindCallback` is not an operator because its input and output are not
       * Observables. The input is a function `func` with some parameters, the
       * last parameter must be a callback function that `func` calls when it is
       * done.
       *
       * The output of `bindCallback` is a function that takes the same parameters
       * as `func`, except the last one (the callback). When the output function
       * is called with arguments it will return an Observable. If function `func`
       * calls its callback with one argument the Observable will emit that value.
       * If on the other hand the callback is called with multiple values the resulting
       * Observable will emit an array with said values as arguments.
       *
       * It is very important to remember that input function `func` is not called
       * when the output function is, but rather when the Observable returned by the output
       * function is subscribed. This means if `func` makes an AJAX request, that request
       * will be made every time someone subscribes to the resulting Observable, but not before.
       *
       * Optionally, a selector function can be passed to `bindObservable`. The selector function
       * takes the same arguments as the callback and returns the value that will be emitted by the Observable.
       * Even though by default multiple arguments passed to callback appear in the stream as an array
       * the selector function will be called with arguments directly, just as the callback would.
       * This means you can imagine the default selector (when one is not provided explicitly)
       * as a function that aggregates all its arguments into an array, or simply returns first argument
       * if there is only one.
       *
       * The last optional parameter - {@link Scheduler} - can be used to control when the call
       * to `func` happens after someone subscribes to Observable, as well as when results
       * passed to callback will be emitted. By default, the subscription to  an Observable calls `func`
       * synchronously, but using `Scheduler.async` as the last parameter will defer the call to `func`,
       * just like wrapping the call in `setTimeout` with a timeout of `0` would. If you use the async Scheduler
       * and call `subscribe` on the output Observable all function calls that are currently executing
       * will end before `func` is invoked.
       *
       * By default results passed to the callback are emitted immediately after `func` invokes the callback.
       * In particular, if the callback is called synchronously the subscription of the resulting Observable
       * will call the `next` function synchronously as well.  If you want to defer that call,
       * you may use `Scheduler.async` just as before.  This means that by using `Scheduler.async` you can
       * ensure that `func` always calls its callback asynchronously, thus avoiding terrifying Zalgo.
       *
       * Note that the Observable created by the output function will always emit a single value
       * and then complete immediately. If `func` calls the callback multiple times, values from subsequent
       * calls will not appear in the stream. If you need to listen for multiple calls,
       *  you probably want to use {@link fromEvent} or {@link fromEventPattern} instead.
       *
       * If `func` depends on some context (`this` property) and is not already bound the context of `func`
       * will be the context that the output function has at call time. In particular, if `func`
       * is called as a method of some objec and if `func` is not already bound, in order to preserve the context
       * it is recommended that the context of the output function is set to that object as well.
       *
       * If the input function calls its callback in the "node style" (i.e. first argument to callback is
       * optional error parameter signaling whether the call failed or not), {@link bindNodeCallback}
       * provides convenient error handling and probably is a better choice.
       * `bindCallback` will treat such functions the same as any other and error parameters
       * (whether passed or not) will always be interpreted as regular callback argument.
       *
       *
       * @example <caption>Convert jQuery's getJSON to an Observable API</caption>
       * // Suppose we have jQuery.getJSON('/my/url', callback)
       * var getJSONAsObservable = Rx.Observable.bindCallback(jQuery.getJSON);
       * var result = getJSONAsObservable('/my/url');
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       *
       * @example <caption>Receive an array of arguments passed to a callback</caption>
       * someFunction((a, b, c) => {
       *   console.log(a); // 5
       *   console.log(b); // 'some string'
       *   console.log(c); // {someProperty: 'someValue'}
       * });
       *
       * const boundSomeFunction = Rx.Observable.bindCallback(someFunction);
       * boundSomeFunction().subscribe(values => {
       *   console.log(values) // [5, 'some string', {someProperty: 'someValue'}]
       * });
       *
       *
       * @example <caption>Use bindCallback with a selector function</caption>
       * someFunction((a, b, c) => {
       *   console.log(a); // 'a'
       *   console.log(b); // 'b'
       *   console.log(c); // 'c'
       * });
       *
       * const boundSomeFunction = Rx.Observable.bindCallback(someFunction, (a, b, c) => a + b + c);
       * boundSomeFunction().subscribe(value => {
       *   console.log(value) // 'abc'
       * });
       *
       *
       * @example <caption>Compare behaviour with and without async Scheduler</caption>
       * function iCallMyCallbackSynchronously(cb) {
       *   cb();
       * }
       *
       * const boundSyncFn = Rx.Observable.bindCallback(iCallMyCallbackSynchronously);
       * const boundAsyncFn = Rx.Observable.bindCallback(iCallMyCallbackSynchronously, null, Rx.Scheduler.async);
       *
       * boundSyncFn().subscribe(() => console.log('I was sync!'));
       * boundAsyncFn().subscribe(() => console.log('I was async!'));
       * console.log('This happened...');
       *
       * // Logs:
       * // I was sync!
       * // This happened...
       * // I was async!
       *
       *
       * @example <caption>Use bindCallback on an object method</caption>
       * const boundMethod = Rx.Observable.bindCallback(someObject.methodWithCallback);
       * boundMethod.call(someObject) // make sure methodWithCallback has access to someObject
       * .subscribe(subscriber);
       *
       *
       * @see {@link bindNodeCallback}
       * @see {@link from}
       * @see {@link fromPromise}
       *
       * @param {function} func A function with a callback as the last parameter.
       * @param {function} [selector] A function which takes the arguments from the
       * callback and maps them to a value that is emitted on the output Observable.
       * @param {Scheduler} [scheduler] The scheduler on which to schedule the
       * callbacks.
       * @return {function(...params: *): Observable} A function which returns the
       * Observable that delivers the same values the callback would deliver.
       * @static true
       * @name bindCallback
       * @owner Observable
       */BoundCallbackObservable.create=function(func,selector,scheduler){if(selector===void 0){selector=undefined;}return function(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}return new BoundCallbackObservable(func,selector,args,this,scheduler);};};BoundCallbackObservable.prototype._subscribe=function(subscriber){var callbackFunc=this.callbackFunc;var args=this.args;var scheduler=this.scheduler;var subject=this.subject;if(!scheduler){if(!subject){subject=this.subject=new AsyncSubject_1.AsyncSubject();var handler=function handlerFn(){var innerArgs=[];for(var _i=0;_i<arguments.length;_i++){innerArgs[_i-0]=arguments[_i];}var source=handlerFn.source;var selector=source.selector,subject=source.subject;if(selector){var result_1=tryCatch_1.tryCatch(selector).apply(this,innerArgs);if(result_1===errorObject_1.errorObject){subject.error(errorObject_1.errorObject.e);}else{subject.next(result_1);subject.complete();}}else{subject.next(innerArgs.length<=1?innerArgs[0]:innerArgs);subject.complete();}};// use named function instance to avoid closure.
  handler.source=this;var result=tryCatch_1.tryCatch(callbackFunc).apply(this.context,args.concat(handler));if(result===errorObject_1.errorObject){subject.error(errorObject_1.errorObject.e);}}return subject.subscribe(subscriber);}else{return scheduler.schedule(BoundCallbackObservable.dispatch,0,{source:this,subscriber:subscriber,context:this.context});}};BoundCallbackObservable.dispatch=function(state){var self=this;var source=state.source,subscriber=state.subscriber,context=state.context;var callbackFunc=source.callbackFunc,args=source.args,scheduler=source.scheduler;var subject=source.subject;if(!subject){subject=source.subject=new AsyncSubject_1.AsyncSubject();var handler=function handlerFn(){var innerArgs=[];for(var _i=0;_i<arguments.length;_i++){innerArgs[_i-0]=arguments[_i];}var source=handlerFn.source;var selector=source.selector,subject=source.subject;if(selector){var result_2=tryCatch_1.tryCatch(selector).apply(this,innerArgs);if(result_2===errorObject_1.errorObject){self.add(scheduler.schedule(dispatchError,0,{err:errorObject_1.errorObject.e,subject:subject}));}else{self.add(scheduler.schedule(dispatchNext,0,{value:result_2,subject:subject}));}}else{var value=innerArgs.length<=1?innerArgs[0]:innerArgs;self.add(scheduler.schedule(dispatchNext,0,{value:value,subject:subject}));}};// use named function to pass values in without closure
  handler.source=source;var result=tryCatch_1.tryCatch(callbackFunc).apply(context,args.concat(handler));if(result===errorObject_1.errorObject){subject.error(errorObject_1.errorObject.e);}}self.add(subject.subscribe(subscriber));};return BoundCallbackObservable;}(Observable_1.Observable);exports.BoundCallbackObservable=BoundCallbackObservable;function dispatchNext(arg){var value=arg.value,subject=arg.subject;subject.next(value);subject.complete();}function dispatchError(arg){var err=arg.err,subject=arg.subject;subject.error(err);}//# sourceMappingURL=BoundCallbackObservable.js.map
  
  /***/ }),
  /* 164 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bindNodeCallback_1=__webpack_require__(165);Observable_1.Observable.bindNodeCallback=bindNodeCallback_1.bindNodeCallback;//# sourceMappingURL=bindNodeCallback.js.map
  
  /***/ }),
  /* 165 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var BoundNodeCallbackObservable_1=__webpack_require__(166);exports.bindNodeCallback=BoundNodeCallbackObservable_1.BoundNodeCallbackObservable.create;//# sourceMappingURL=bindNodeCallback.js.map
  
  /***/ }),
  /* 166 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var AsyncSubject_1=__webpack_require__(29);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var BoundNodeCallbackObservable=function(_super){__extends(BoundNodeCallbackObservable,_super);function BoundNodeCallbackObservable(callbackFunc,selector,args,context,scheduler){_super.call(this);this.callbackFunc=callbackFunc;this.selector=selector;this.args=args;this.context=context;this.scheduler=scheduler;}/* tslint:enable:max-line-length *//**
       * Converts a Node.js-style callback API to a function that returns an
       * Observable.
       *
       * <span class="informal">It's just like {@link bindCallback}, but the
       * callback is expected to be of type `callback(error, result)`.</span>
       *
       * `bindNodeCallback` is not an operator because its input and output are not
       * Observables. The input is a function `func` with some parameters, but the
       * last parameter must be a callback function that `func` calls when it is
       * done. The callback function is expected to follow Node.js conventions,
       * where the first argument to the callback is an error object, signaling
       * whether call was successful. If that object is passed to callback, it means
       * something went wrong.
       *
       * The output of `bindNodeCallback` is a function that takes the same
       * parameters as `func`, except the last one (the callback). When the output
       * function is called with arguments, it will return an Observable.
       * If `func` calls its callback with error parameter present, Observable will
       * error with that value as well. If error parameter is not passed, Observable will emit
       * second parameter. If there are more parameters (third and so on),
       * Observable will emit an array with all arguments, except first error argument.
       *
       * Optionally `bindNodeCallback` accepts selector function, which allows you to
       * make resulting Observable emit value computed by selector, instead of regular
       * callback arguments. It works similarly to {@link bindCallback} selector, but
       * Node.js-style error argument will never be passed to that function.
       *
       * Note that `func` will not be called at the same time output function is,
       * but rather whenever resulting Observable is subscribed. By default call to
       * `func` will happen synchronously after subscription, but that can be changed
       * with proper {@link Scheduler} provided as optional third parameter. Scheduler
       * can also control when values from callback will be emitted by Observable.
       * To find out more, check out documentation for {@link bindCallback}, where
       * Scheduler works exactly the same.
       *
       * As in {@link bindCallback}, context (`this` property) of input function will be set to context
       * of returned function, when it is called.
       *
       * After Observable emits value, it will complete immediately. This means
       * even if `func` calls callback again, values from second and consecutive
       * calls will never appear on the stream. If you need to handle functions
       * that call callbacks multiple times, check out {@link fromEvent} or
       * {@link fromEventPattern} instead.
       *
       * Note that `bindNodeCallback` can be used in non-Node.js environments as well.
       * "Node.js-style" callbacks are just a convention, so if you write for
       * browsers or any other environment and API you use implements that callback style,
       * `bindNodeCallback` can be safely used on that API functions as well.
       *
       * Remember that Error object passed to callback does not have to be an instance
       * of JavaScript built-in `Error` object. In fact, it does not even have to an object.
       * Error parameter of callback function is interpreted as "present", when value
       * of that parameter is truthy. It could be, for example, non-zero number, non-empty
       * string or boolean `true`. In all of these cases resulting Observable would error
       * with that value. This means usually regular style callbacks will fail very often when
       * `bindNodeCallback` is used. If your Observable errors much more often then you
       * would expect, check if callback really is called in Node.js-style and, if not,
       * switch to {@link bindCallback} instead.
       *
       * Note that even if error parameter is technically present in callback, but its value
       * is falsy, it still won't appear in array emitted by Observable or in selector function.
       *
       *
       * @example <caption>Read a file from the filesystem and get the data as an Observable</caption>
       * import * as fs from 'fs';
       * var readFileAsObservable = Rx.Observable.bindNodeCallback(fs.readFile);
       * var result = readFileAsObservable('./roadNames.txt', 'utf8');
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       *
       * @example <caption>Use on function calling callback with multiple arguments</caption>
       * someFunction((err, a, b) => {
       *   console.log(err); // null
       *   console.log(a); // 5
       *   console.log(b); // "some string"
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
       * boundSomeFunction()
       * .subscribe(value => {
       *   console.log(value); // [5, "some string"]
       * });
       *
       *
       * @example <caption>Use with selector function</caption>
       * someFunction((err, a, b) => {
       *   console.log(err); // undefined
       *   console.log(a); // "abc"
       *   console.log(b); // "DEF"
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction, (a, b) => a + b);
       * boundSomeFunction()
       * .subscribe(value => {
       *   console.log(value); // "abcDEF"
       * });
       *
       *
       * @example <caption>Use on function calling callback in regular style</caption>
       * someFunction(a => {
       *   console.log(a); // 5
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
       * boundSomeFunction()
       * .subscribe(
       *   value => {}             // never gets called
       *   err => console.log(err) // 5
       *);
       *
       *
       * @see {@link bindCallback}
       * @see {@link from}
       * @see {@link fromPromise}
       *
       * @param {function} func Function with a Node.js-style callback as the last parameter.
       * @param {function} [selector] A function which takes the arguments from the
       * callback and maps those to a value to emit on the output Observable.
       * @param {Scheduler} [scheduler] The scheduler on which to schedule the
       * callbacks.
       * @return {function(...params: *): Observable} A function which returns the
       * Observable that delivers the same values the Node.js callback would
       * deliver.
       * @static true
       * @name bindNodeCallback
       * @owner Observable
       */BoundNodeCallbackObservable.create=function(func,selector,scheduler){if(selector===void 0){selector=undefined;}return function(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}return new BoundNodeCallbackObservable(func,selector,args,this,scheduler);};};BoundNodeCallbackObservable.prototype._subscribe=function(subscriber){var callbackFunc=this.callbackFunc;var args=this.args;var scheduler=this.scheduler;var subject=this.subject;if(!scheduler){if(!subject){subject=this.subject=new AsyncSubject_1.AsyncSubject();var handler=function handlerFn(){var innerArgs=[];for(var _i=0;_i<arguments.length;_i++){innerArgs[_i-0]=arguments[_i];}var source=handlerFn.source;var selector=source.selector,subject=source.subject;var err=innerArgs.shift();if(err){subject.error(err);}else if(selector){var result_1=tryCatch_1.tryCatch(selector).apply(this,innerArgs);if(result_1===errorObject_1.errorObject){subject.error(errorObject_1.errorObject.e);}else{subject.next(result_1);subject.complete();}}else{subject.next(innerArgs.length<=1?innerArgs[0]:innerArgs);subject.complete();}};// use named function instance to avoid closure.
  handler.source=this;var result=tryCatch_1.tryCatch(callbackFunc).apply(this.context,args.concat(handler));if(result===errorObject_1.errorObject){subject.error(errorObject_1.errorObject.e);}}return subject.subscribe(subscriber);}else{return scheduler.schedule(dispatch,0,{source:this,subscriber:subscriber,context:this.context});}};return BoundNodeCallbackObservable;}(Observable_1.Observable);exports.BoundNodeCallbackObservable=BoundNodeCallbackObservable;function dispatch(state){var self=this;var source=state.source,subscriber=state.subscriber,context=state.context;// XXX: cast to `any` to access to the private field in `source`.
  var _a=source,callbackFunc=_a.callbackFunc,args=_a.args,scheduler=_a.scheduler;var subject=source.subject;if(!subject){subject=source.subject=new AsyncSubject_1.AsyncSubject();var handler=function handlerFn(){var innerArgs=[];for(var _i=0;_i<arguments.length;_i++){innerArgs[_i-0]=arguments[_i];}var source=handlerFn.source;var selector=source.selector,subject=source.subject;var err=innerArgs.shift();if(err){self.add(scheduler.schedule(dispatchError,0,{err:err,subject:subject}));}else if(selector){var result_2=tryCatch_1.tryCatch(selector).apply(this,innerArgs);if(result_2===errorObject_1.errorObject){self.add(scheduler.schedule(dispatchError,0,{err:errorObject_1.errorObject.e,subject:subject}));}else{self.add(scheduler.schedule(dispatchNext,0,{value:result_2,subject:subject}));}}else{var value=innerArgs.length<=1?innerArgs[0]:innerArgs;self.add(scheduler.schedule(dispatchNext,0,{value:value,subject:subject}));}};// use named function to pass values in without closure
  handler.source=source;var result=tryCatch_1.tryCatch(callbackFunc).apply(context,args.concat(handler));if(result===errorObject_1.errorObject){self.add(scheduler.schedule(dispatchError,0,{err:errorObject_1.errorObject.e,subject:subject}));}}self.add(subject.subscribe(subscriber));}function dispatchNext(arg){var value=arg.value,subject=arg.subject;subject.next(value);subject.complete();}function dispatchError(arg){var err=arg.err,subject=arg.subject;subject.error(err);}//# sourceMappingURL=BoundNodeCallbackObservable.js.map
  
  /***/ }),
  /* 167 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var combineLatest_1=__webpack_require__(168);Observable_1.Observable.combineLatest=combineLatest_1.combineLatest;//# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 168 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var isScheduler_1=__webpack_require__(10);var isArray_1=__webpack_require__(11);var ArrayObservable_1=__webpack_require__(12);var combineLatest_1=__webpack_require__(30);/* tslint:enable:max-line-length *//**
   * Combines multiple Observables to create an Observable whose values are
   * calculated from the latest values of each of its input Observables.
   *
   * <span class="informal">Whenever any input Observable emits a value, it
   * computes a formula using the latest values from all the inputs, then emits
   * the output of that formula.</span>
   *
   * <img src="./img/combineLatest.png" width="100%">
   *
   * `combineLatest` combines the values from all the Observables passed as
   * arguments. This is done by subscribing to each Observable in order and,
   * whenever any Observable emits, collecting an array of the most recent
   * values from each Observable. So if you pass `n` Observables to operator,
   * returned Observable will always emit an array of `n` values, in order
   * corresponding to order of passed Observables (value from the first Observable
   * on the first place and so on).
   *
   * Static version of `combineLatest` accepts either an array of Observables
   * or each Observable can be put directly as an argument. Note that array of
   * Observables is good choice, if you don't know beforehand how many Observables
   * you will combine. Passing empty array will result in Observable that
   * completes immediately.
   *
   * To ensure output array has always the same length, `combineLatest` will
   * actually wait for all input Observables to emit at least once,
   * before it starts emitting results. This means if some Observable emits
   * values before other Observables started emitting, all that values but last
   * will be lost. On the other hand, is some Observable does not emit value but
   * completes, resulting Observable will complete at the same moment without
   * emitting anything, since it will be now impossible to include value from
   * completed Observable in resulting array. Also, if some input Observable does
   * not emit any value and never completes, `combineLatest` will also never emit
   * and never complete, since, again, it will wait for all streams to emit some
   * value.
   *
   * If at least one Observable was passed to `combineLatest` and all passed Observables
   * emitted something, resulting Observable will complete when all combined
   * streams complete. So even if some Observable completes, result of
   * `combineLatest` will still emit values when other Observables do. In case
   * of completed Observable, its value from now on will always be the last
   * emitted value. On the other hand, if any Observable errors, `combineLatest`
   * will error immediately as well, and all other Observables will be unsubscribed.
   *
   * `combineLatest` accepts as optional parameter `project` function, which takes
   * as arguments all values that would normally be emitted by resulting Observable.
   * `project` can return any kind of value, which will be then emitted by Observable
   * instead of default array. Note that `project` does not take as argument that array
   * of values, but values themselves. That means default `project` can be imagined
   * as function that takes all its arguments and puts them into an array.
   *
   *
   * @example <caption>Combine two timer Observables</caption>
   * const firstTimer = Rx.Observable.timer(0, 1000); // emit 0, 1, 2... after every second, starting from now
   * const secondTimer = Rx.Observable.timer(500, 1000); // emit 0, 1, 2... after every second, starting 0,5s from now
   * const combinedTimers = Rx.Observable.combineLatest(firstTimer, secondTimer);
   * combinedTimers.subscribe(value => console.log(value));
   * // Logs
   * // [0, 0] after 0.5s
   * // [1, 0] after 1s
   * // [1, 1] after 1.5s
   * // [2, 1] after 2s
   *
   *
   * @example <caption>Combine an array of Observables</caption>
   * const observables = [1, 5, 10].map(
   *   n => Rx.Observable.of(n).delay(n * 1000).startWith(0) // emit 0 and then emit n after n seconds
   * );
   * const combined = Rx.Observable.combineLatest(observables);
   * combined.subscribe(value => console.log(value));
   * // Logs
   * // [0, 0, 0] immediately
   * // [1, 0, 0] after 1s
   * // [1, 5, 0] after 5s
   * // [1, 5, 10] after 10s
   *
   *
   * @example <caption>Use project function to dynamically calculate the Body-Mass Index</caption>
   * var weight = Rx.Observable.of(70, 72, 76, 79, 75);
   * var height = Rx.Observable.of(1.76, 1.77, 1.78);
   * var bmi = Rx.Observable.combineLatest(weight, height, (w, h) => w / (h * h));
   * bmi.subscribe(x => console.log('BMI is ' + x));
   *
   * // With output to console:
   * // BMI is 24.212293388429753
   * // BMI is 23.93948099205209
   * // BMI is 23.671253629592222
   *
   *
   * @see {@link combineAll}
   * @see {@link merge}
   * @see {@link withLatestFrom}
   *
   * @param {ObservableInput} observable1 An input Observable to combine with other Observables.
   * @param {ObservableInput} observable2 An input Observable to combine with other Observables.
   * More than one input Observables may be given as arguments
   * or an array of Observables may be given as the first argument.
   * @param {function} [project] An optional function to project the values from
   * the combined latest values into a new value on the output Observable.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for subscribing to
   * each input Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @static true
   * @name combineLatest
   * @owner Observable
   */function combineLatest(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}var project=null;var scheduler=null;if(isScheduler_1.isScheduler(observables[observables.length-1])){scheduler=observables.pop();}if(typeof observables[observables.length-1]==='function'){project=observables.pop();}// if the first and only other argument besides the resultSelector is an array
  // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`
  if(observables.length===1&&isArray_1.isArray(observables[0])){observables=observables[0];}return new ArrayObservable_1.ArrayObservable(observables,scheduler).lift(new combineLatest_1.CombineLatestOperator(project));}exports.combineLatest=combineLatest;//# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 169 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscriber_1=__webpack_require__(1);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var InnerSubscriber=function(_super){__extends(InnerSubscriber,_super);function InnerSubscriber(parent,outerValue,outerIndex){_super.call(this);this.parent=parent;this.outerValue=outerValue;this.outerIndex=outerIndex;this.index=0;}InnerSubscriber.prototype._next=function(value){this.parent.notifyNext(this.outerValue,value,this.outerIndex,this.index++,this);};InnerSubscriber.prototype._error=function(error){this.parent.notifyError(error,this);this.unsubscribe();};InnerSubscriber.prototype._complete=function(){this.parent.notifyComplete(this);this.unsubscribe();};return InnerSubscriber;}(Subscriber_1.Subscriber);exports.InnerSubscriber=InnerSubscriber;//# sourceMappingURL=InnerSubscriber.js.map
  
  /***/ }),
  /* 170 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var concat_1=__webpack_require__(16);Observable_1.Observable.concat=concat_1.concat;//# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 171 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var root_1=__webpack_require__(9);var Observable_1=__webpack_require__(0);var iterator_1=__webpack_require__(15);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var IteratorObservable=function(_super){__extends(IteratorObservable,_super);function IteratorObservable(iterator,scheduler){_super.call(this);this.scheduler=scheduler;if(iterator==null){throw new Error('iterator cannot be null.');}this.iterator=getIterator(iterator);}IteratorObservable.create=function(iterator,scheduler){return new IteratorObservable(iterator,scheduler);};IteratorObservable.dispatch=function(state){var index=state.index,hasError=state.hasError,iterator=state.iterator,subscriber=state.subscriber;if(hasError){subscriber.error(state.error);return;}var result=iterator.next();if(result.done){subscriber.complete();return;}subscriber.next(result.value);state.index=index+1;if(subscriber.closed){if(typeof iterator.return==='function'){iterator.return();}return;}this.schedule(state);};IteratorObservable.prototype._subscribe=function(subscriber){var index=0;var _a=this,iterator=_a.iterator,scheduler=_a.scheduler;if(scheduler){return scheduler.schedule(IteratorObservable.dispatch,0,{index:index,iterator:iterator,subscriber:subscriber});}else{do{var result=iterator.next();if(result.done){subscriber.complete();break;}else{subscriber.next(result.value);}if(subscriber.closed){if(typeof iterator.return==='function'){iterator.return();}break;}}while(true);}};return IteratorObservable;}(Observable_1.Observable);exports.IteratorObservable=IteratorObservable;var StringIterator=function(){function StringIterator(str,idx,len){if(idx===void 0){idx=0;}if(len===void 0){len=str.length;}this.str=str;this.idx=idx;this.len=len;}StringIterator.prototype[iterator_1.iterator]=function(){return this;};StringIterator.prototype.next=function(){return this.idx<this.len?{done:false,value:this.str.charAt(this.idx++)}:{done:true,value:undefined};};return StringIterator;}();var ArrayIterator=function(){function ArrayIterator(arr,idx,len){if(idx===void 0){idx=0;}if(len===void 0){len=toLength(arr);}this.arr=arr;this.idx=idx;this.len=len;}ArrayIterator.prototype[iterator_1.iterator]=function(){return this;};ArrayIterator.prototype.next=function(){return this.idx<this.len?{done:false,value:this.arr[this.idx++]}:{done:true,value:undefined};};return ArrayIterator;}();function getIterator(obj){var i=obj[iterator_1.iterator];if(!i&&typeof obj==='string'){return new StringIterator(obj);}if(!i&&obj.length!==undefined){return new ArrayIterator(obj);}if(!i){throw new TypeError('object is not iterable');}return obj[iterator_1.iterator]();}var maxSafeInteger=Math.pow(2,53)-1;function toLength(o){var len=+o.length;if(isNaN(len)){return 0;}if(len===0||!numberIsFinite(len)){return len;}len=sign(len)*Math.floor(Math.abs(len));if(len<=0){return 0;}if(len>maxSafeInteger){return maxSafeInteger;}return len;}function numberIsFinite(value){return typeof value==='number'&&root_1.root.isFinite(value);}function sign(value){var valueAsNumber=+value;if(valueAsNumber===0){return valueAsNumber;}if(isNaN(valueAsNumber)){return valueAsNumber;}return valueAsNumber<0?-1:1;}//# sourceMappingURL=IteratorObservable.js.map
  
  /***/ }),
  /* 172 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var ScalarObservable_1=__webpack_require__(42);var EmptyObservable_1=__webpack_require__(13);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var ArrayLikeObservable=function(_super){__extends(ArrayLikeObservable,_super);function ArrayLikeObservable(arrayLike,scheduler){_super.call(this);this.arrayLike=arrayLike;this.scheduler=scheduler;if(!scheduler&&arrayLike.length===1){this._isScalar=true;this.value=arrayLike[0];}}ArrayLikeObservable.create=function(arrayLike,scheduler){var length=arrayLike.length;if(length===0){return new EmptyObservable_1.EmptyObservable();}else if(length===1){return new ScalarObservable_1.ScalarObservable(arrayLike[0],scheduler);}else{return new ArrayLikeObservable(arrayLike,scheduler);}};ArrayLikeObservable.dispatch=function(state){var arrayLike=state.arrayLike,index=state.index,length=state.length,subscriber=state.subscriber;if(subscriber.closed){return;}if(index>=length){subscriber.complete();return;}subscriber.next(arrayLike[index]);state.index=index+1;this.schedule(state);};ArrayLikeObservable.prototype._subscribe=function(subscriber){var index=0;var _a=this,arrayLike=_a.arrayLike,scheduler=_a.scheduler;var length=arrayLike.length;if(scheduler){return scheduler.schedule(ArrayLikeObservable.dispatch,0,{arrayLike:arrayLike,index:index,length:length,subscriber:subscriber});}else{for(var i=0;i<length&&!subscriber.closed;i++){subscriber.next(arrayLike[i]);}subscriber.complete();}};return ArrayLikeObservable;}(Observable_1.Observable);exports.ArrayLikeObservable=ArrayLikeObservable;//# sourceMappingURL=ArrayLikeObservable.js.map
  
  /***/ }),
  /* 173 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var defer_1=__webpack_require__(174);Observable_1.Observable.defer=defer_1.defer;//# sourceMappingURL=defer.js.map
  
  /***/ }),
  /* 174 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var DeferObservable_1=__webpack_require__(175);exports.defer=DeferObservable_1.DeferObservable.create;//# sourceMappingURL=defer.js.map
  
  /***/ }),
  /* 175 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var DeferObservable=function(_super){__extends(DeferObservable,_super);function DeferObservable(observableFactory){_super.call(this);this.observableFactory=observableFactory;}/**
       * Creates an Observable that, on subscribe, calls an Observable factory to
       * make an Observable for each new Observer.
       *
       * <span class="informal">Creates the Observable lazily, that is, only when it
       * is subscribed.
       * </span>
       *
       * <img src="./img/defer.png" width="100%">
       *
       * `defer` allows you to create the Observable only when the Observer
       * subscribes, and create a fresh Observable for each Observer. It waits until
       * an Observer subscribes to it, and then it generates an Observable,
       * typically with an Observable factory function. It does this afresh for each
       * subscriber, so although each subscriber may think it is subscribing to the
       * same Observable, in fact each subscriber gets its own individual
       * Observable.
       *
       * @example <caption>Subscribe to either an Observable of clicks or an Observable of interval, at random</caption>
       * var clicksOrInterval = Rx.Observable.defer(function () {
       *   if (Math.random() > 0.5) {
       *     return Rx.Observable.fromEvent(document, 'click');
       *   } else {
       *     return Rx.Observable.interval(1000);
       *   }
       * });
       * clicksOrInterval.subscribe(x => console.log(x));
       *
       * // Results in the following behavior:
       * // If the result of Math.random() is greater than 0.5 it will listen
       * // for clicks anywhere on the "document"; when document is clicked it
       * // will log a MouseEvent object to the console. If the result is less
       * // than 0.5 it will emit ascending numbers, one every second(1000ms).
       *
       * @see {@link create}
       *
       * @param {function(): SubscribableOrPromise} observableFactory The Observable
       * factory function to invoke for each Observer that subscribes to the output
       * Observable. May also return a Promise, which will be converted on the fly
       * to an Observable.
       * @return {Observable} An Observable whose Observers' subscriptions trigger
       * an invocation of the given Observable factory function.
       * @static true
       * @name defer
       * @owner Observable
       */DeferObservable.create=function(observableFactory){return new DeferObservable(observableFactory);};DeferObservable.prototype._subscribe=function(subscriber){return new DeferSubscriber(subscriber,this.observableFactory);};return DeferObservable;}(Observable_1.Observable);exports.DeferObservable=DeferObservable;var DeferSubscriber=function(_super){__extends(DeferSubscriber,_super);function DeferSubscriber(destination,factory){_super.call(this,destination);this.factory=factory;this.tryDefer();}DeferSubscriber.prototype.tryDefer=function(){try{this._callFactory();}catch(err){this._error(err);}};DeferSubscriber.prototype._callFactory=function(){var result=this.factory();if(result){this.add(subscribeToResult_1.subscribeToResult(this,result));}};return DeferSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=DeferObservable.js.map
  
  /***/ }),
  /* 176 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var empty_1=__webpack_require__(177);Observable_1.Observable.empty=empty_1.empty;//# sourceMappingURL=empty.js.map
  
  /***/ }),
  /* 177 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var EmptyObservable_1=__webpack_require__(13);exports.empty=EmptyObservable_1.EmptyObservable.create;//# sourceMappingURL=empty.js.map
  
  /***/ }),
  /* 178 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var forkJoin_1=__webpack_require__(179);Observable_1.Observable.forkJoin=forkJoin_1.forkJoin;//# sourceMappingURL=forkJoin.js.map
  
  /***/ }),
  /* 179 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ForkJoinObservable_1=__webpack_require__(180);exports.forkJoin=ForkJoinObservable_1.ForkJoinObservable.create;//# sourceMappingURL=forkJoin.js.map
  
  /***/ }),
  /* 180 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var EmptyObservable_1=__webpack_require__(13);var isArray_1=__webpack_require__(11);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var ForkJoinObservable=function(_super){__extends(ForkJoinObservable,_super);function ForkJoinObservable(sources,resultSelector){_super.call(this);this.sources=sources;this.resultSelector=resultSelector;}/* tslint:enable:max-line-length *//**
       * Joins last values emitted by passed Observables.
       *
       * <span class="informal">Wait for Observables to complete and then combine last values they emitted.</span>
       *
       * <img src="./img/forkJoin.png" width="100%">
       *
       * `forkJoin` is an operator that takes any number of Observables which can be passed either as an array
       * or directly as arguments. If no input Observables are provided, resulting stream will complete
       * immediately.
       *
       * `forkJoin` will wait for all passed Observables to complete and then it will emit an array with last
       * values from corresponding Observables. So if you pass `n` Observables to the operator, resulting
       * array will have `n` values, where first value is the last thing emitted by the first Observable,
       * second value is the last thing emitted by the second Observable and so on. That means `forkJoin` will
       * not emit more than once and it will complete after that. If you need to emit combined values not only
       * at the end of lifecycle of passed Observables, but also throughout it, try out {@link combineLatest}
       * or {@link zip} instead.
       *
       * In order for resulting array to have the same length as the number of input Observables, whenever any of
       * that Observables completes without emitting any value, `forkJoin` will complete at that moment as well
       * and it will not emit anything either, even if it already has some last values from other Observables.
       * Conversely, if there is an Observable that never completes, `forkJoin` will never complete as well,
       * unless at any point some other Observable completes without emitting value, which brings us back to
       * the previous case. Overall, in order for `forkJoin` to emit a value, all Observables passed as arguments
       * have to emit something at least once and complete.
       *
       * If any input Observable errors at some point, `forkJoin` will error as well and all other Observables
       * will be immediately unsubscribed.
       *
       * Optionally `forkJoin` accepts project function, that will be called with values which normally
       * would land in emitted array. Whatever is returned by project function, will appear in output
       * Observable instead. This means that default project can be thought of as a function that takes
       * all its arguments and puts them into an array. Note that project function will be called only
       * when output Observable is supposed to emit a result.
       *
       * @example <caption>Use forkJoin with operator emitting immediately</caption>
       * const observable = Rx.Observable.forkJoin(
       *   Rx.Observable.of(1, 2, 3, 4),
       *   Rx.Observable.of(5, 6, 7, 8)
       * );
       * observable.subscribe(
       *   value => console.log(value),
       *   err => {},
       *   () => console.log('This is how it ends!')
       * );
       *
       * // Logs:
       * // [4, 8]
       * // "This is how it ends!"
       *
       *
       * @example <caption>Use forkJoin with operator emitting after some time</caption>
       * const observable = Rx.Observable.forkJoin(
       *   Rx.Observable.interval(1000).take(3), // emit 0, 1, 2 every second and complete
       *   Rx.Observable.interval(500).take(4) // emit 0, 1, 2, 3 every half a second and complete
       * );
       * observable.subscribe(
       *   value => console.log(value),
       *   err => {},
       *   () => console.log('This is how it ends!')
       * );
       *
       * // Logs:
       * // [2, 3] after 3 seconds
       * // "This is how it ends!" immediately after
       *
       *
       * @example <caption>Use forkJoin with project function</caption>
       * const observable = Rx.Observable.forkJoin(
       *   Rx.Observable.interval(1000).take(3), // emit 0, 1, 2 every second and complete
       *   Rx.Observable.interval(500).take(4), // emit 0, 1, 2, 3 every half a second and complete
       *   (n, m) => n + m
       * );
       * observable.subscribe(
       *   value => console.log(value),
       *   err => {},
       *   () => console.log('This is how it ends!')
       * );
       *
       * // Logs:
       * // 5 after 3 seconds
       * // "This is how it ends!" immediately after
       *
       * @see {@link combineLatest}
       * @see {@link zip}
       *
       * @param {...SubscribableOrPromise} sources Any number of Observables provided either as an array or as an arguments
       * passed directly to the operator.
       * @param {function} [project] Function that takes values emitted by input Observables and returns value
       * that will appear in resulting Observable instead of default array.
       * @return {Observable} Observable emitting either an array of last values emitted by passed Observables
       * or value from project function.
       * @static true
       * @name forkJoin
       * @owner Observable
       */ForkJoinObservable.create=function(){var sources=[];for(var _i=0;_i<arguments.length;_i++){sources[_i-0]=arguments[_i];}if(sources===null||arguments.length===0){return new EmptyObservable_1.EmptyObservable();}var resultSelector=null;if(typeof sources[sources.length-1]==='function'){resultSelector=sources.pop();}// if the first and only other argument besides the resultSelector is an array
  // assume it's been called with `forkJoin([obs1, obs2, obs3], resultSelector)`
  if(sources.length===1&&isArray_1.isArray(sources[0])){sources=sources[0];}if(sources.length===0){return new EmptyObservable_1.EmptyObservable();}return new ForkJoinObservable(sources,resultSelector);};ForkJoinObservable.prototype._subscribe=function(subscriber){return new ForkJoinSubscriber(subscriber,this.sources,this.resultSelector);};return ForkJoinObservable;}(Observable_1.Observable);exports.ForkJoinObservable=ForkJoinObservable;/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ForkJoinSubscriber=function(_super){__extends(ForkJoinSubscriber,_super);function ForkJoinSubscriber(destination,sources,resultSelector){_super.call(this,destination);this.sources=sources;this.resultSelector=resultSelector;this.completed=0;this.haveValues=0;var len=sources.length;this.total=len;this.values=new Array(len);for(var i=0;i<len;i++){var source=sources[i];var innerSubscription=subscribeToResult_1.subscribeToResult(this,source,null,i);if(innerSubscription){innerSubscription.outerIndex=i;this.add(innerSubscription);}}}ForkJoinSubscriber.prototype.notifyNext=function(outerValue,innerValue,outerIndex,innerIndex,innerSub){this.values[outerIndex]=innerValue;if(!innerSub._hasValue){innerSub._hasValue=true;this.haveValues++;}};ForkJoinSubscriber.prototype.notifyComplete=function(innerSub){var destination=this.destination;var _a=this,haveValues=_a.haveValues,resultSelector=_a.resultSelector,values=_a.values;var len=values.length;if(!innerSub._hasValue){destination.complete();return;}this.completed++;if(this.completed!==len){return;}if(haveValues===len){var value=resultSelector?resultSelector.apply(this,values):values;destination.next(value);}destination.complete();};return ForkJoinSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=ForkJoinObservable.js.map
  
  /***/ }),
  /* 181 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var from_1=__webpack_require__(65);Observable_1.Observable.from=from_1.from;//# sourceMappingURL=from.js.map
  
  /***/ }),
  /* 182 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var fromEvent_1=__webpack_require__(183);Observable_1.Observable.fromEvent=fromEvent_1.fromEvent;//# sourceMappingURL=fromEvent.js.map
  
  /***/ }),
  /* 183 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var FromEventObservable_1=__webpack_require__(184);exports.fromEvent=FromEventObservable_1.FromEventObservable.create;//# sourceMappingURL=fromEvent.js.map
  
  /***/ }),
  /* 184 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var tryCatch_1=__webpack_require__(8);var isFunction_1=__webpack_require__(25);var errorObject_1=__webpack_require__(7);var Subscription_1=__webpack_require__(5);var toString=Object.prototype.toString;function isNodeStyleEventEmitter(sourceObj){return!!sourceObj&&typeof sourceObj.addListener==='function'&&typeof sourceObj.removeListener==='function';}function isJQueryStyleEventEmitter(sourceObj){return!!sourceObj&&typeof sourceObj.on==='function'&&typeof sourceObj.off==='function';}function isNodeList(sourceObj){return!!sourceObj&&toString.call(sourceObj)==='[object NodeList]';}function isHTMLCollection(sourceObj){return!!sourceObj&&toString.call(sourceObj)==='[object HTMLCollection]';}function isEventTarget(sourceObj){return!!sourceObj&&typeof sourceObj.addEventListener==='function'&&typeof sourceObj.removeEventListener==='function';}/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var FromEventObservable=function(_super){__extends(FromEventObservable,_super);function FromEventObservable(sourceObj,eventName,selector,options){_super.call(this);this.sourceObj=sourceObj;this.eventName=eventName;this.selector=selector;this.options=options;}/* tslint:enable:max-line-length *//**
       * Creates an Observable that emits events of a specific type coming from the
       * given event target.
       *
       * <span class="informal">Creates an Observable from DOM events, or Node.js
       * EventEmitter events or others.</span>
       *
       * <img src="./img/fromEvent.png" width="100%">
       *
       * `fromEvent` accepts as a first argument event target, which is an object with methods
       * for registering event handler functions. As a second argument it takes string that indicates
       * type of event we want to listen for. `fromEvent` supports selected types of event targets,
       * which are described in detail below. If your event target does not match any of the ones listed,
       * you should use {@link fromEventPattern}, which can be used on arbitrary APIs.
       * When it comes to APIs supported by `fromEvent`, their methods for adding and removing event
       * handler functions have different names, but they all accept a string describing event type
       * and function itself, which will be called whenever said event happens.
       *
       * Every time resulting Observable is subscribed, event handler function will be registered
       * to event target on given event type. When that event fires, value
       * passed as a first argument to registered function will be emitted by output Observable.
       * When Observable is unsubscribed, function will be unregistered from event target.
       *
       * Note that if event target calls registered function with more than one argument, second
       * and following arguments will not appear in resulting stream. In order to get access to them,
       * you can pass to `fromEvent` optional project function, which will be called with all arguments
       * passed to event handler. Output Observable will then emit value returned by project function,
       * instead of the usual value.
       *
       * Remember that event targets listed below are checked via duck typing. It means that
       * no matter what kind of object you have and no matter what environment you work in,
       * you can safely use `fromEvent` on that object if it exposes described methods (provided
       * of course they behave as was described above). So for example if Node.js library exposes
       * event target which has the same method names as DOM EventTarget, `fromEvent` is still
       * a good choice.
       *
       * If the API you use is more callback then event handler oriented (subscribed
       * callback function fires only once and thus there is no need to manually
       * unregister it), you should use {@link bindCallback} or {@link bindNodeCallback}
       * instead.
       *
       * `fromEvent` supports following types of event targets:
       *
       * **DOM EventTarget**
       *
       * This is an object with `addEventListener` and `removeEventListener` methods.
       *
       * In the browser, `addEventListener` accepts - apart from event type string and event
       * handler function arguments - optional third parameter, which is either an object or boolean,
       * both used for additional configuration how and when passed function will be called. When
       * `fromEvent` is used with event target of that type, you can provide this values
       * as third parameter as well.
       *
       * **Node.js EventEmitter**
       *
       * An object with `addListener` and `removeListener` methods.
       *
       * **JQuery-style event target**
       *
       * An object with `on` and `off` methods
       *
       * **DOM NodeList**
       *
       * List of DOM Nodes, returned for example by `document.querySelectorAll` or `Node.childNodes`.
       *
       * Although this collection is not event target in itself, `fromEvent` will iterate over all Nodes
       * it contains and install event handler function in every of them. When returned Observable
       * is unsubscribed, function will be removed from all Nodes.
       *
       * **DOM HtmlCollection**
       *
       * Just as in case of NodeList it is a collection of DOM nodes. Here as well event handler function is
       * installed and removed in each of elements.
       *
       *
       * @example <caption>Emits clicks happening on the DOM document</caption>
       * var clicks = Rx.Observable.fromEvent(document, 'click');
       * clicks.subscribe(x => console.log(x));
       *
       * // Results in:
       * // MouseEvent object logged to console every time a click
       * // occurs on the document.
       *
       *
       * @example <caption>Use addEventListener with capture option</caption>
       * var clicksInDocument = Rx.Observable.fromEvent(document, 'click', true); // note optional configuration parameter
       *                                                                          // which will be passed to addEventListener
       * var clicksInDiv = Rx.Observable.fromEvent(someDivInDocument, 'click');
       *
       * clicksInDocument.subscribe(() => console.log('document'));
       * clicksInDiv.subscribe(() => console.log('div'));
       *
       * // By default events bubble UP in DOM tree, so normally
       * // when we would click on div in document
       * // "div" would be logged first and then "document".
       * // Since we specified optional `capture` option, document
       * // will catch event when it goes DOWN DOM tree, so console
       * // will log "document" and then "div".
       *
       * @see {@link bindCallback}
       * @see {@link bindNodeCallback}
       * @see {@link fromEventPattern}
       *
       * @param {EventTargetLike} target The DOM EventTarget, Node.js
       * EventEmitter, JQuery-like event target, NodeList or HTMLCollection to attach the event handler to.
       * @param {string} eventName The event name of interest, being emitted by the
       * `target`.
       * @param {EventListenerOptions} [options] Options to pass through to addEventListener
       * @param {SelectorMethodSignature<T>} [selector] An optional function to
       * post-process results. It takes the arguments from the event handler and
       * should return a single value.
       * @return {Observable<T>}
       * @static true
       * @name fromEvent
       * @owner Observable
       */FromEventObservable.create=function(target,eventName,options,selector){if(isFunction_1.isFunction(options)){selector=options;options=undefined;}return new FromEventObservable(target,eventName,selector,options);};FromEventObservable.setupSubscription=function(sourceObj,eventName,handler,subscriber,options){var unsubscribe;if(isNodeList(sourceObj)||isHTMLCollection(sourceObj)){for(var i=0,len=sourceObj.length;i<len;i++){FromEventObservable.setupSubscription(sourceObj[i],eventName,handler,subscriber,options);}}else if(isEventTarget(sourceObj)){var source_1=sourceObj;sourceObj.addEventListener(eventName,handler,options);unsubscribe=function unsubscribe(){return source_1.removeEventListener(eventName,handler);};}else if(isJQueryStyleEventEmitter(sourceObj)){var source_2=sourceObj;sourceObj.on(eventName,handler);unsubscribe=function unsubscribe(){return source_2.off(eventName,handler);};}else if(isNodeStyleEventEmitter(sourceObj)){var source_3=sourceObj;sourceObj.addListener(eventName,handler);unsubscribe=function unsubscribe(){return source_3.removeListener(eventName,handler);};}else{throw new TypeError('Invalid event target');}subscriber.add(new Subscription_1.Subscription(unsubscribe));};FromEventObservable.prototype._subscribe=function(subscriber){var sourceObj=this.sourceObj;var eventName=this.eventName;var options=this.options;var selector=this.selector;var handler=selector?function(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}var result=tryCatch_1.tryCatch(selector).apply(void 0,args);if(result===errorObject_1.errorObject){subscriber.error(errorObject_1.errorObject.e);}else{subscriber.next(result);}}:function(e){return subscriber.next(e);};FromEventObservable.setupSubscription(sourceObj,eventName,handler,subscriber,options);};return FromEventObservable;}(Observable_1.Observable);exports.FromEventObservable=FromEventObservable;//# sourceMappingURL=FromEventObservable.js.map
  
  /***/ }),
  /* 185 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var fromEventPattern_1=__webpack_require__(186);Observable_1.Observable.fromEventPattern=fromEventPattern_1.fromEventPattern;//# sourceMappingURL=fromEventPattern.js.map
  
  /***/ }),
  /* 186 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var FromEventPatternObservable_1=__webpack_require__(187);exports.fromEventPattern=FromEventPatternObservable_1.FromEventPatternObservable.create;//# sourceMappingURL=fromEventPattern.js.map
  
  /***/ }),
  /* 187 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isFunction_1=__webpack_require__(25);var Observable_1=__webpack_require__(0);var Subscription_1=__webpack_require__(5);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var FromEventPatternObservable=function(_super){__extends(FromEventPatternObservable,_super);function FromEventPatternObservable(addHandler,removeHandler,selector){_super.call(this);this.addHandler=addHandler;this.removeHandler=removeHandler;this.selector=selector;}/**
       * Creates an Observable from an API based on addHandler/removeHandler
       * functions.
       *
       * <span class="informal">Converts any addHandler/removeHandler API to an
       * Observable.</span>
       *
       * <img src="./img/fromEventPattern.png" width="100%">
       *
       * Creates an Observable by using the `addHandler` and `removeHandler`
       * functions to add and remove the handlers, with an optional selector
       * function to project the event arguments to a result. The `addHandler` is
       * called when the output Observable is subscribed, and `removeHandler` is
       * called when the Subscription is unsubscribed.
       *
       * @example <caption>Emits clicks happening on the DOM document</caption>
       * function addClickHandler(handler) {
       *   document.addEventListener('click', handler);
       * }
       *
       * function removeClickHandler(handler) {
       *   document.removeEventListener('click', handler);
       * }
       *
       * var clicks = Rx.Observable.fromEventPattern(
       *   addClickHandler,
       *   removeClickHandler
       * );
       * clicks.subscribe(x => console.log(x));
       *
       * @see {@link from}
       * @see {@link fromEvent}
       *
       * @param {function(handler: Function): any} addHandler A function that takes
       * a `handler` function as argument and attaches it somehow to the actual
       * source of events.
       * @param {function(handler: Function, signal?: any): void} [removeHandler] An optional function that
       * takes a `handler` function as argument and removes it in case it was
       * previously attached using `addHandler`. if addHandler returns signal to teardown when remove,
       * removeHandler function will forward it.
       * @param {function(...args: any): T} [selector] An optional function to
       * post-process results. It takes the arguments from the event handler and
       * should return a single value.
       * @return {Observable<T>}
       * @static true
       * @name fromEventPattern
       * @owner Observable
       */FromEventPatternObservable.create=function(addHandler,removeHandler,selector){return new FromEventPatternObservable(addHandler,removeHandler,selector);};FromEventPatternObservable.prototype._subscribe=function(subscriber){var _this=this;var removeHandler=this.removeHandler;var handler=!!this.selector?function(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}_this._callSelector(subscriber,args);}:function(e){subscriber.next(e);};var retValue=this._callAddHandler(handler,subscriber);if(!isFunction_1.isFunction(removeHandler)){return;}subscriber.add(new Subscription_1.Subscription(function(){//TODO: determine whether or not to forward to error handler
  removeHandler(handler,retValue);}));};FromEventPatternObservable.prototype._callSelector=function(subscriber,args){try{var result=this.selector.apply(this,args);subscriber.next(result);}catch(e){subscriber.error(e);}};FromEventPatternObservable.prototype._callAddHandler=function(handler,errorSubscriber){try{return this.addHandler(handler)||null;}catch(e){errorSubscriber.error(e);}};return FromEventPatternObservable;}(Observable_1.Observable);exports.FromEventPatternObservable=FromEventPatternObservable;//# sourceMappingURL=FromEventPatternObservable.js.map
  
  /***/ }),
  /* 188 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var fromPromise_1=__webpack_require__(189);Observable_1.Observable.fromPromise=fromPromise_1.fromPromise;//# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  /* 189 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var PromiseObservable_1=__webpack_require__(67);exports.fromPromise=PromiseObservable_1.PromiseObservable.create;//# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  /* 190 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var generate_1=__webpack_require__(191);Observable_1.Observable.generate=generate_1.generate;//# sourceMappingURL=generate.js.map
  
  /***/ }),
  /* 191 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var GenerateObservable_1=__webpack_require__(192);exports.generate=GenerateObservable_1.GenerateObservable.create;//# sourceMappingURL=generate.js.map
  
  /***/ }),
  /* 192 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var isScheduler_1=__webpack_require__(10);var selfSelector=function selfSelector(value){return value;};/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var GenerateObservable=function(_super){__extends(GenerateObservable,_super);function GenerateObservable(initialState,condition,iterate,resultSelector,scheduler){_super.call(this);this.initialState=initialState;this.condition=condition;this.iterate=iterate;this.resultSelector=resultSelector;this.scheduler=scheduler;}GenerateObservable.create=function(initialStateOrOptions,condition,iterate,resultSelectorOrObservable,scheduler){if(arguments.length==1){return new GenerateObservable(initialStateOrOptions.initialState,initialStateOrOptions.condition,initialStateOrOptions.iterate,initialStateOrOptions.resultSelector||selfSelector,initialStateOrOptions.scheduler);}if(resultSelectorOrObservable===undefined||isScheduler_1.isScheduler(resultSelectorOrObservable)){return new GenerateObservable(initialStateOrOptions,condition,iterate,selfSelector,resultSelectorOrObservable);}return new GenerateObservable(initialStateOrOptions,condition,iterate,resultSelectorOrObservable,scheduler);};GenerateObservable.prototype._subscribe=function(subscriber){var state=this.initialState;if(this.scheduler){return this.scheduler.schedule(GenerateObservable.dispatch,0,{subscriber:subscriber,iterate:this.iterate,condition:this.condition,resultSelector:this.resultSelector,state:state});}var _a=this,condition=_a.condition,resultSelector=_a.resultSelector,iterate=_a.iterate;do{if(condition){var conditionResult=void 0;try{conditionResult=condition(state);}catch(err){subscriber.error(err);return;}if(!conditionResult){subscriber.complete();break;}}var value=void 0;try{value=resultSelector(state);}catch(err){subscriber.error(err);return;}subscriber.next(value);if(subscriber.closed){break;}try{state=iterate(state);}catch(err){subscriber.error(err);return;}}while(true);};GenerateObservable.dispatch=function(state){var subscriber=state.subscriber,condition=state.condition;if(subscriber.closed){return;}if(state.needIterate){try{state.state=state.iterate(state.state);}catch(err){subscriber.error(err);return;}}else{state.needIterate=true;}if(condition){var conditionResult=void 0;try{conditionResult=condition(state.state);}catch(err){subscriber.error(err);return;}if(!conditionResult){subscriber.complete();return;}if(subscriber.closed){return;}}var value;try{value=state.resultSelector(state.state);}catch(err){subscriber.error(err);return;}if(subscriber.closed){return;}subscriber.next(value);if(subscriber.closed){return;}return this.schedule(state);};return GenerateObservable;}(Observable_1.Observable);exports.GenerateObservable=GenerateObservable;//# sourceMappingURL=GenerateObservable.js.map
  
  /***/ }),
  /* 193 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var if_1=__webpack_require__(194);Observable_1.Observable.if=if_1._if;//# sourceMappingURL=if.js.map
  
  /***/ }),
  /* 194 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var IfObservable_1=__webpack_require__(195);exports._if=IfObservable_1.IfObservable.create;//# sourceMappingURL=if.js.map
  
  /***/ }),
  /* 195 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var IfObservable=function(_super){__extends(IfObservable,_super);function IfObservable(condition,thenSource,elseSource){_super.call(this);this.condition=condition;this.thenSource=thenSource;this.elseSource=elseSource;}IfObservable.create=function(condition,thenSource,elseSource){return new IfObservable(condition,thenSource,elseSource);};IfObservable.prototype._subscribe=function(subscriber){var _a=this,condition=_a.condition,thenSource=_a.thenSource,elseSource=_a.elseSource;return new IfSubscriber(subscriber,condition,thenSource,elseSource);};return IfObservable;}(Observable_1.Observable);exports.IfObservable=IfObservable;var IfSubscriber=function(_super){__extends(IfSubscriber,_super);function IfSubscriber(destination,condition,thenSource,elseSource){_super.call(this,destination);this.condition=condition;this.thenSource=thenSource;this.elseSource=elseSource;this.tryIf();}IfSubscriber.prototype.tryIf=function(){var _a=this,condition=_a.condition,thenSource=_a.thenSource,elseSource=_a.elseSource;var result;try{result=condition();var source=result?thenSource:elseSource;if(source){this.add(subscribeToResult_1.subscribeToResult(this,source));}else{this._complete();}}catch(err){this._error(err);}};return IfSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=IfObservable.js.map
  
  /***/ }),
  /* 196 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var interval_1=__webpack_require__(197);Observable_1.Observable.interval=interval_1.interval;//# sourceMappingURL=interval.js.map
  
  /***/ }),
  /* 197 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var IntervalObservable_1=__webpack_require__(198);exports.interval=IntervalObservable_1.IntervalObservable.create;//# sourceMappingURL=interval.js.map
  
  /***/ }),
  /* 198 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isNumeric_1=__webpack_require__(19);var Observable_1=__webpack_require__(0);var async_1=__webpack_require__(4);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var IntervalObservable=function(_super){__extends(IntervalObservable,_super);function IntervalObservable(period,scheduler){if(period===void 0){period=0;}if(scheduler===void 0){scheduler=async_1.async;}_super.call(this);this.period=period;this.scheduler=scheduler;if(!isNumeric_1.isNumeric(period)||period<0){this.period=0;}if(!scheduler||typeof scheduler.schedule!=='function'){this.scheduler=async_1.async;}}/**
       * Creates an Observable that emits sequential numbers every specified
       * interval of time, on a specified IScheduler.
       *
       * <span class="informal">Emits incremental numbers periodically in time.
       * </span>
       *
       * <img src="./img/interval.png" width="100%">
       *
       * `interval` returns an Observable that emits an infinite sequence of
       * ascending integers, with a constant interval of time of your choosing
       * between those emissions. The first emission is not sent immediately, but
       * only after the first period has passed. By default, this operator uses the
       * `async` IScheduler to provide a notion of time, but you may pass any
       * IScheduler to it.
       *
       * @example <caption>Emits ascending numbers, one every second (1000ms)</caption>
       * var numbers = Rx.Observable.interval(1000);
       * numbers.subscribe(x => console.log(x));
       *
       * @see {@link timer}
       * @see {@link delay}
       *
       * @param {number} [period=0] The interval size in milliseconds (by default)
       * or the time unit determined by the scheduler's clock.
       * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling
       * the emission of values, and providing a notion of "time".
       * @return {Observable} An Observable that emits a sequential number each time
       * interval.
       * @static true
       * @name interval
       * @owner Observable
       */IntervalObservable.create=function(period,scheduler){if(period===void 0){period=0;}if(scheduler===void 0){scheduler=async_1.async;}return new IntervalObservable(period,scheduler);};IntervalObservable.dispatch=function(state){var index=state.index,subscriber=state.subscriber,period=state.period;subscriber.next(index);if(subscriber.closed){return;}state.index+=1;this.schedule(state,period);};IntervalObservable.prototype._subscribe=function(subscriber){var index=0;var period=this.period;var scheduler=this.scheduler;subscriber.add(scheduler.schedule(IntervalObservable.dispatch,period,{index:index,subscriber:subscriber,period:period}));};return IntervalObservable;}(Observable_1.Observable);exports.IntervalObservable=IntervalObservable;//# sourceMappingURL=IntervalObservable.js.map
  
  /***/ }),
  /* 199 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subscription_1=__webpack_require__(5);/**
   * A unit of work to be executed in a {@link Scheduler}. An action is typically
   * created from within a Scheduler and an RxJS user does not need to concern
   * themselves about creating and manipulating an Action.
   *
   * ```ts
   * class Action<T> extends Subscription {
   *   new (scheduler: Scheduler, work: (state?: T) => void);
   *   schedule(state?: T, delay: number = 0): Subscription;
   * }
   * ```
   *
   * @class Action<T>
   */var Action=function(_super){__extends(Action,_super);function Action(scheduler,work){_super.call(this);}/**
       * Schedules this action on its parent Scheduler for execution. May be passed
       * some context object, `state`. May happen at some point in the future,
       * according to the `delay` parameter, if specified.
       * @param {T} [state] Some contextual data that the `work` function uses when
       * called by the Scheduler.
       * @param {number} [delay] Time to wait before executing the work, where the
       * time unit is implicit and defined by the Scheduler.
       * @return {void}
       */Action.prototype.schedule=function(state,delay){if(delay===void 0){delay=0;}return this;};return Action;}(Subscription_1.Subscription);exports.Action=Action;//# sourceMappingURL=Action.js.map
  
  /***/ }),
  /* 200 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /**
   * An execution context and a data structure to order tasks and schedule their
   * execution. Provides a notion of (potentially virtual) time, through the
   * `now()` getter method.
   *
   * Each unit of work in a Scheduler is called an {@link Action}.
   *
   * ```ts
   * class Scheduler {
   *   now(): number;
   *   schedule(work, delay?, state?): Subscription;
   * }
   * ```
   *
   * @class Scheduler
   */var Scheduler=function(){function Scheduler(SchedulerAction,now){if(now===void 0){now=Scheduler.now;}this.SchedulerAction=SchedulerAction;this.now=now;}/**
       * Schedules a function, `work`, for execution. May happen at some point in
       * the future, according to the `delay` parameter, if specified. May be passed
       * some context object, `state`, which will be passed to the `work` function.
       *
       * The given arguments will be processed an stored as an Action object in a
       * queue of actions.
       *
       * @param {function(state: ?T): ?Subscription} work A function representing a
       * task, or some unit of work to be executed by the Scheduler.
       * @param {number} [delay] Time to wait before executing the work, where the
       * time unit is implicit and defined by the Scheduler itself.
       * @param {T} [state] Some contextual data that the `work` function uses when
       * called by the Scheduler.
       * @return {Subscription} A subscription in order to be able to unsubscribe
       * the scheduled work.
       */Scheduler.prototype.schedule=function(work,delay,state){if(delay===void 0){delay=0;}return new this.SchedulerAction(this,work).schedule(state,delay);};Scheduler.now=Date.now?Date.now:function(){return+new Date();};return Scheduler;}();exports.Scheduler=Scheduler;//# sourceMappingURL=Scheduler.js.map
  
  /***/ }),
  /* 201 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var merge_1=__webpack_require__(33);Observable_1.Observable.merge=merge_1.merge;//# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 202 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var race_1=__webpack_require__(44);Observable_1.Observable.race=race_1.race;//# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 203 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var never_1=__webpack_require__(204);Observable_1.Observable.never=never_1.never;//# sourceMappingURL=never.js.map
  
  /***/ }),
  /* 204 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var NeverObservable_1=__webpack_require__(205);exports.never=NeverObservable_1.NeverObservable.create;//# sourceMappingURL=never.js.map
  
  /***/ }),
  /* 205 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var noop_1=__webpack_require__(41);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var NeverObservable=function(_super){__extends(NeverObservable,_super);function NeverObservable(){_super.call(this);}/**
       * Creates an Observable that emits no items to the Observer.
       *
       * <span class="informal">An Observable that never emits anything.</span>
       *
       * <img src="./img/never.png" width="100%">
       *
       * This static operator is useful for creating a simple Observable that emits
       * neither values nor errors nor the completion notification. It can be used
       * for testing purposes or for composing with other Observables. Please note
       * that by never emitting a complete notification, this Observable keeps the
       * subscription from being disposed automatically. Subscriptions need to be
       * manually disposed.
       *
       * @example <caption>Emit the number 7, then never emit anything else (not even complete).</caption>
       * function info() {
       *   console.log('Will not be called');
       * }
       * var result = Rx.Observable.never().startWith(7);
       * result.subscribe(x => console.log(x), info, info);
       *
       * @see {@link create}
       * @see {@link empty}
       * @see {@link of}
       * @see {@link throw}
       *
       * @return {Observable} A "never" Observable: never emits anything.
       * @static true
       * @name never
       * @owner Observable
       */NeverObservable.create=function(){return new NeverObservable();};NeverObservable.prototype._subscribe=function(subscriber){noop_1.noop();};return NeverObservable;}(Observable_1.Observable);exports.NeverObservable=NeverObservable;//# sourceMappingURL=NeverObservable.js.map
  
  /***/ }),
  /* 206 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var of_1=__webpack_require__(64);Observable_1.Observable.of=of_1.of;//# sourceMappingURL=of.js.map
  
  /***/ }),
  /* 207 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var onErrorResumeNext_1=__webpack_require__(208);Observable_1.Observable.onErrorResumeNext=onErrorResumeNext_1.onErrorResumeNext;//# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 208 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var onErrorResumeNext_1=__webpack_require__(45);exports.onErrorResumeNext=onErrorResumeNext_1.onErrorResumeNextStatic;//# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 209 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var pairs_1=__webpack_require__(210);Observable_1.Observable.pairs=pairs_1.pairs;//# sourceMappingURL=pairs.js.map
  
  /***/ }),
  /* 210 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var PairsObservable_1=__webpack_require__(211);exports.pairs=PairsObservable_1.PairsObservable.create;//# sourceMappingURL=pairs.js.map
  
  /***/ }),
  /* 211 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);function dispatch(state){var obj=state.obj,keys=state.keys,length=state.length,index=state.index,subscriber=state.subscriber;if(index===length){subscriber.complete();return;}var key=keys[index];subscriber.next([key,obj[key]]);state.index=index+1;this.schedule(state);}/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var PairsObservable=function(_super){__extends(PairsObservable,_super);function PairsObservable(obj,scheduler){_super.call(this);this.obj=obj;this.scheduler=scheduler;this.keys=Object.keys(obj);}/**
       * Convert an object into an observable sequence of [key, value] pairs
       * using an optional IScheduler to enumerate the object.
       *
       * @example <caption>Converts a javascript object to an Observable</caption>
       * var obj = {
       *   foo: 42,
       *   bar: 56,
       *   baz: 78
       * };
       *
       * var source = Rx.Observable.pairs(obj);
       *
       * var subscription = source.subscribe(
       *   function (x) {
       *     console.log('Next: %s', x);
       *   },
       *   function (err) {
       *     console.log('Error: %s', err);
       *   },
       *   function () {
       *     console.log('Completed');
       *   });
       *
       * @param {Object} obj The object to inspect and turn into an
       * Observable sequence.
       * @param {Scheduler} [scheduler] An optional IScheduler to run the
       * enumeration of the input sequence on.
       * @returns {(Observable<Array<string | T>>)} An observable sequence of
       * [key, value] pairs from the object.
       */PairsObservable.create=function(obj,scheduler){return new PairsObservable(obj,scheduler);};PairsObservable.prototype._subscribe=function(subscriber){var _a=this,keys=_a.keys,scheduler=_a.scheduler;var length=keys.length;if(scheduler){return scheduler.schedule(dispatch,0,{obj:this.obj,keys:keys,length:length,index:0,subscriber:subscriber});}else{for(var idx=0;idx<length;idx++){var key=keys[idx];subscriber.next([key,this.obj[key]]);}subscriber.complete();}};return PairsObservable;}(Observable_1.Observable);exports.PairsObservable=PairsObservable;//# sourceMappingURL=PairsObservable.js.map
  
  /***/ }),
  /* 212 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var range_1=__webpack_require__(213);Observable_1.Observable.range=range_1.range;//# sourceMappingURL=range.js.map
  
  /***/ }),
  /* 213 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var RangeObservable_1=__webpack_require__(214);exports.range=RangeObservable_1.RangeObservable.create;//# sourceMappingURL=range.js.map
  
  /***/ }),
  /* 214 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var RangeObservable=function(_super){__extends(RangeObservable,_super);function RangeObservable(start,count,scheduler){_super.call(this);this.start=start;this._count=count;this.scheduler=scheduler;}/**
       * Creates an Observable that emits a sequence of numbers within a specified
       * range.
       *
       * <span class="informal">Emits a sequence of numbers in a range.</span>
       *
       * <img src="./img/range.png" width="100%">
       *
       * `range` operator emits a range of sequential integers, in order, where you
       * select the `start` of the range and its `length`. By default, uses no
       * IScheduler and just delivers the notifications synchronously, but may use
       * an optional IScheduler to regulate those deliveries.
       *
       * @example <caption>Emits the numbers 1 to 10</caption>
       * var numbers = Rx.Observable.range(1, 10);
       * numbers.subscribe(x => console.log(x));
       *
       * @see {@link timer}
       * @see {@link interval}
       *
       * @param {number} [start=0] The value of the first integer in the sequence.
       * @param {number} [count=0] The number of sequential integers to generate.
       * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
       * the emissions of the notifications.
       * @return {Observable} An Observable of numbers that emits a finite range of
       * sequential integers.
       * @static true
       * @name range
       * @owner Observable
       */RangeObservable.create=function(start,count,scheduler){if(start===void 0){start=0;}if(count===void 0){count=0;}return new RangeObservable(start,count,scheduler);};RangeObservable.dispatch=function(state){var start=state.start,index=state.index,count=state.count,subscriber=state.subscriber;if(index>=count){subscriber.complete();return;}subscriber.next(start);if(subscriber.closed){return;}state.index=index+1;state.start=start+1;this.schedule(state);};RangeObservable.prototype._subscribe=function(subscriber){var index=0;var start=this.start;var count=this._count;var scheduler=this.scheduler;if(scheduler){return scheduler.schedule(RangeObservable.dispatch,0,{index:index,count:count,start:start,subscriber:subscriber});}else{do{if(index++>=count){subscriber.complete();break;}subscriber.next(start++);if(subscriber.closed){break;}}while(true);}};return RangeObservable;}(Observable_1.Observable);exports.RangeObservable=RangeObservable;//# sourceMappingURL=RangeObservable.js.map
  
  /***/ }),
  /* 215 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var using_1=__webpack_require__(216);Observable_1.Observable.using=using_1.using;//# sourceMappingURL=using.js.map
  
  /***/ }),
  /* 216 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var UsingObservable_1=__webpack_require__(217);exports.using=UsingObservable_1.UsingObservable.create;//# sourceMappingURL=using.js.map
  
  /***/ }),
  /* 217 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var subscribeToResult_1=__webpack_require__(3);var OuterSubscriber_1=__webpack_require__(2);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var UsingObservable=function(_super){__extends(UsingObservable,_super);function UsingObservable(resourceFactory,observableFactory){_super.call(this);this.resourceFactory=resourceFactory;this.observableFactory=observableFactory;}UsingObservable.create=function(resourceFactory,observableFactory){return new UsingObservable(resourceFactory,observableFactory);};UsingObservable.prototype._subscribe=function(subscriber){var _a=this,resourceFactory=_a.resourceFactory,observableFactory=_a.observableFactory;var resource;try{resource=resourceFactory();return new UsingSubscriber(subscriber,resource,observableFactory);}catch(err){subscriber.error(err);}};return UsingObservable;}(Observable_1.Observable);exports.UsingObservable=UsingObservable;var UsingSubscriber=function(_super){__extends(UsingSubscriber,_super);function UsingSubscriber(destination,resource,observableFactory){_super.call(this,destination);this.resource=resource;this.observableFactory=observableFactory;destination.add(resource);this.tryUse();}UsingSubscriber.prototype.tryUse=function(){try{var source=this.observableFactory.call(this,this.resource);if(source){this.add(subscribeToResult_1.subscribeToResult(this,source));}}catch(err){this._error(err);}};return UsingSubscriber;}(OuterSubscriber_1.OuterSubscriber);//# sourceMappingURL=UsingObservable.js.map
  
  /***/ }),
  /* 218 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var throw_1=__webpack_require__(219);Observable_1.Observable.throw=throw_1._throw;//# sourceMappingURL=throw.js.map
  
  /***/ }),
  /* 219 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ErrorObservable_1=__webpack_require__(220);exports._throw=ErrorObservable_1.ErrorObservable.create;//# sourceMappingURL=throw.js.map
  
  /***/ }),
  /* 220 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var ErrorObservable=function(_super){__extends(ErrorObservable,_super);function ErrorObservable(error,scheduler){_super.call(this);this.error=error;this.scheduler=scheduler;}/**
       * Creates an Observable that emits no items to the Observer and immediately
       * emits an error notification.
       *
       * <span class="informal">Just emits 'error', and nothing else.
       * </span>
       *
       * <img src="./img/throw.png" width="100%">
       *
       * This static operator is useful for creating a simple Observable that only
       * emits the error notification. It can be used for composing with other
       * Observables, such as in a {@link mergeMap}.
       *
       * @example <caption>Emit the number 7, then emit an error.</caption>
       * var result = Rx.Observable.throw(new Error('oops!')).startWith(7);
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       * @example <caption>Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 13</caption>
       * var interval = Rx.Observable.interval(1000);
       * var result = interval.mergeMap(x =>
       *   x === 13 ?
       *     Rx.Observable.throw('Thirteens are bad') :
       *     Rx.Observable.of('a', 'b', 'c')
       * );
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       * @see {@link create}
       * @see {@link empty}
       * @see {@link never}
       * @see {@link of}
       *
       * @param {any} error The particular Error to pass to the error notification.
       * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
       * the emission of the error notification.
       * @return {Observable} An error Observable: emits only the error notification
       * using the given error argument.
       * @static true
       * @name throw
       * @owner Observable
       */ErrorObservable.create=function(error,scheduler){return new ErrorObservable(error,scheduler);};ErrorObservable.dispatch=function(arg){var error=arg.error,subscriber=arg.subscriber;subscriber.error(error);};ErrorObservable.prototype._subscribe=function(subscriber){var error=this.error;var scheduler=this.scheduler;subscriber.syncErrorThrowable=true;if(scheduler){return scheduler.schedule(ErrorObservable.dispatch,0,{error:error,subscriber:subscriber});}else{subscriber.error(error);}};return ErrorObservable;}(Observable_1.Observable);exports.ErrorObservable=ErrorObservable;//# sourceMappingURL=ErrorObservable.js.map
  
  /***/ }),
  /* 221 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var timer_1=__webpack_require__(69);Observable_1.Observable.timer=timer_1.timer;//# sourceMappingURL=timer.js.map
  
  /***/ }),
  /* 222 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var isNumeric_1=__webpack_require__(19);var Observable_1=__webpack_require__(0);var async_1=__webpack_require__(4);var isScheduler_1=__webpack_require__(10);var isDate_1=__webpack_require__(34);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var TimerObservable=function(_super){__extends(TimerObservable,_super);function TimerObservable(dueTime,period,scheduler){if(dueTime===void 0){dueTime=0;}_super.call(this);this.period=-1;this.dueTime=0;if(isNumeric_1.isNumeric(period)){this.period=Number(period)<1&&1||Number(period);}else if(isScheduler_1.isScheduler(period)){scheduler=period;}if(!isScheduler_1.isScheduler(scheduler)){scheduler=async_1.async;}this.scheduler=scheduler;this.dueTime=isDate_1.isDate(dueTime)?+dueTime-this.scheduler.now():dueTime;}/**
       * Creates an Observable that starts emitting after an `initialDelay` and
       * emits ever increasing numbers after each `period` of time thereafter.
       *
       * <span class="informal">Its like {@link interval}, but you can specify when
       * should the emissions start.</span>
       *
       * <img src="./img/timer.png" width="100%">
       *
       * `timer` returns an Observable that emits an infinite sequence of ascending
       * integers, with a constant interval of time, `period` of your choosing
       * between those emissions. The first emission happens after the specified
       * `initialDelay`. The initial delay may be a {@link Date}. By default, this
       * operator uses the `async` IScheduler to provide a notion of time, but you
       * may pass any IScheduler to it. If `period` is not specified, the output
       * Observable emits only one value, `0`. Otherwise, it emits an infinite
       * sequence.
       *
       * @example <caption>Emits ascending numbers, one every second (1000ms), starting after 3 seconds</caption>
       * var numbers = Rx.Observable.timer(3000, 1000);
       * numbers.subscribe(x => console.log(x));
       *
       * @example <caption>Emits one number after five seconds</caption>
       * var numbers = Rx.Observable.timer(5000);
       * numbers.subscribe(x => console.log(x));
       *
       * @see {@link interval}
       * @see {@link delay}
       *
       * @param {number|Date} initialDelay The initial delay time to wait before
       * emitting the first value of `0`.
       * @param {number} [period] The period of time between emissions of the
       * subsequent numbers.
       * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling
       * the emission of values, and providing a notion of "time".
       * @return {Observable} An Observable that emits a `0` after the
       * `initialDelay` and ever increasing numbers after each `period` of time
       * thereafter.
       * @static true
       * @name timer
       * @owner Observable
       */TimerObservable.create=function(initialDelay,period,scheduler){if(initialDelay===void 0){initialDelay=0;}return new TimerObservable(initialDelay,period,scheduler);};TimerObservable.dispatch=function(state){var index=state.index,period=state.period,subscriber=state.subscriber;var action=this;subscriber.next(index);if(subscriber.closed){return;}else if(period===-1){return subscriber.complete();}state.index=index+1;action.schedule(state,period);};TimerObservable.prototype._subscribe=function(subscriber){var index=0;var _a=this,period=_a.period,dueTime=_a.dueTime,scheduler=_a.scheduler;return scheduler.schedule(TimerObservable.dispatch,dueTime,{index:index,period:period,subscriber:subscriber});};return TimerObservable;}(Observable_1.Observable);exports.TimerObservable=TimerObservable;//# sourceMappingURL=TimerObservable.js.map
  
  /***/ }),
  /* 223 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var zip_1=__webpack_require__(224);Observable_1.Observable.zip=zip_1.zip;//# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 224 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var zip_1=__webpack_require__(35);exports.zip=zip_1.zipStatic;//# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 225 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var ajax_1=__webpack_require__(226);Observable_1.Observable.ajax=ajax_1.ajax;//# sourceMappingURL=ajax.js.map
  
  /***/ }),
  /* 226 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var AjaxObservable_1=__webpack_require__(70);exports.ajax=AjaxObservable_1.AjaxObservable.create;//# sourceMappingURL=ajax.js.map
  
  /***/ }),
  /* 227 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var webSocket_1=__webpack_require__(228);Observable_1.Observable.webSocket=webSocket_1.webSocket;//# sourceMappingURL=webSocket.js.map
  
  /***/ }),
  /* 228 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var WebSocketSubject_1=__webpack_require__(229);exports.webSocket=WebSocketSubject_1.WebSocketSubject.create;//# sourceMappingURL=webSocket.js.map
  
  /***/ }),
  /* 229 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var Subscriber_1=__webpack_require__(1);var Observable_1=__webpack_require__(0);var Subscription_1=__webpack_require__(5);var root_1=__webpack_require__(9);var ReplaySubject_1=__webpack_require__(36);var tryCatch_1=__webpack_require__(8);var errorObject_1=__webpack_require__(7);var assign_1=__webpack_require__(232);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var WebSocketSubject=function(_super){__extends(WebSocketSubject,_super);function WebSocketSubject(urlConfigOrSource,destination){if(urlConfigOrSource instanceof Observable_1.Observable){_super.call(this,destination,urlConfigOrSource);}else{_super.call(this);this.WebSocketCtor=root_1.root.WebSocket;this._output=new Subject_1.Subject();if(typeof urlConfigOrSource==='string'){this.url=urlConfigOrSource;}else{// WARNING: config object could override important members here.
  assign_1.assign(this,urlConfigOrSource);}if(!this.WebSocketCtor){throw new Error('no WebSocket constructor can be found');}this.destination=new ReplaySubject_1.ReplaySubject();}}WebSocketSubject.prototype.resultSelector=function(e){return JSON.parse(e.data);};/**
       * Wrapper around the w3c-compatible WebSocket object provided by the browser.
       *
       * @example <caption>Wraps browser WebSocket</caption>
       *
       * let socket$ = Observable.webSocket('ws://localhost:8081');
       *
       * socket$.subscribe(
       *    (msg) => console.log('message received: ' + msg),
       *    (err) => console.log(err),
       *    () => console.log('complete')
       *  );
       *
       * socket$.next(JSON.stringify({ op: 'hello' }));
       *
       * @example <caption>Wraps WebSocket from nodejs-websocket (using node.js)</caption>
       *
       * import { w3cwebsocket } from 'websocket';
       *
       * let socket$ = Observable.webSocket({
       *   url: 'ws://localhost:8081',
       *   WebSocketCtor: w3cwebsocket
       * });
       *
       * socket$.subscribe(
       *    (msg) => console.log('message received: ' + msg),
       *    (err) => console.log(err),
       *    () => console.log('complete')
       *  );
       *
       * socket$.next(JSON.stringify({ op: 'hello' }));
       *
       * @param {string | WebSocketSubjectConfig} urlConfigOrSource the source of the websocket as an url or a structure defining the websocket object
       * @return {WebSocketSubject}
       * @static true
       * @name webSocket
       * @owner Observable
       */WebSocketSubject.create=function(urlConfigOrSource){return new WebSocketSubject(urlConfigOrSource);};WebSocketSubject.prototype.lift=function(operator){var sock=new WebSocketSubject(this,this.destination);sock.operator=operator;return sock;};WebSocketSubject.prototype._resetState=function(){this.socket=null;if(!this.source){this.destination=new ReplaySubject_1.ReplaySubject();}this._output=new Subject_1.Subject();};// TODO: factor this out to be a proper Operator/Subscriber implementation and eliminate closures
  WebSocketSubject.prototype.multiplex=function(subMsg,unsubMsg,messageFilter){var self=this;return new Observable_1.Observable(function(observer){var result=tryCatch_1.tryCatch(subMsg)();if(result===errorObject_1.errorObject){observer.error(errorObject_1.errorObject.e);}else{self.next(result);}var subscription=self.subscribe(function(x){var result=tryCatch_1.tryCatch(messageFilter)(x);if(result===errorObject_1.errorObject){observer.error(errorObject_1.errorObject.e);}else if(result){observer.next(x);}},function(err){return observer.error(err);},function(){return observer.complete();});return function(){var result=tryCatch_1.tryCatch(unsubMsg)();if(result===errorObject_1.errorObject){observer.error(errorObject_1.errorObject.e);}else{self.next(result);}subscription.unsubscribe();};});};WebSocketSubject.prototype._connectSocket=function(){var _this=this;var WebSocketCtor=this.WebSocketCtor;var observer=this._output;var socket=null;try{socket=this.protocol?new WebSocketCtor(this.url,this.protocol):new WebSocketCtor(this.url);this.socket=socket;if(this.binaryType){this.socket.binaryType=this.binaryType;}}catch(e){observer.error(e);return;}var subscription=new Subscription_1.Subscription(function(){_this.socket=null;if(socket&&socket.readyState===1){socket.close();}});socket.onopen=function(e){var openObserver=_this.openObserver;if(openObserver){openObserver.next(e);}var queue=_this.destination;_this.destination=Subscriber_1.Subscriber.create(function(x){return socket.readyState===1&&socket.send(x);},function(e){var closingObserver=_this.closingObserver;if(closingObserver){closingObserver.next(undefined);}if(e&&e.code){socket.close(e.code,e.reason);}else{observer.error(new TypeError('WebSocketSubject.error must be called with an object with an error code, '+'and an optional reason: { code: number, reason: string }'));}_this._resetState();},function(){var closingObserver=_this.closingObserver;if(closingObserver){closingObserver.next(undefined);}socket.close();_this._resetState();});if(queue&&queue instanceof ReplaySubject_1.ReplaySubject){subscription.add(queue.subscribe(_this.destination));}};socket.onerror=function(e){_this._resetState();observer.error(e);};socket.onclose=function(e){_this._resetState();var closeObserver=_this.closeObserver;if(closeObserver){closeObserver.next(e);}if(e.wasClean){observer.complete();}else{observer.error(e);}};socket.onmessage=function(e){var result=tryCatch_1.tryCatch(_this.resultSelector)(e);if(result===errorObject_1.errorObject){observer.error(errorObject_1.errorObject.e);}else{observer.next(result);}};};WebSocketSubject.prototype._subscribe=function(subscriber){var _this=this;var source=this.source;if(source){return source.subscribe(subscriber);}if(!this.socket){this._connectSocket();}var subscription=new Subscription_1.Subscription();subscription.add(this._output.subscribe(subscriber));subscription.add(function(){var socket=_this.socket;if(_this._output.observers.length===0){if(socket&&socket.readyState===1){socket.close();}_this._resetState();}});return subscription;};WebSocketSubject.prototype.unsubscribe=function(){var _a=this,source=_a.source,socket=_a.socket;if(socket&&socket.readyState===1){socket.close();this._resetState();}_super.prototype.unsubscribe.call(this);if(!source){this.destination=new ReplaySubject_1.ReplaySubject();}};return WebSocketSubject;}(Subject_1.AnonymousSubject);exports.WebSocketSubject=WebSocketSubject;//# sourceMappingURL=WebSocketSubject.js.map
  
  /***/ }),
  /* 230 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncAction_1=__webpack_require__(20);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var QueueAction=function(_super){__extends(QueueAction,_super);function QueueAction(scheduler,work){_super.call(this,scheduler,work);this.scheduler=scheduler;this.work=work;}QueueAction.prototype.schedule=function(state,delay){if(delay===void 0){delay=0;}if(delay>0){return _super.prototype.schedule.call(this,state,delay);}this.delay=delay;this.state=state;this.scheduler.flush(this);return this;};QueueAction.prototype.execute=function(state,delay){return delay>0||this.closed?_super.prototype.execute.call(this,state,delay):this._execute(state,delay);};QueueAction.prototype.requestAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If delay exists and is greater than 0, or if the delay is null (the
  // action wasn't rescheduled) but was originally scheduled as an async
  // action, then recycle as an async action.
  if(delay!==null&&delay>0||delay===null&&this.delay>0){return _super.prototype.requestAsyncId.call(this,scheduler,id,delay);}// Otherwise flush the scheduler starting with this action.
  return scheduler.flush(this);};return QueueAction;}(AsyncAction_1.AsyncAction);exports.QueueAction=QueueAction;//# sourceMappingURL=QueueAction.js.map
  
  /***/ }),
  /* 231 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncScheduler_1=__webpack_require__(21);var QueueScheduler=function(_super){__extends(QueueScheduler,_super);function QueueScheduler(){_super.apply(this,arguments);}return QueueScheduler;}(AsyncScheduler_1.AsyncScheduler);exports.QueueScheduler=QueueScheduler;//# sourceMappingURL=QueueScheduler.js.map
  
  /***/ }),
  /* 232 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);function assignImpl(target){var sources=[];for(var _i=1;_i<arguments.length;_i++){sources[_i-1]=arguments[_i];}var len=sources.length;for(var i=0;i<len;i++){var source=sources[i];for(var k in source){if(source.hasOwnProperty(k)){target[k]=source[k];}}}return target;}exports.assignImpl=assignImpl;;function getAssign(root){return root.Object.assign||assignImpl;}exports.getAssign=getAssign;exports.assign=getAssign(root_1.root);//# sourceMappingURL=assign.js.map
  
  /***/ }),
  /* 233 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var buffer_1=__webpack_require__(234);Observable_1.Observable.prototype.buffer=buffer_1.buffer;//# sourceMappingURL=buffer.js.map
  
  /***/ }),
  /* 234 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var buffer_1=__webpack_require__(72);/**
   * Buffers the source Observable values until `closingNotifier` emits.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * that array only when another Observable emits.</span>
   *
   * <img src="./img/buffer.png" width="100%">
   *
   * Buffers the incoming Observable values until the given `closingNotifier`
   * Observable emits a value, at which point it emits the buffer on the output
   * Observable and starts a new buffer internally, awaiting the next time
   * `closingNotifier` emits.
   *
   * @example <caption>On every click, emit array of most recent interval events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var interval = Rx.Observable.interval(1000);
   * var buffered = interval.buffer(clicks);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link window}
   *
   * @param {Observable<any>} closingNotifier An Observable that signals the
   * buffer to be emitted on the output Observable.
   * @return {Observable<T[]>} An Observable of buffers, which are arrays of
   * values.
   * @method buffer
   * @owner Observable
   */function buffer(closingNotifier){return buffer_1.buffer(closingNotifier)(this);}exports.buffer=buffer;//# sourceMappingURL=buffer.js.map
  
  /***/ }),
  /* 235 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bufferCount_1=__webpack_require__(236);Observable_1.Observable.prototype.bufferCount=bufferCount_1.bufferCount;//# sourceMappingURL=bufferCount.js.map
  
  /***/ }),
  /* 236 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var bufferCount_1=__webpack_require__(73);/**
   * Buffers the source Observable values until the size hits the maximum
   * `bufferSize` given.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * that array only when its size reaches `bufferSize`.</span>
   *
   * <img src="./img/bufferCount.png" width="100%">
   *
   * Buffers a number of values from the source Observable by `bufferSize` then
   * emits the buffer and clears it, and starts a new buffer each
   * `startBufferEvery` values. If `startBufferEvery` is not provided or is
   * `null`, then new buffers are started immediately at the start of the source
   * and when each buffer closes and is emitted.
   *
   * @example <caption>Emit the last two click events as an array</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferCount(2);
   * buffered.subscribe(x => console.log(x));
   *
   * @example <caption>On every click, emit the last two click events as an array</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferCount(2, 1);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link pairwise}
   * @see {@link windowCount}
   *
   * @param {number} bufferSize The maximum size of the buffer emitted.
   * @param {number} [startBufferEvery] Interval at which to start a new buffer.
   * For example if `startBufferEvery` is `2`, then a new buffer will be started
   * on every other value from the source. A new buffer is started at the
   * beginning of the source by default.
   * @return {Observable<T[]>} An Observable of arrays of buffered values.
   * @method bufferCount
   * @owner Observable
   */function bufferCount(bufferSize,startBufferEvery){if(startBufferEvery===void 0){startBufferEvery=null;}return bufferCount_1.bufferCount(bufferSize,startBufferEvery)(this);}exports.bufferCount=bufferCount;//# sourceMappingURL=bufferCount.js.map
  
  /***/ }),
  /* 237 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bufferTime_1=__webpack_require__(238);Observable_1.Observable.prototype.bufferTime=bufferTime_1.bufferTime;//# sourceMappingURL=bufferTime.js.map
  
  /***/ }),
  /* 238 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var isScheduler_1=__webpack_require__(10);var bufferTime_1=__webpack_require__(74);/* tslint:enable:max-line-length *//**
   * Buffers the source Observable values for a specific time period.
   *
   * <span class="informal">Collects values from the past as an array, and emits
   * those arrays periodically in time.</span>
   *
   * <img src="./img/bufferTime.png" width="100%">
   *
   * Buffers values from the source for a specific time duration `bufferTimeSpan`.
   * Unless the optional argument `bufferCreationInterval` is given, it emits and
   * resets the buffer every `bufferTimeSpan` milliseconds. If
   * `bufferCreationInterval` is given, this operator opens the buffer every
   * `bufferCreationInterval` milliseconds and closes (emits and resets) the
   * buffer every `bufferTimeSpan` milliseconds. When the optional argument
   * `maxBufferSize` is specified, the buffer will be closed either after
   * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.
   *
   * @example <caption>Every second, emit an array of the recent click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferTime(1000);
   * buffered.subscribe(x => console.log(x));
   *
   * @example <caption>Every 5 seconds, emit the click events from the next 2 seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferTime(2000, 5000);
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferToggle}
   * @see {@link bufferWhen}
   * @see {@link windowTime}
   *
   * @param {number} bufferTimeSpan The amount of time to fill each buffer array.
   * @param {number} [bufferCreationInterval] The interval at which to start new
   * buffers.
   * @param {number} [maxBufferSize] The maximum buffer size.
   * @param {Scheduler} [scheduler=async] The scheduler on which to schedule the
   * intervals that determine buffer boundaries.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferTime
   * @owner Observable
   */function bufferTime(bufferTimeSpan){var length=arguments.length;var scheduler=async_1.async;if(isScheduler_1.isScheduler(arguments[arguments.length-1])){scheduler=arguments[arguments.length-1];length--;}var bufferCreationInterval=null;if(length>=2){bufferCreationInterval=arguments[1];}var maxBufferSize=Number.POSITIVE_INFINITY;if(length>=3){maxBufferSize=arguments[2];}return bufferTime_1.bufferTime(bufferTimeSpan,bufferCreationInterval,maxBufferSize,scheduler)(this);}exports.bufferTime=bufferTime;//# sourceMappingURL=bufferTime.js.map
  
  /***/ }),
  /* 239 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bufferToggle_1=__webpack_require__(240);Observable_1.Observable.prototype.bufferToggle=bufferToggle_1.bufferToggle;//# sourceMappingURL=bufferToggle.js.map
  
  /***/ }),
  /* 240 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var bufferToggle_1=__webpack_require__(75);/**
   * Buffers the source Observable values starting from an emission from
   * `openings` and ending when the output of `closingSelector` emits.
   *
   * <span class="informal">Collects values from the past as an array. Starts
   * collecting only when `opening` emits, and calls the `closingSelector`
   * function to get an Observable that tells when to close the buffer.</span>
   *
   * <img src="./img/bufferToggle.png" width="100%">
   *
   * Buffers values from the source by opening the buffer via signals from an
   * Observable provided to `openings`, and closing and sending the buffers when
   * a Subscribable or Promise returned by the `closingSelector` function emits.
   *
   * @example <caption>Every other second, emit the click events from the next 500ms</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var openings = Rx.Observable.interval(1000);
   * var buffered = clicks.bufferToggle(openings, i =>
   *   i % 2 ? Rx.Observable.interval(500) : Rx.Observable.empty()
   * );
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferWhen}
   * @see {@link windowToggle}
   *
   * @param {SubscribableOrPromise<O>} openings A Subscribable or Promise of notifications to start new
   * buffers.
   * @param {function(value: O): SubscribableOrPromise} closingSelector A function that takes
   * the value emitted by the `openings` observable and returns a Subscribable or Promise,
   * which, when it emits, signals that the associated buffer should be emitted
   * and cleared.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferToggle
   * @owner Observable
   */function bufferToggle(openings,closingSelector){return bufferToggle_1.bufferToggle(openings,closingSelector)(this);}exports.bufferToggle=bufferToggle;//# sourceMappingURL=bufferToggle.js.map
  
  /***/ }),
  /* 241 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var bufferWhen_1=__webpack_require__(242);Observable_1.Observable.prototype.bufferWhen=bufferWhen_1.bufferWhen;//# sourceMappingURL=bufferWhen.js.map
  
  /***/ }),
  /* 242 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var bufferWhen_1=__webpack_require__(76);/**
   * Buffers the source Observable values, using a factory function of closing
   * Observables to determine when to close, emit, and reset the buffer.
   *
   * <span class="informal">Collects values from the past as an array. When it
   * starts collecting values, it calls a function that returns an Observable that
   * tells when to close the buffer and restart collecting.</span>
   *
   * <img src="./img/bufferWhen.png" width="100%">
   *
   * Opens a buffer immediately, then closes the buffer when the observable
   * returned by calling `closingSelector` function emits a value. When it closes
   * the buffer, it immediately opens a new buffer and repeats the process.
   *
   * @example <caption>Emit an array of the last clicks every [1-5] random seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var buffered = clicks.bufferWhen(() =>
   *   Rx.Observable.interval(1000 + Math.random() * 4000)
   * );
   * buffered.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   * @see {@link bufferTime}
   * @see {@link bufferToggle}
   * @see {@link windowWhen}
   *
   * @param {function(): Observable} closingSelector A function that takes no
   * arguments and returns an Observable that signals buffer closure.
   * @return {Observable<T[]>} An observable of arrays of buffered values.
   * @method bufferWhen
   * @owner Observable
   */function bufferWhen(closingSelector){return bufferWhen_1.bufferWhen(closingSelector)(this);}exports.bufferWhen=bufferWhen;//# sourceMappingURL=bufferWhen.js.map
  
  /***/ }),
  /* 243 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var catch_1=__webpack_require__(244);Observable_1.Observable.prototype.catch=catch_1._catch;Observable_1.Observable.prototype._catch=catch_1._catch;//# sourceMappingURL=catch.js.map
  
  /***/ }),
  /* 244 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var catchError_1=__webpack_require__(77);/**
   * Catches errors on the observable to be handled by returning a new observable or throwing an error.
   *
   * <img src="./img/catch.png" width="100%">
   *
   * @example <caption>Continues with a different Observable when there's an error</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   * 	   if (n == 4) {
   * 	     throw 'four!';
   *     }
   *	   return n;
   *   })
   *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))
   *   .subscribe(x => console.log(x));
   *   // 1, 2, 3, I, II, III, IV, V
   *
   * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   * 	   if (n === 4) {
   * 	     throw 'four!';
   *     }
   * 	   return n;
   *   })
   *   .catch((err, caught) => caught)
   *   .take(30)
   *   .subscribe(x => console.log(x));
   *   // 1, 2, 3, 1, 2, 3, ...
   *
   * @example <caption>Throws a new error when the source Observable throws an error</caption>
   *
   * Observable.of(1, 2, 3, 4, 5)
   *   .map(n => {
   *     if (n == 4) {
   *       throw 'four!';
   *     }
   *     return n;
   *   })
   *   .catch(err => {
   *     throw 'error in source. Details: ' + err;
   *   })
   *   .subscribe(
   *     x => console.log(x),
   *     err => console.log(err)
   *   );
   *   // 1, 2, 3, error in source. Details: four!
   *
   * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which
   *  is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable
   *  is returned by the `selector` will be used to continue the observable chain.
   * @return {Observable} An observable that originates from either the source or the observable returned by the
   *  catch `selector` function.
   * @method catch
   * @name catch
   * @owner Observable
   */function _catch(selector){return catchError_1.catchError(selector)(this);}exports._catch=_catch;//# sourceMappingURL=catch.js.map
  
  /***/ }),
  /* 245 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var combineAll_1=__webpack_require__(246);Observable_1.Observable.prototype.combineAll=combineAll_1.combineAll;//# sourceMappingURL=combineAll.js.map
  
  /***/ }),
  /* 246 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var combineAll_1=__webpack_require__(78);/**
   * Converts a higher-order Observable into a first-order Observable by waiting
   * for the outer Observable to complete, then applying {@link combineLatest}.
   *
   * <span class="informal">Flattens an Observable-of-Observables by applying
   * {@link combineLatest} when the Observable-of-Observables completes.</span>
   *
   * <img src="./img/combineAll.png" width="100%">
   *
   * Takes an Observable of Observables, and collects all Observables from it.
   * Once the outer Observable completes, it subscribes to all collected
   * Observables and combines their values using the {@link combineLatest}
   * strategy, such that:
   * - Every time an inner Observable emits, the output Observable emits.
   * - When the returned observable emits, it emits all of the latest values by:
   *   - If a `project` function is provided, it is called with each recent value
   *     from each inner Observable in whatever order they arrived, and the result
   *     of the `project` function is what is emitted by the output Observable.
   *   - If there is no `project` function, an array of all of the most recent
   *     values is emitted by the output Observable.
   *
   * @example <caption>Map two click events to a finite interval Observable, then apply combineAll</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map(ev =>
   *   Rx.Observable.interval(Math.random()*2000).take(3)
   * ).take(2);
   * var result = higherOrder.combineAll();
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineLatest}
   * @see {@link mergeAll}
   *
   * @param {function} [project] An optional function to map the most recent
   * values from each inner Observable into a new result. Takes each of the most
   * recent values from each collected inner Observable as arguments, in order.
   * @return {Observable} An Observable of projected results or arrays of recent
   * values.
   * @method combineAll
   * @owner Observable
   */function combineAll(project){return combineAll_1.combineAll(project)(this);}exports.combineAll=combineAll;//# sourceMappingURL=combineAll.js.map
  
  /***/ }),
  /* 247 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var combineLatest_1=__webpack_require__(248);Observable_1.Observable.prototype.combineLatest=combineLatest_1.combineLatest;//# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 248 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var combineLatest_1=__webpack_require__(30);/* tslint:enable:max-line-length *//**
   * Combines multiple Observables to create an Observable whose values are
   * calculated from the latest values of each of its input Observables.
   *
   * <span class="informal">Whenever any input Observable emits a value, it
   * computes a formula using the latest values from all the inputs, then emits
   * the output of that formula.</span>
   *
   * <img src="./img/combineLatest.png" width="100%">
   *
   * `combineLatest` combines the values from this Observable with values from
   * Observables passed as arguments. This is done by subscribing to each
   * Observable, in order, and collecting an array of each of the most recent
   * values any time any of the input Observables emits, then either taking that
   * array and passing it as arguments to an optional `project` function and
   * emitting the return value of that, or just emitting the array of recent
   * values directly if there is no `project` function.
   *
   * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>
   * var weight = Rx.Observable.of(70, 72, 76, 79, 75);
   * var height = Rx.Observable.of(1.76, 1.77, 1.78);
   * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));
   * bmi.subscribe(x => console.log('BMI is ' + x));
   *
   * // With output to console:
   * // BMI is 24.212293388429753
   * // BMI is 23.93948099205209
   * // BMI is 23.671253629592222
   *
   * @see {@link combineAll}
   * @see {@link merge}
   * @see {@link withLatestFrom}
   *
   * @param {ObservableInput} other An input Observable to combine with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {function} [project] An optional function to project the values from
   * the combined latest values into a new value on the output Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @method combineLatest
   * @owner Observable
   */function combineLatest(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return combineLatest_1.combineLatest.apply(void 0,observables)(this);}exports.combineLatest=combineLatest;//# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 249 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var concat_1=__webpack_require__(250);Observable_1.Observable.prototype.concat=concat_1.concat;//# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 250 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concat_1=__webpack_require__(79);var concat_2=__webpack_require__(16);exports.concatStatic=concat_2.concat;/* tslint:enable:max-line-length *//**
   * Creates an output Observable which sequentially emits all values from every
   * given input Observable after the current Observable.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * Joins this Observable with multiple other Observables by subscribing to them
   * one at a time, starting with the source, and merging their results into the
   * output Observable. Will wait for each Observable to complete before moving
   * on to the next.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = timer.concat(sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   * @example <caption>Concatenate 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = timer1.concat(timer2, timer3);
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} other An input Observable to concatenate after the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @method concat
   * @owner Observable
   */function concat(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return concat_1.concat.apply(void 0,observables)(this);}exports.concat=concat;//# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 251 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var concatAll_1=__webpack_require__(252);Observable_1.Observable.prototype.concatAll=concatAll_1.concatAll;//# sourceMappingURL=concatAll.js.map
  
  /***/ }),
  /* 252 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concatAll_1=__webpack_require__(43);/* tslint:enable:max-line-length *//**
   * Converts a higher-order Observable into a first-order Observable by
   * concatenating the inner Observables in order.
   *
   * <span class="informal">Flattens an Observable-of-Observables by putting one
   * inner Observable after the other.</span>
   *
   * <img src="./img/concatAll.png" width="100%">
   *
   * Joins every Observable emitted by the source (a higher-order Observable), in
   * a serial fashion. It subscribes to each inner Observable only after the
   * previous inner Observable has completed, and merges all of their values into
   * the returned observable.
   *
   * __Warning:__ If the source Observable emits Observables quickly and
   * endlessly, and the inner Observables it emits generally complete slower than
   * the source emits, you can run into memory issues as the incoming Observables
   * collect in an unbounded buffer.
   *
   * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set
   * to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));
   * var firstOrder = higherOrder.concatAll();
   * firstOrder.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link combineAll}
   * @see {@link concat}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   * @see {@link exhaust}
   * @see {@link mergeAll}
   * @see {@link switch}
   * @see {@link zipAll}
   *
   * @return {Observable} An Observable emitting values from all the inner
   * Observables concatenated.
   * @method concatAll
   * @owner Observable
   */function concatAll(){return concatAll_1.concatAll()(this);}exports.concatAll=concatAll;//# sourceMappingURL=concatAll.js.map
  
  /***/ }),
  /* 253 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var concatMap_1=__webpack_require__(254);Observable_1.Observable.prototype.concatMap=concatMap_1.concatMap;//# sourceMappingURL=concatMap.js.map
  
  /***/ }),
  /* 254 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concatMap_1=__webpack_require__(46);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable, in a serialized fashion waiting for each one to complete before
   * merging the next.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link concatAll}.</span>
   *
   * <img src="./img/concatMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. Each new inner Observable is
   * concatenated with the previous inner Observable.
   *
   * __Warning:__ if source values arrive endlessly and faster than their
   * corresponding inner Observables can complete, it will result in memory issues
   * as inner Observables amass in an unbounded buffer waiting for their turn to
   * be subscribed to.
   *
   * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set
   * to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link concat}
   * @see {@link concatAll}
   * @see {@link concatMapTo}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking values from each projected inner
   * Observable sequentially.
   * @method concatMap
   * @owner Observable
   */function concatMap(project,resultSelector){return concatMap_1.concatMap(project,resultSelector)(this);}exports.concatMap=concatMap;//# sourceMappingURL=concatMap.js.map
  
  /***/ }),
  /* 255 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var concatMapTo_1=__webpack_require__(256);Observable_1.Observable.prototype.concatMapTo=concatMapTo_1.concatMapTo;//# sourceMappingURL=concatMapTo.js.map
  
  /***/ }),
  /* 256 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var concatMapTo_1=__webpack_require__(80);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is merged multiple
   * times in a serialized fashion on the output Observable.
   *
   * <span class="informal">It's like {@link concatMap}, but maps each value
   * always to the same inner Observable.</span>
   *
   * <img src="./img/concatMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then flattens those resulting Observables into one
   * single Observable, which is the output Observable. Each new `innerObservable`
   * instance emitted on the output Observable is concatenated with the previous
   * `innerObservable` instance.
   *
   * __Warning:__ if source values arrive endlessly and faster than their
   * corresponding inner Observables can complete, it will result in memory issues
   * as inner Observables amass in an unbounded buffer waiting for their turn to
   * be subscribed to.
   *
   * Note: `concatMapTo` is equivalent to `mergeMapTo` with concurrency parameter
   * set to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.concatMapTo(Rx.Observable.interval(1000).take(4));
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link concat}
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link mergeMapTo}
   * @see {@link switchMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An observable of values merged together by joining the
   * passed observable with itself, one after the other, for each value emitted
   * from the source.
   * @method concatMapTo
   * @owner Observable
   */function concatMapTo(innerObservable,resultSelector){return concatMapTo_1.concatMapTo(innerObservable,resultSelector)(this);}exports.concatMapTo=concatMapTo;//# sourceMappingURL=concatMapTo.js.map
  
  /***/ }),
  /* 257 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var count_1=__webpack_require__(258);Observable_1.Observable.prototype.count=count_1.count;//# sourceMappingURL=count.js.map
  
  /***/ }),
  /* 258 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var count_1=__webpack_require__(81);/**
   * Counts the number of emissions on the source and emits that number when the
   * source completes.
   *
   * <span class="informal">Tells how many values were emitted, when the source
   * completes.</span>
   *
   * <img src="./img/count.png" width="100%">
   *
   * `count` transforms an Observable that emits values into an Observable that
   * emits a single value that represents the number of values emitted by the
   * source Observable. If the source Observable terminates with an error, `count`
   * will pass this error notification along without emitting a value first. If
   * the source Observable does not terminate at all, `count` will neither emit
   * a value nor terminate. This operator takes an optional `predicate` function
   * as argument, in which case the output emission will represent the number of
   * source values that matched `true` with the `predicate`.
   *
   * @example <caption>Counts how many seconds have passed before the first click happened</caption>
   * var seconds = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var secondsBeforeClick = seconds.takeUntil(clicks);
   * var result = secondsBeforeClick.count();
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>
   * var numbers = Rx.Observable.range(1, 7);
   * var result = numbers.count(i => i % 2 === 1);
   * result.subscribe(x => console.log(x));
   *
   * // Results in:
   * // 4
   *
   * @see {@link max}
   * @see {@link min}
   * @see {@link reduce}
   *
   * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A
   * boolean function to select what values are to be counted. It is provided with
   * arguments of:
   * - `value`: the value from the source Observable.
   * - `index`: the (zero-based) "index" of the value from the source Observable.
   * - `source`: the source Observable instance itself.
   * @return {Observable} An Observable of one number that represents the count as
   * described above.
   * @method count
   * @owner Observable
   */function count(predicate){return count_1.count(predicate)(this);}exports.count=count;//# sourceMappingURL=count.js.map
  
  /***/ }),
  /* 259 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var dematerialize_1=__webpack_require__(260);Observable_1.Observable.prototype.dematerialize=dematerialize_1.dematerialize;//# sourceMappingURL=dematerialize.js.map
  
  /***/ }),
  /* 260 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var dematerialize_1=__webpack_require__(82);/**
   * Converts an Observable of {@link Notification} objects into the emissions
   * that they represent.
   *
   * <span class="informal">Unwraps {@link Notification} objects as actual `next`,
   * `error` and `complete` emissions. The opposite of {@link materialize}.</span>
   *
   * <img src="./img/dematerialize.png" width="100%">
   *
   * `dematerialize` is assumed to operate an Observable that only emits
   * {@link Notification} objects as `next` emissions, and does not emit any
   * `error`. Such Observable is the output of a `materialize` operation. Those
   * notifications are then unwrapped using the metadata they contain, and emitted
   * as `next`, `error`, and `complete` on the output Observable.
   *
   * Use this operator in conjunction with {@link materialize}.
   *
   * @example <caption>Convert an Observable of Notifications to an actual Observable</caption>
   * var notifA = new Rx.Notification('N', 'A');
   * var notifB = new Rx.Notification('N', 'B');
   * var notifE = new Rx.Notification('E', void 0,
   *   new TypeError('x.toUpperCase is not a function')
   * );
   * var materialized = Rx.Observable.of(notifA, notifB, notifE);
   * var upperCase = materialized.dematerialize();
   * upperCase.subscribe(x => console.log(x), e => console.error(e));
   *
   * // Results in:
   * // A
   * // B
   * // TypeError: x.toUpperCase is not a function
   *
   * @see {@link Notification}
   * @see {@link materialize}
   *
   * @return {Observable} An Observable that emits items and notifications
   * embedded in Notification objects emitted by the source Observable.
   * @method dematerialize
   * @owner Observable
   */function dematerialize(){return dematerialize_1.dematerialize()(this);}exports.dematerialize=dematerialize;//# sourceMappingURL=dematerialize.js.map
  
  /***/ }),
  /* 261 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var debounce_1=__webpack_require__(262);Observable_1.Observable.prototype.debounce=debounce_1.debounce;//# sourceMappingURL=debounce.js.map
  
  /***/ }),
  /* 262 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var debounce_1=__webpack_require__(83);/**
   * Emits a value from the source Observable only after a particular time span
   * determined by another Observable has passed without another source emission.
   *
   * <span class="informal">It's like {@link debounceTime}, but the time span of
   * emission silence is determined by a second Observable.</span>
   *
   * <img src="./img/debounce.png" width="100%">
   *
   * `debounce` delays values emitted by the source Observable, but drops previous
   * pending delayed emissions if a new value arrives on the source Observable.
   * This operator keeps track of the most recent value from the source
   * Observable, and spawns a duration Observable by calling the
   * `durationSelector` function. The value is emitted only when the duration
   * Observable emits a value or completes, and if no other value was emitted on
   * the source Observable since the duration Observable was spawned. If a new
   * value appears before the duration Observable emits, the previous value will
   * be dropped and will not be emitted on the output Observable.
   *
   * Like {@link debounceTime}, this is a rate-limiting operator, and also a
   * delay-like operator since output emissions do not necessarily occur at the
   * same time as they did on the source Observable.
   *
   * @example <caption>Emit the most recent click after a burst of clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.debounce(() => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounceTime}
   * @see {@link delayWhen}
   * @see {@link throttle}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the timeout
   * duration for each source value, returned as an Observable or a Promise.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified duration Observable returned by
   * `durationSelector`, and may drop some values if they occur too frequently.
   * @method debounce
   * @owner Observable
   */function debounce(durationSelector){return debounce_1.debounce(durationSelector)(this);}exports.debounce=debounce;//# sourceMappingURL=debounce.js.map
  
  /***/ }),
  /* 263 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var debounceTime_1=__webpack_require__(264);Observable_1.Observable.prototype.debounceTime=debounceTime_1.debounceTime;//# sourceMappingURL=debounceTime.js.map
  
  /***/ }),
  /* 264 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var debounceTime_1=__webpack_require__(84);/**
   * Emits a value from the source Observable only after a particular time span
   * has passed without another source emission.
   *
   * <span class="informal">It's like {@link delay}, but passes only the most
   * recent value from each burst of emissions.</span>
   *
   * <img src="./img/debounceTime.png" width="100%">
   *
   * `debounceTime` delays values emitted by the source Observable, but drops
   * previous pending delayed emissions if a new value arrives on the source
   * Observable. This operator keeps track of the most recent value from the
   * source Observable, and emits that only when `dueTime` enough time has passed
   * without any other value appearing on the source Observable. If a new value
   * appears before `dueTime` silence occurs, the previous value will be dropped
   * and will not be emitted on the output Observable.
   *
   * This is a rate-limiting operator, because it is impossible for more than one
   * value to be emitted in any time window of duration `dueTime`, but it is also
   * a delay-like operator since output emissions do not occur at the same time as
   * they did on the source Observable. Optionally takes a {@link IScheduler} for
   * managing timers.
   *
   * @example <caption>Emit the most recent click after a burst of clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.debounceTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounce}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttleTime}
   *
   * @param {number} dueTime The timeout duration in milliseconds (or the time
   * unit determined internally by the optional `scheduler`) for the window of
   * time required to wait for emission silence before emitting the most recent
   * source value.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the timeout for each value.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified `dueTime`, and may drop some values if they occur
   * too frequently.
   * @method debounceTime
   * @owner Observable
   */function debounceTime(dueTime,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return debounceTime_1.debounceTime(dueTime,scheduler)(this);}exports.debounceTime=debounceTime;//# sourceMappingURL=debounceTime.js.map
  
  /***/ }),
  /* 265 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var defaultIfEmpty_1=__webpack_require__(266);Observable_1.Observable.prototype.defaultIfEmpty=defaultIfEmpty_1.defaultIfEmpty;//# sourceMappingURL=defaultIfEmpty.js.map
  
  /***/ }),
  /* 266 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var defaultIfEmpty_1=__webpack_require__(47);/* tslint:enable:max-line-length *//**
   * Emits a given value if the source Observable completes without emitting any
   * `next` value, otherwise mirrors the source Observable.
   *
   * <span class="informal">If the source Observable turns out to be empty, then
   * this operator will emit a default value.</span>
   *
   * <img src="./img/defaultIfEmpty.png" width="100%">
   *
   * `defaultIfEmpty` emits the values emitted by the source Observable or a
   * specified default value if the source Observable is empty (completes without
   * having emitted any `next` value).
   *
   * @example <caption>If no clicks happen in 5 seconds, then emit "no clicks"</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var clicksBeforeFive = clicks.takeUntil(Rx.Observable.interval(5000));
   * var result = clicksBeforeFive.defaultIfEmpty('no clicks');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link empty}
   * @see {@link last}
   *
   * @param {any} [defaultValue=null] The default value used if the source
   * Observable is empty.
   * @return {Observable} An Observable that emits either the specified
   * `defaultValue` if the source Observable emits no items, or the values emitted
   * by the source Observable.
   * @method defaultIfEmpty
   * @owner Observable
   */function defaultIfEmpty(defaultValue){if(defaultValue===void 0){defaultValue=null;}return defaultIfEmpty_1.defaultIfEmpty(defaultValue)(this);}exports.defaultIfEmpty=defaultIfEmpty;//# sourceMappingURL=defaultIfEmpty.js.map
  
  /***/ }),
  /* 267 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var delay_1=__webpack_require__(268);Observable_1.Observable.prototype.delay=delay_1.delay;//# sourceMappingURL=delay.js.map
  
  /***/ }),
  /* 268 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var delay_1=__webpack_require__(85);/**
   * Delays the emission of items from the source Observable by a given timeout or
   * until a given Date.
   *
   * <span class="informal">Time shifts each item by some specified amount of
   * milliseconds.</span>
   *
   * <img src="./img/delay.png" width="100%">
   *
   * If the delay argument is a Number, this operator time shifts the source
   * Observable by that amount of time expressed in milliseconds. The relative
   * time intervals between the values are preserved.
   *
   * If the delay argument is a Date, this operator time shifts the start of the
   * Observable execution until the given date occurs.
   *
   * @example <caption>Delay each click by one second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @example <caption>Delay all clicks until a future date happens</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var date = new Date('March 15, 2050 12:00:00'); // in the future
   * var delayedClicks = clicks.delay(date); // click emitted only after that date
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @see {@link debounceTime}
   * @see {@link delayWhen}
   *
   * @param {number|Date} delay The delay duration in milliseconds (a `number`) or
   * a `Date` until which the emission of the source items is delayed.
   * @param {Scheduler} [scheduler=async] The IScheduler to use for
   * managing the timers that handle the time-shift for each item.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by the specified timeout or Date.
   * @method delay
   * @owner Observable
   */function delay(delay,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return delay_1.delay(delay,scheduler)(this);}exports.delay=delay;//# sourceMappingURL=delay.js.map
  
  /***/ }),
  /* 269 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var delayWhen_1=__webpack_require__(270);Observable_1.Observable.prototype.delayWhen=delayWhen_1.delayWhen;//# sourceMappingURL=delayWhen.js.map
  
  /***/ }),
  /* 270 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var delayWhen_1=__webpack_require__(86);/**
   * Delays the emission of items from the source Observable by a given time span
   * determined by the emissions of another Observable.
   *
   * <span class="informal">It's like {@link delay}, but the time span of the
   * delay duration is determined by a second Observable.</span>
   *
   * <img src="./img/delayWhen.png" width="100%">
   *
   * `delayWhen` time shifts each emitted value from the source Observable by a
   * time span determined by another Observable. When the source emits a value,
   * the `delayDurationSelector` function is called with the source value as
   * argument, and should return an Observable, called the "duration" Observable.
   * The source value is emitted on the output Observable only when the duration
   * Observable emits a value or completes.
   *
   * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which
   * is an Observable. When `subscriptionDelay` emits its first value or
   * completes, the source Observable is subscribed to and starts behaving like
   * described in the previous paragraph. If `subscriptionDelay` is not provided,
   * `delayWhen` will subscribe to the source Observable as soon as the output
   * Observable is subscribed.
   *
   * @example <caption>Delay each click by a random amount of time, between 0 and 5 seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var delayedClicks = clicks.delayWhen(event =>
   *   Rx.Observable.interval(Math.random() * 5000)
   * );
   * delayedClicks.subscribe(x => console.log(x));
   *
   * @see {@link debounce}
   * @see {@link delay}
   *
   * @param {function(value: T): Observable} delayDurationSelector A function that
   * returns an Observable for each value emitted by the source Observable, which
   * is then used to delay the emission of that item on the output Observable
   * until the Observable returned from this function emits a value.
   * @param {Observable} subscriptionDelay An Observable that triggers the
   * subscription to the source Observable once it emits any value.
   * @return {Observable} An Observable that delays the emissions of the source
   * Observable by an amount of time specified by the Observable returned by
   * `delayDurationSelector`.
   * @method delayWhen
   * @owner Observable
   */function delayWhen(delayDurationSelector,subscriptionDelay){return delayWhen_1.delayWhen(delayDurationSelector,subscriptionDelay)(this);}exports.delayWhen=delayWhen;//# sourceMappingURL=delayWhen.js.map
  
  /***/ }),
  /* 271 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var distinct_1=__webpack_require__(272);Observable_1.Observable.prototype.distinct=distinct_1.distinct;//# sourceMappingURL=distinct.js.map
  
  /***/ }),
  /* 272 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var distinct_1=__webpack_require__(87);/**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
   *
   * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
   * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
   * source observable directly with an equality check against previous values.
   *
   * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
   *
   * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
   * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
   * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
   * that the internal `Set` can be "flushed", basically clearing it of values.
   *
   * @example <caption>A simple example with numbers</caption>
   * Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
   *   .distinct()
   *   .subscribe(x => console.log(x)); // 1, 2, 3, 4
   *
   * @example <caption>An example using a keySelector function</caption>
   * interface Person {
   *    age: number,
   *    name: string
   * }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'})
   *     .distinct((p: Person) => p.name)
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   *
   * @see {@link distinctUntilChanged}
   * @see {@link distinctUntilKeyChanged}
   *
   * @param {function} [keySelector] Optional function to select which value you want to check as distinct.
   * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values.
   * @method distinct
   * @owner Observable
   */function distinct(keySelector,flushes){return distinct_1.distinct(keySelector,flushes)(this);}exports.distinct=distinct;//# sourceMappingURL=distinct.js.map
  
  /***/ }),
  /* 273 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);function minimalSetImpl(){// THIS IS NOT a full impl of Set, this is just the minimum
  // bits of functionality we need for this library.
  return function(){function MinimalSet(){this._values=[];}MinimalSet.prototype.add=function(value){if(!this.has(value)){this._values.push(value);}};MinimalSet.prototype.has=function(value){return this._values.indexOf(value)!==-1;};Object.defineProperty(MinimalSet.prototype,"size",{get:function get(){return this._values.length;},enumerable:true,configurable:true});MinimalSet.prototype.clear=function(){this._values.length=0;};return MinimalSet;}();}exports.minimalSetImpl=minimalSetImpl;exports.Set=root_1.root.Set||minimalSetImpl();//# sourceMappingURL=Set.js.map
  
  /***/ }),
  /* 274 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var distinctUntilChanged_1=__webpack_require__(275);Observable_1.Observable.prototype.distinctUntilChanged=distinctUntilChanged_1.distinctUntilChanged;//# sourceMappingURL=distinctUntilChanged.js.map
  
  /***/ }),
  /* 275 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var distinctUntilChanged_1=__webpack_require__(48);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.
   *
   * 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.
   *
   * If a comparator function is not provided, an equality check is used by default.
   *
   * @example <caption>A simple example with numbers</caption>
   * Observable.of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4)
   *   .distinctUntilChanged()
   *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4
   *
   * @example <caption>An example using a compare function</caption>
   * interface Person {
   *    age: number,
   *    name: string
   * }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'})
   *     { age: 6, name: 'Foo'})
   *     .distinctUntilChanged((p: Person, q: Person) => p.name === q.name)
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo' }
   *
   * @see {@link distinct}
   * @see {@link distinctUntilKeyChanged}
   *
   * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values.
   * @method distinctUntilChanged
   * @owner Observable
   */function distinctUntilChanged(compare,keySelector){return distinctUntilChanged_1.distinctUntilChanged(compare,keySelector)(this);}exports.distinctUntilChanged=distinctUntilChanged;//# sourceMappingURL=distinctUntilChanged.js.map
  
  /***/ }),
  /* 276 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var distinctUntilKeyChanged_1=__webpack_require__(277);Observable_1.Observable.prototype.distinctUntilKeyChanged=distinctUntilKeyChanged_1.distinctUntilKeyChanged;//# sourceMappingURL=distinctUntilKeyChanged.js.map
  
  /***/ }),
  /* 277 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var distinctUntilKeyChanged_1=__webpack_require__(88);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item,
   * using a property accessed by using the key provided to check if the two items are distinct.
   *
   * 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.
   *
   * If a comparator function is not provided, an equality check is used by default.
   *
   * @example <caption>An example comparing the name of persons</caption>
   *
   *  interface Person {
   *     age: number,
   *     name: string
   *  }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'},
   *     { age: 6, name: 'Foo'})
   *     .distinctUntilKeyChanged('name')
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo' }
   *
   * @example <caption>An example comparing the first letters of the name</caption>
   *
   * interface Person {
   *     age: number,
   *     name: string
   *  }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo1'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo2'},
   *     { age: 6, name: 'Foo3'})
   *     .distinctUntilKeyChanged('name', (x: string, y: string) => x.substring(0, 3) === y.substring(0, 3))
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo1' }
   * // { age: 7, name: 'Bar' }
   * // { age: 5, name: 'Foo2' }
   *
   * @see {@link distinct}
   * @see {@link distinctUntilChanged}
   *
   * @param {string} key String key for object property lookup on each item.
   * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values based on the key specified.
   * @method distinctUntilKeyChanged
   * @owner Observable
   */function distinctUntilKeyChanged(key,compare){return distinctUntilKeyChanged_1.distinctUntilKeyChanged(key,compare)(this);}exports.distinctUntilKeyChanged=distinctUntilKeyChanged;//# sourceMappingURL=distinctUntilKeyChanged.js.map
  
  /***/ }),
  /* 278 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var do_1=__webpack_require__(279);Observable_1.Observable.prototype.do=do_1._do;Observable_1.Observable.prototype._do=do_1._do;//# sourceMappingURL=do.js.map
  
  /***/ }),
  /* 279 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var tap_1=__webpack_require__(89);/* tslint:enable:max-line-length *//**
   * Perform a side effect for every emission on the source Observable, but return
   * an Observable that is identical to the source.
   *
   * <span class="informal">Intercepts each emission on the source and runs a
   * function, but returns an output which is identical to the source as long as errors don't occur.</span>
   *
   * <img src="./img/do.png" width="100%">
   *
   * Returns a mirrored Observable of the source Observable, but modified so that
   * the provided Observer is called to perform a side effect for every value,
   * error, and completion emitted by the source. Any errors that are thrown in
   * the aforementioned Observer or handlers are safely sent down the error path
   * of the output Observable.
   *
   * This operator is useful for debugging your Observables for the correct values
   * or performing other side effects.
   *
   * Note: this is different to a `subscribe` on the Observable. If the Observable
   * returned by `do` is not subscribed, the side effects specified by the
   * Observer will never happen. `do` therefore simply spies on existing
   * execution, it does not trigger an execution to happen like `subscribe` does.
   *
   * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var positions = clicks
   *   .do(ev => console.log(ev))
   *   .map(ev => ev.clientX);
   * positions.subscribe(x => console.log(x));
   *
   * @see {@link map}
   * @see {@link subscribe}
   *
   * @param {Observer|function} [nextOrObserver] A normal Observer object or a
   * callback for `next`.
   * @param {function} [error] Callback for errors in the source.
   * @param {function} [complete] Callback for the completion of the source.
   * @return {Observable} An Observable identical to the source, but runs the
   * specified Observer or callback(s) for each item.
   * @method do
   * @name do
   * @owner Observable
   */function _do(nextOrObserver,error,complete){return tap_1.tap(nextOrObserver,error,complete)(this);}exports._do=_do;//# sourceMappingURL=do.js.map
  
  /***/ }),
  /* 280 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var exhaust_1=__webpack_require__(281);Observable_1.Observable.prototype.exhaust=exhaust_1.exhaust;//# sourceMappingURL=exhaust.js.map
  
  /***/ }),
  /* 281 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var exhaust_1=__webpack_require__(90);/**
   * Converts a higher-order Observable into a first-order Observable by dropping
   * inner Observables while the previous inner Observable has not yet completed.
   *
   * <span class="informal">Flattens an Observable-of-Observables by dropping the
   * next inner Observables while the current inner is still executing.</span>
   *
   * <img src="./img/exhaust.png" width="100%">
   *
   * `exhaust` subscribes to an Observable that emits Observables, also known as a
   * higher-order Observable. Each time it observes one of these emitted inner
   * Observables, the output Observable begins emitting the items emitted by that
   * inner Observable. So far, it behaves like {@link mergeAll}. However,
   * `exhaust` ignores every new inner Observable if the previous Observable has
   * not yet completed. Once that one completes, it will accept and flatten the
   * next inner Observable and repeat this process.
   *
   * @example <caption>Run a finite timer for each click, only if there is no currently active timer</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(5));
   * var result = higherOrder.exhaust();
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineAll}
   * @see {@link concatAll}
   * @see {@link switch}
   * @see {@link mergeAll}
   * @see {@link exhaustMap}
   * @see {@link zipAll}
   *
   * @return {Observable} An Observable that takes a source of Observables and propagates the first observable
   * exclusively until it completes before subscribing to the next.
   * @method exhaust
   * @owner Observable
   */function exhaust(){return exhaust_1.exhaust()(this);}exports.exhaust=exhaust;//# sourceMappingURL=exhaust.js.map
  
  /***/ }),
  /* 282 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var exhaustMap_1=__webpack_require__(283);Observable_1.Observable.prototype.exhaustMap=exhaustMap_1.exhaustMap;//# sourceMappingURL=exhaustMap.js.map
  
  /***/ }),
  /* 283 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var exhaustMap_1=__webpack_require__(91);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable only if the previous projected Observable has completed.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link exhaust}.</span>
   *
   * <img src="./img/exhaustMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. When it projects a source value to
   * an Observable, the output Observable begins emitting the items emitted by
   * that projected Observable. However, `exhaustMap` ignores every new projected
   * Observable if the previous projected Observable has not yet completed. Once
   * that one completes, it will accept and flatten the next projected Observable
   * and repeat this process.
   *
   * @example <caption>Run a finite timer for each click, only if there is no currently active timer</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.exhaustMap((ev) => Rx.Observable.interval(1000).take(5));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaust}
   * @see {@link mergeMap}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable containing projected Observables
   * of each item of the source, ignoring projected Observables that start before
   * their preceding Observable has completed.
   * @method exhaustMap
   * @owner Observable
   */function exhaustMap(project,resultSelector){return exhaustMap_1.exhaustMap(project,resultSelector)(this);}exports.exhaustMap=exhaustMap;//# sourceMappingURL=exhaustMap.js.map
  
  /***/ }),
  /* 284 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var expand_1=__webpack_require__(285);Observable_1.Observable.prototype.expand=expand_1.expand;//# sourceMappingURL=expand.js.map
  
  /***/ }),
  /* 285 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var expand_1=__webpack_require__(92);/* tslint:enable:max-line-length *//**
   * Recursively projects each source value to an Observable which is merged in
   * the output Observable.
   *
   * <span class="informal">It's similar to {@link mergeMap}, but applies the
   * projection function to every source value as well as every output value.
   * It's recursive.</span>
   *
   * <img src="./img/expand.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an Observable, and then merging those resulting Observables and
   * emitting the results of this merger. *Expand* will re-emit on the output
   * Observable every source value. Then, each output value is given to the
   * `project` function which returns an inner Observable to be merged on the
   * output Observable. Those output values resulting from the projection are also
   * given to the `project` function to produce new output values. This is how
   * *expand* behaves recursively.
   *
   * @example <caption>Start emitting the powers of two on every click, at most 10 of them</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var powersOfTwo = clicks
   *   .mapTo(1)
   *   .expand(x => Rx.Observable.of(2 * x).delay(1000))
   *   .take(10);
   * powersOfTwo.subscribe(x => console.log(x));
   *
   * @see {@link mergeMap}
   * @see {@link mergeScan}
   *
   * @param {function(value: T, index: number) => Observable} project A function
   * that, when applied to an item emitted by the source or the output Observable,
   * returns an Observable.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for subscribing to
   * each projected inner Observable.
   * @return {Observable} An Observable that emits the source values and also
   * result of applying the projection function to each value emitted on the
   * output Observable and and merging the results of the Observables obtained
   * from this transformation.
   * @method expand
   * @owner Observable
   */function expand(project,concurrent,scheduler){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}if(scheduler===void 0){scheduler=undefined;}concurrent=(concurrent||0)<1?Number.POSITIVE_INFINITY:concurrent;return expand_1.expand(project,concurrent,scheduler)(this);}exports.expand=expand;//# sourceMappingURL=expand.js.map
  
  /***/ }),
  /* 286 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var elementAt_1=__webpack_require__(287);Observable_1.Observable.prototype.elementAt=elementAt_1.elementAt;//# sourceMappingURL=elementAt.js.map
  
  /***/ }),
  /* 287 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var elementAt_1=__webpack_require__(93);/**
   * Emits the single value at the specified `index` in a sequence of emissions
   * from the source Observable.
   *
   * <span class="informal">Emits only the i-th value, then completes.</span>
   *
   * <img src="./img/elementAt.png" width="100%">
   *
   * `elementAt` returns an Observable that emits the item at the specified
   * `index` in the source Observable, or a default value if that `index` is out
   * of range and the `default` argument is provided. If the `default` argument is
   * not given and the `index` is out of range, the output Observable will emit an
   * `ArgumentOutOfRangeError` error.
   *
   * @example <caption>Emit only the third click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.elementAt(2);
   * result.subscribe(x => console.log(x));
   *
   * // Results in:
   * // click 1 = nothing
   * // click 2 = nothing
   * // click 3 = MouseEvent object logged to console
   *
   * @see {@link first}
   * @see {@link last}
   * @see {@link skip}
   * @see {@link single}
   * @see {@link take}
   *
   * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0` or the
   * Observable has completed before emitting the i-th `next` notification.
   *
   * @param {number} index Is the number `i` for the i-th source emission that has
   * happened since the subscription, starting from the number `0`.
   * @param {T} [defaultValue] The default value returned for missing indices.
   * @return {Observable} An Observable that emits a single item, if it is found.
   * Otherwise, will emit the default value if given. If not, then emits an error.
   * @method elementAt
   * @owner Observable
   */function elementAt(index,defaultValue){return elementAt_1.elementAt(index,defaultValue)(this);}exports.elementAt=elementAt;//# sourceMappingURL=elementAt.js.map
  
  /***/ }),
  /* 288 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var filter_1=__webpack_require__(289);Observable_1.Observable.prototype.filter=filter_1.filter;//# sourceMappingURL=filter.js.map
  
  /***/ }),
  /* 289 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var filter_1=__webpack_require__(49);/* tslint:enable:max-line-length *//**
   * Filter items emitted by the source Observable by only emitting those that
   * satisfy a specified predicate.
   *
   * <span class="informal">Like
   * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
   * it only emits a value from the source if it passes a criterion function.</span>
   *
   * <img src="./img/filter.png" width="100%">
   *
   * Similar to the well-known `Array.prototype.filter` method, this operator
   * takes values from the source Observable, passes them through a `predicate`
   * function and only emits those values that yielded `true`.
   *
   * @example <caption>Emit only click events whose target was a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');
   * clicksOnDivs.subscribe(x => console.log(x));
   *
   * @see {@link distinct}
   * @see {@link distinctUntilChanged}
   * @see {@link distinctUntilKeyChanged}
   * @see {@link ignoreElements}
   * @see {@link partition}
   * @see {@link skip}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates each value emitted by the source Observable. If it returns `true`,
   * the value is emitted, if `false` the value is not passed to the output
   * Observable. The `index` parameter is the number `i` for the i-th source
   * emission that has happened since the subscription, starting from the number
   * `0`.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable} An Observable of values from the source that were
   * allowed by the `predicate` function.
   * @method filter
   * @owner Observable
   */function filter(predicate,thisArg){return filter_1.filter(predicate,thisArg)(this);}exports.filter=filter;//# sourceMappingURL=filter.js.map
  
  /***/ }),
  /* 290 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var finally_1=__webpack_require__(291);Observable_1.Observable.prototype.finally=finally_1._finally;Observable_1.Observable.prototype._finally=finally_1._finally;//# sourceMappingURL=finally.js.map
  
  /***/ }),
  /* 291 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var finalize_1=__webpack_require__(94);/**
   * Returns an Observable that mirrors the source Observable, but will call a specified function when
   * the source terminates on complete or error.
   * @param {function} callback Function to be called when source terminates.
   * @return {Observable} An Observable that mirrors the source, but will call the specified function on termination.
   * @method finally
   * @owner Observable
   */function _finally(callback){return finalize_1.finalize(callback)(this);}exports._finally=_finally;//# sourceMappingURL=finally.js.map
  
  /***/ }),
  /* 292 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var find_1=__webpack_require__(293);Observable_1.Observable.prototype.find=find_1.find;//# sourceMappingURL=find.js.map
  
  /***/ }),
  /* 293 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var find_1=__webpack_require__(50);/* tslint:enable:max-line-length *//**
   * Emits only the first value emitted by the source Observable that meets some
   * condition.
   *
   * <span class="informal">Finds the first value that passes some test and emits
   * that.</span>
   *
   * <img src="./img/find.png" width="100%">
   *
   * `find` searches for the first item in the source Observable that matches the
   * specified condition embodied by the `predicate`, and returns the first
   * occurrence in the source. Unlike {@link first}, the `predicate` is required
   * in `find`, and does not emit an error if a valid value is not found.
   *
   * @example <caption>Find and emit the first click that happens on a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.find(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link first}
   * @see {@link findIndex}
   * @see {@link take}
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
   * A function called with each item to test for condition matching.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable<T>} An Observable of the first item that matches the
   * condition.
   * @method find
   * @owner Observable
   */function find(predicate,thisArg){return find_1.find(predicate,thisArg)(this);}exports.find=find;//# sourceMappingURL=find.js.map
  
  /***/ }),
  /* 294 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var findIndex_1=__webpack_require__(295);Observable_1.Observable.prototype.findIndex=findIndex_1.findIndex;//# sourceMappingURL=findIndex.js.map
  
  /***/ }),
  /* 295 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var findIndex_1=__webpack_require__(95);/**
   * Emits only the index of the first value emitted by the source Observable that
   * meets some condition.
   *
   * <span class="informal">It's like {@link find}, but emits the index of the
   * found value, not the value itself.</span>
   *
   * <img src="./img/findIndex.png" width="100%">
   *
   * `findIndex` searches for the first item in the source Observable that matches
   * the specified condition embodied by the `predicate`, and returns the
   * (zero-based) index of the first occurrence in the source. Unlike
   * {@link first}, the `predicate` is required in `findIndex`, and does not emit
   * an error if a valid value is not found.
   *
   * @example <caption>Emit the index of first click that happens on a DIV element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.findIndex(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link find}
   * @see {@link first}
   * @see {@link take}
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
   * A function called with each item to test for condition matching.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {Observable} An Observable of the index of the first item that
   * matches the condition.
   * @method find
   * @owner Observable
   */function findIndex(predicate,thisArg){return findIndex_1.findIndex(predicate,thisArg)(this);}exports.findIndex=findIndex;//# sourceMappingURL=findIndex.js.map
  
  /***/ }),
  /* 296 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var first_1=__webpack_require__(297);Observable_1.Observable.prototype.first=first_1.first;//# sourceMappingURL=first.js.map
  
  /***/ }),
  /* 297 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var first_1=__webpack_require__(96);/**
   * Emits only the first value (or the first value that meets some condition)
   * emitted by the source Observable.
   *
   * <span class="informal">Emits only the first value. Or emits only the first
   * value that passes some test.</span>
   *
   * <img src="./img/first.png" width="100%">
   *
   * If called with no arguments, `first` emits the first value of the source
   * Observable, then completes. If called with a `predicate` function, `first`
   * emits the first value of the source that matches the specified condition. It
   * may also take a `resultSelector` function to produce the output value from
   * the input value, and a `defaultValue` to emit in case the source completes
   * before it is able to emit a valid value. Throws an error if `defaultValue`
   * was not provided and a matching element is not found.
   *
   * @example <caption>Emit only the first click that happens on the DOM</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.first();
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Emits the first click that happens on a DIV</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.first(ev => ev.target.tagName === 'DIV');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link filter}
   * @see {@link find}
   * @see {@link take}
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   *
   * @param {function(value: T, index: number, source: Observable<T>): boolean} [predicate]
   * An optional function called with each item to test for condition matching.
   * @param {function(value: T, index: number): R} [resultSelector] A function to
   * produce the value on the output Observable based on the values
   * and the indices of the source Observable. The arguments passed to this
   * function are:
   * - `value`: the value that was emitted on the source.
   * - `index`: the "index" of the value from the source.
   * @param {R} [defaultValue] The default value emitted in case no valid value
   * was found on the source.
   * @return {Observable<T|R>} An Observable of the first item that matches the
   * condition.
   * @method first
   * @owner Observable
   */function first(predicate,resultSelector,defaultValue){return first_1.first(predicate,resultSelector,defaultValue)(this);}exports.first=first;//# sourceMappingURL=first.js.map
  
  /***/ }),
  /* 298 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var groupBy_1=__webpack_require__(299);Observable_1.Observable.prototype.groupBy=groupBy_1.groupBy;//# sourceMappingURL=groupBy.js.map
  
  /***/ }),
  /* 299 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var groupBy_1=__webpack_require__(97);exports.GroupedObservable=groupBy_1.GroupedObservable;/* tslint:enable:max-line-length *//**
   * Groups the items emitted by an Observable according to a specified criterion,
   * and emits these grouped items as `GroupedObservables`, one
   * {@link GroupedObservable} per group.
   *
   * <img src="./img/groupBy.png" width="100%">
   *
   * @example <caption>Group objects by id and return as array</caption>
   * Observable.of<Obj>({id: 1, name: 'aze1'},
   *                    {id: 2, name: 'sf2'},
   *                    {id: 2, name: 'dg2'},
   *                    {id: 1, name: 'erg1'},
   *                    {id: 1, name: 'df1'},
   *                    {id: 2, name: 'sfqfb2'},
   *                    {id: 3, name: 'qfs3'},
   *                    {id: 2, name: 'qsgqsfg2'}
   *     )
   *     .groupBy(p => p.id)
   *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], []))
   *     .subscribe(p => console.log(p));
   *
   * // displays:
   * // [ { id: 1, name: 'aze1' },
   * //   { id: 1, name: 'erg1' },
   * //   { id: 1, name: 'df1' } ]
   * //
   * // [ { id: 2, name: 'sf2' },
   * //   { id: 2, name: 'dg2' },
   * //   { id: 2, name: 'sfqfb2' },
   * //   { id: 2, name: 'qsgqsfg2' } ]
   * //
   * // [ { id: 3, name: 'qfs3' } ]
   *
   * @example <caption>Pivot data on the id field</caption>
   * Observable.of<Obj>({id: 1, name: 'aze1'},
   *                    {id: 2, name: 'sf2'},
   *                    {id: 2, name: 'dg2'},
   *                    {id: 1, name: 'erg1'},
   *                    {id: 1, name: 'df1'},
   *                    {id: 2, name: 'sfqfb2'},
   *                    {id: 3, name: 'qfs1'},
   *                    {id: 2, name: 'qsgqsfg2'}
   *                   )
   *     .groupBy(p => p.id, p => p.name)
   *     .flatMap( (group$) => group$.reduce((acc, cur) => [...acc, cur], ["" + group$.key]))
   *     .map(arr => ({'id': parseInt(arr[0]), 'values': arr.slice(1)}))
   *     .subscribe(p => console.log(p));
   *
   * // displays:
   * // { id: 1, values: [ 'aze1', 'erg1', 'df1' ] }
   * // { id: 2, values: [ 'sf2', 'dg2', 'sfqfb2', 'qsgqsfg2' ] }
   * // { id: 3, values: [ 'qfs1' ] }
   *
   * @param {function(value: T): K} keySelector A function that extracts the key
   * for each item.
   * @param {function(value: T): R} [elementSelector] A function that extracts the
   * return element for each item.
   * @param {function(grouped: GroupedObservable<K,R>): Observable<any>} [durationSelector]
   * A function that returns an Observable to determine how long each group should
   * exist.
   * @return {Observable<GroupedObservable<K,R>>} An Observable that emits
   * GroupedObservables, each of which corresponds to a unique key value and each
   * of which emits those items from the source Observable that share that key
   * value.
   * @method groupBy
   * @owner Observable
   */function groupBy(keySelector,elementSelector,durationSelector,subjectSelector){return groupBy_1.groupBy(keySelector,elementSelector,durationSelector,subjectSelector)(this);}exports.groupBy=groupBy;//# sourceMappingURL=groupBy.js.map
  
  /***/ }),
  /* 300 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);var MapPolyfill_1=__webpack_require__(301);exports.Map=root_1.root.Map||function(){return MapPolyfill_1.MapPolyfill;}();//# sourceMappingURL=Map.js.map
  
  /***/ }),
  /* 301 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var MapPolyfill=function(){function MapPolyfill(){this.size=0;this._values=[];this._keys=[];}MapPolyfill.prototype.get=function(key){var i=this._keys.indexOf(key);return i===-1?undefined:this._values[i];};MapPolyfill.prototype.set=function(key,value){var i=this._keys.indexOf(key);if(i===-1){this._keys.push(key);this._values.push(value);this.size++;}else{this._values[i]=value;}return this;};MapPolyfill.prototype.delete=function(key){var i=this._keys.indexOf(key);if(i===-1){return false;}this._values.splice(i,1);this._keys.splice(i,1);this.size--;return true;};MapPolyfill.prototype.clear=function(){this._keys.length=0;this._values.length=0;this.size=0;};MapPolyfill.prototype.forEach=function(cb,thisArg){for(var i=0;i<this.size;i++){cb.call(thisArg,this._values[i],this._keys[i]);}};return MapPolyfill;}();exports.MapPolyfill=MapPolyfill;//# sourceMappingURL=MapPolyfill.js.map
  
  /***/ }),
  /* 302 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var FastMap=function(){function FastMap(){this.values={};}FastMap.prototype.delete=function(key){this.values[key]=null;return true;};FastMap.prototype.set=function(key,value){this.values[key]=value;return this;};FastMap.prototype.get=function(key){return this.values[key];};FastMap.prototype.forEach=function(cb,thisArg){var values=this.values;for(var key in values){if(values.hasOwnProperty(key)&&values[key]!==null){cb.call(thisArg,values[key],key);}}};FastMap.prototype.clear=function(){this.values={};};return FastMap;}();exports.FastMap=FastMap;//# sourceMappingURL=FastMap.js.map
  
  /***/ }),
  /* 303 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var ignoreElements_1=__webpack_require__(304);Observable_1.Observable.prototype.ignoreElements=ignoreElements_1.ignoreElements;//# sourceMappingURL=ignoreElements.js.map
  
  /***/ }),
  /* 304 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var ignoreElements_1=__webpack_require__(98);/**
   * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.
   *
   * <img src="./img/ignoreElements.png" width="100%">
   *
   * @return {Observable} An empty Observable that only calls `complete`
   * or `error`, based on which one is called by the source Observable.
   * @method ignoreElements
   * @owner Observable
   */function ignoreElements(){return ignoreElements_1.ignoreElements()(this);}exports.ignoreElements=ignoreElements;;//# sourceMappingURL=ignoreElements.js.map
  
  /***/ }),
  /* 305 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var isEmpty_1=__webpack_require__(306);Observable_1.Observable.prototype.isEmpty=isEmpty_1.isEmpty;//# sourceMappingURL=isEmpty.js.map
  
  /***/ }),
  /* 306 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var isEmpty_1=__webpack_require__(99);/**
   * If the source Observable is empty it returns an Observable that emits true, otherwise it emits false.
   *
   * <img src="./img/isEmpty.png" width="100%">
   *
   * @return {Observable} An Observable that emits a Boolean.
   * @method isEmpty
   * @owner Observable
   */function isEmpty(){return isEmpty_1.isEmpty()(this);}exports.isEmpty=isEmpty;//# sourceMappingURL=isEmpty.js.map
  
  /***/ }),
  /* 307 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var audit_1=__webpack_require__(308);Observable_1.Observable.prototype.audit=audit_1.audit;//# sourceMappingURL=audit.js.map
  
  /***/ }),
  /* 308 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var audit_1=__webpack_require__(51);/**
   * Ignores source values for a duration determined by another Observable, then
   * emits the most recent value from the source Observable, then repeats this
   * process.
   *
   * <span class="informal">It's like {@link auditTime}, but the silencing
   * duration is determined by a second Observable.</span>
   *
   * <img src="./img/audit.png" width="100%">
   *
   * `audit` is similar to `throttle`, but emits the last value from the silenced
   * time window, instead of the first value. `audit` emits the most recent value
   * from the source Observable on the output Observable as soon as its internal
   * timer becomes disabled, and ignores source values while the timer is enabled.
   * Initially, the timer is disabled. As soon as the first source value arrives,
   * the timer is enabled by calling the `durationSelector` function with the
   * source value, which returns the "duration" Observable. When the duration
   * Observable emits a value or completes, the timer is disabled, then the most
   * recent source value is emitted on the output Observable, and this process
   * repeats for the next source value.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.audit(ev => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounce}
   * @see {@link delayWhen}
   * @see {@link sample}
   * @see {@link throttle}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the silencing
   * duration, returned as an Observable or a Promise.
   * @return {Observable<T>} An Observable that performs rate-limiting of
   * emissions from the source Observable.
   * @method audit
   * @owner Observable
   */function audit(durationSelector){return audit_1.audit(durationSelector)(this);}exports.audit=audit;//# sourceMappingURL=audit.js.map
  
  /***/ }),
  /* 309 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var auditTime_1=__webpack_require__(310);Observable_1.Observable.prototype.auditTime=auditTime_1.auditTime;//# sourceMappingURL=auditTime.js.map
  
  /***/ }),
  /* 310 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var auditTime_1=__webpack_require__(100);/**
   * Ignores source values for `duration` milliseconds, then emits the most recent
   * value from the source Observable, then repeats this process.
   *
   * <span class="informal">When it sees a source values, it ignores that plus
   * the next ones for `duration` milliseconds, and then it emits the most recent
   * value from the source.</span>
   *
   * <img src="./img/auditTime.png" width="100%">
   *
   * `auditTime` is similar to `throttleTime`, but emits the last value from the
   * silenced time window, instead of the first value. `auditTime` emits the most
   * recent value from the source Observable on the output Observable as soon as
   * its internal timer becomes disabled, and ignores source values while the
   * timer is enabled. Initially, the timer is disabled. As soon as the first
   * source value arrives, the timer is enabled. After `duration` milliseconds (or
   * the time unit determined internally by the optional `scheduler`) has passed,
   * the timer is disabled, then the most recent source value is emitted on the
   * output Observable, and this process repeats for the next source value.
   * Optionally takes a {@link IScheduler} for managing timers.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.auditTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttleTime}
   *
   * @param {number} duration Time to wait before emitting the most recent source
   * value, measured in milliseconds or the time unit determined internally
   * by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the rate-limiting behavior.
   * @return {Observable<T>} An Observable that performs rate-limiting of
   * emissions from the source Observable.
   * @method auditTime
   * @owner Observable
   */function auditTime(duration,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return auditTime_1.auditTime(duration,scheduler)(this);}exports.auditTime=auditTime;//# sourceMappingURL=auditTime.js.map
  
  /***/ }),
  /* 311 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var last_1=__webpack_require__(312);Observable_1.Observable.prototype.last=last_1.last;//# sourceMappingURL=last.js.map
  
  /***/ }),
  /* 312 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var last_1=__webpack_require__(101);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits only the last item emitted by the source Observable.
   * It optionally takes a predicate function as a parameter, in which case, rather than emitting
   * the last item from the source Observable, the resulting Observable will emit the last item
   * from the source Observable that satisfies the predicate.
   *
   * <img src="./img/last.png" width="100%">
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   * @param {function} predicate - The condition any source emitted item has to satisfy.
   * @return {Observable} An Observable that emits only the last item satisfying the given condition
   * from the source, or an NoSuchElementException if no such items are emitted.
   * @throws - Throws if no items that match the predicate are emitted by the source Observable.
   * @method last
   * @owner Observable
   */function last(predicate,resultSelector,defaultValue){return last_1.last(predicate,resultSelector,defaultValue)(this);}exports.last=last;//# sourceMappingURL=last.js.map
  
  /***/ }),
  /* 313 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var let_1=__webpack_require__(314);Observable_1.Observable.prototype.let=let_1.letProto;Observable_1.Observable.prototype.letBind=let_1.letProto;//# sourceMappingURL=let.js.map
  
  /***/ }),
  /* 314 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /**
   * @param func
   * @return {Observable<R>}
   * @method let
   * @owner Observable
   */function letProto(func){return func(this);}exports.letProto=letProto;//# sourceMappingURL=let.js.map
  
  /***/ }),
  /* 315 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var every_1=__webpack_require__(316);Observable_1.Observable.prototype.every=every_1.every;//# sourceMappingURL=every.js.map
  
  /***/ }),
  /* 316 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var every_1=__webpack_require__(102);/**
   * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.
   *
   * @example <caption>A simple example emitting true if all elements are less than 5, false otherwise</caption>
   *  Observable.of(1, 2, 3, 4, 5, 6)
   *     .every(x => x < 5)
   *     .subscribe(x => console.log(x)); // -> false
   *
   * @param {function} predicate A function for determining if an item meets a specified condition.
   * @param {any} [thisArg] Optional object to use for `this` in the callback.
   * @return {Observable} An Observable of booleans that determines if all items of the source Observable meet the condition specified.
   * @method every
   * @owner Observable
   */function every(predicate,thisArg){return every_1.every(predicate,thisArg)(this);}exports.every=every;//# sourceMappingURL=every.js.map
  
  /***/ }),
  /* 317 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var map_1=__webpack_require__(318);Observable_1.Observable.prototype.map=map_1.map;//# sourceMappingURL=map.js.map
  
  /***/ }),
  /* 318 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var map_1=__webpack_require__(22);/**
   * Applies a given `project` function to each value emitted by the source
   * Observable, and emits the resulting values as an Observable.
   *
   * <span class="informal">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),
   * it passes each source value through a transformation function to get
   * corresponding output values.</span>
   *
   * <img src="./img/map.png" width="100%">
   *
   * Similar to the well known `Array.prototype.map` function, this operator
   * applies a projection to each value and emits that projection in the output
   * Observable.
   *
   * @example <caption>Map every click to the clientX position of that click</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var positions = clicks.map(ev => ev.clientX);
   * positions.subscribe(x => console.log(x));
   *
   * @see {@link mapTo}
   * @see {@link pluck}
   *
   * @param {function(value: T, index: number): R} project The function to apply
   * to each `value` emitted by the source Observable. The `index` parameter is
   * the number `i` for the i-th emission that has happened since the
   * subscription, starting from the number `0`.
   * @param {any} [thisArg] An optional argument to define what `this` is in the
   * `project` function.
   * @return {Observable<R>} An Observable that emits the values from the source
   * Observable transformed by the given `project` function.
   * @method map
   * @owner Observable
   */function map(project,thisArg){return map_1.map(project,thisArg)(this);}exports.map=map;//# sourceMappingURL=map.js.map
  
  /***/ }),
  /* 319 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var mapTo_1=__webpack_require__(320);Observable_1.Observable.prototype.mapTo=mapTo_1.mapTo;//# sourceMappingURL=mapTo.js.map
  
  /***/ }),
  /* 320 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mapTo_1=__webpack_require__(103);/**
   * Emits the given constant value on the output Observable every time the source
   * Observable emits a value.
   *
   * <span class="informal">Like {@link map}, but it maps every source value to
   * the same output value every time.</span>
   *
   * <img src="./img/mapTo.png" width="100%">
   *
   * Takes a constant `value` as argument, and emits that whenever the source
   * Observable emits a value. In other words, ignores the actual source value,
   * and simply uses the emission moment to know when to emit the given `value`.
   *
   * @example <caption>Map every click to the string 'Hi'</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var greetings = clicks.mapTo('Hi');
   * greetings.subscribe(x => console.log(x));
   *
   * @see {@link map}
   *
   * @param {any} value The value to map each source value to.
   * @return {Observable} An Observable that emits the given `value` every time
   * the source Observable emits something.
   * @method mapTo
   * @owner Observable
   */function mapTo(value){return mapTo_1.mapTo(value)(this);}exports.mapTo=mapTo;//# sourceMappingURL=mapTo.js.map
  
  /***/ }),
  /* 321 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var materialize_1=__webpack_require__(322);Observable_1.Observable.prototype.materialize=materialize_1.materialize;//# sourceMappingURL=materialize.js.map
  
  /***/ }),
  /* 322 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var materialize_1=__webpack_require__(104);/**
   * Represents all of the notifications from the source Observable as `next`
   * emissions marked with their original types within {@link Notification}
   * objects.
   *
   * <span class="informal">Wraps `next`, `error` and `complete` emissions in
   * {@link Notification} objects, emitted as `next` on the output Observable.
   * </span>
   *
   * <img src="./img/materialize.png" width="100%">
   *
   * `materialize` returns an Observable that emits a `next` notification for each
   * `next`, `error`, or `complete` emission of the source Observable. When the
   * source Observable emits `complete`, the output Observable will emit `next` as
   * a Notification of type "complete", and then it will emit `complete` as well.
   * When the source Observable emits `error`, the output will emit `next` as a
   * Notification of type "error", and then `complete`.
   *
   * This operator is useful for producing metadata of the source Observable, to
   * be consumed as `next` emissions. Use it in conjunction with
   * {@link dematerialize}.
   *
   * @example <caption>Convert a faulty Observable to an Observable of Notifications</caption>
   * var letters = Rx.Observable.of('a', 'b', 13, 'd');
   * var upperCase = letters.map(x => x.toUpperCase());
   * var materialized = upperCase.materialize();
   * materialized.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // - Notification {kind: "N", value: "A", error: undefined, hasValue: true}
   * // - Notification {kind: "N", value: "B", error: undefined, hasValue: true}
   * // - Notification {kind: "E", value: undefined, error: TypeError:
   * //   x.toUpperCase is not a function at MapSubscriber.letters.map.x
   * //   [as project] (http://1…, hasValue: false}
   *
   * @see {@link Notification}
   * @see {@link dematerialize}
   *
   * @return {Observable<Notification<T>>} An Observable that emits
   * {@link Notification} objects that wrap the original emissions from the source
   * Observable with metadata.
   * @method materialize
   * @owner Observable
   */function materialize(){return materialize_1.materialize()(this);}exports.materialize=materialize;//# sourceMappingURL=materialize.js.map
  
  /***/ }),
  /* 323 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var max_1=__webpack_require__(324);Observable_1.Observable.prototype.max=max_1.max;//# sourceMappingURL=max.js.map
  
  /***/ }),
  /* 324 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var max_1=__webpack_require__(105);/**
   * The Max operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
   * and when source Observable completes it emits a single item: the item with the largest value.
   *
   * <img src="./img/max.png" width="100%">
   *
   * @example <caption>Get the maximal value of a series of numbers</caption>
   * Rx.Observable.of(5, 4, 7, 2, 8)
   *   .max()
   *   .subscribe(x => console.log(x)); // -> 8
   *
   * @example <caption>Use a comparer function to get the maximal item</caption>
   * interface Person {
   *   age: number,
   *   name: string
   * }
   * Observable.of<Person>({age: 7, name: 'Foo'},
   *                       {age: 5, name: 'Bar'},
   *                       {age: 9, name: 'Beer'})
   *           .max<Person>((a: Person, b: Person) => a.age < b.age ? -1 : 1)
   *           .subscribe((x: Person) => console.log(x.name)); // -> 'Beer'
   * }
   *
   * @see {@link min}
   *
   * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
   * value of two items.
   * @return {Observable} An Observable that emits item with the largest value.
   * @method max
   * @owner Observable
   */function max(comparer){return max_1.max(comparer)(this);}exports.max=max;//# sourceMappingURL=max.js.map
  
  /***/ }),
  /* 325 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var merge_1=__webpack_require__(326);Observable_1.Observable.prototype.merge=merge_1.merge;//# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 326 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var merge_1=__webpack_require__(106);var merge_2=__webpack_require__(33);exports.mergeStatic=merge_2.merge;/* tslint:enable:max-line-length *//**
   * Creates an output Observable which concurrently emits all values from every
   * given input Observable.
   *
   * <span class="informal">Flattens multiple Observables together by blending
   * their values into one Observable.</span>
   *
   * <img src="./img/merge.png" width="100%">
   *
   * `merge` subscribes to each given input Observable (either the source or an
   * Observable given as argument), and simply forwards (without doing any
   * transformation) all the values from all the input Observables to the output
   * Observable. The output Observable only completes once all input Observables
   * have completed. Any error delivered by an input Observable will be immediately
   * emitted on the output Observable.
   *
   * @example <caption>Merge together two Observables: 1s interval and clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var clicksOrTimer = clicks.merge(timer);
   * clicksOrTimer.subscribe(x => console.log(x));
   *
   * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var concurrent = 2; // the argument
   * var merged = timer1.merge(timer2, timer3, concurrent);
   * merged.subscribe(x => console.log(x));
   *
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   *
   * @param {ObservableInput} other An input Observable to merge with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for managing
   * concurrency of input Observables.
   * @return {Observable} An Observable that emits items that are the result of
   * every input Observable.
   * @method merge
   * @owner Observable
   */function merge(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return merge_1.merge.apply(void 0,observables)(this);}exports.merge=merge;//# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 327 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var mergeAll_1=__webpack_require__(328);Observable_1.Observable.prototype.mergeAll=mergeAll_1.mergeAll;//# sourceMappingURL=mergeAll.js.map
  
  /***/ }),
  /* 328 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeAll_1=__webpack_require__(32);/**
   * Converts a higher-order Observable into a first-order Observable which
   * concurrently delivers all values that are emitted on the inner Observables.
   *
   * <span class="informal">Flattens an Observable-of-Observables.</span>
   *
   * <img src="./img/mergeAll.png" width="100%">
   *
   * `mergeAll` subscribes to an Observable that emits Observables, also known as
   * a higher-order Observable. Each time it observes one of these emitted inner
   * Observables, it subscribes to that and delivers all the values from the
   * inner Observable on the output Observable. The output Observable only
   * completes once all inner Observables have completed. Any error delivered by
   * a inner Observable will be immediately emitted on the output Observable.
   *
   * @example <caption>Spawn a new interval Observable for each click event, and blend their outputs as one Observable</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000));
   * var firstOrder = higherOrder.mergeAll();
   * firstOrder.subscribe(x => console.log(x));
   *
   * @example <caption>Count from 0 to 9 every second for each click, but only allow 2 concurrent timers</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000).take(10));
   * var firstOrder = higherOrder.mergeAll(2);
   * firstOrder.subscribe(x => console.log(x));
   *
   * @see {@link combineAll}
   * @see {@link concatAll}
   * @see {@link exhaust}
   * @see {@link merge}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   * @see {@link switch}
   * @see {@link zipAll}
   *
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of inner
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits values coming from all the
   * inner Observables emitted by the source Observable.
   * @method mergeAll
   * @owner Observable
   */function mergeAll(concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return mergeAll_1.mergeAll(concurrent)(this);}exports.mergeAll=mergeAll;//# sourceMappingURL=mergeAll.js.map
  
  /***/ }),
  /* 329 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var mergeMap_1=__webpack_require__(330);Observable_1.Observable.prototype.mergeMap=mergeMap_1.mergeMap;Observable_1.Observable.prototype.flatMap=mergeMap_1.mergeMap;//# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  /* 330 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeMap_1=__webpack_require__(18);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link mergeAll}.</span>
   *
   * <img src="./img/mergeMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an Observable, and then merging those resulting Observables and
   * emitting the results of this merger.
   *
   * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>
   * var letters = Rx.Observable.of('a', 'b', 'c');
   * var result = letters.mergeMap(x =>
   *   Rx.Observable.interval(1000).map(i => x+i)
   * );
   * result.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // a0
   * // b0
   * // c0
   * // a1
   * // b1
   * // c1
   * // continues to list a,b,c with respective ascending integers
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link merge}
   * @see {@link mergeAll}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   * @see {@link switchMap}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and merging the results of the Observables obtained
   * from this transformation.
   * @method mergeMap
   * @owner Observable
   */function mergeMap(project,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return mergeMap_1.mergeMap(project,resultSelector,concurrent)(this);}exports.mergeMap=mergeMap;//# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  /* 331 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var mergeMapTo_1=__webpack_require__(332);Observable_1.Observable.prototype.flatMapTo=mergeMapTo_1.mergeMapTo;Observable_1.Observable.prototype.mergeMapTo=mergeMapTo_1.mergeMapTo;//# sourceMappingURL=mergeMapTo.js.map
  
  /***/ }),
  /* 332 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeMapTo_1=__webpack_require__(107);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is merged multiple
   * times in the output Observable.
   *
   * <span class="informal">It's like {@link mergeMap}, but maps each value always
   * to the same inner Observable.</span>
   *
   * <img src="./img/mergeMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then merges those resulting Observables into one
   * single Observable, which is the output Observable.
   *
   * @example <caption>For each click event, start an interval Observable ticking every 1 second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.mergeMapTo(Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMapTo}
   * @see {@link merge}
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeScan}
   * @see {@link switchMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable.
   * @method mergeMapTo
   * @owner Observable
   */function mergeMapTo(innerObservable,resultSelector,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return mergeMapTo_1.mergeMapTo(innerObservable,resultSelector,concurrent)(this);}exports.mergeMapTo=mergeMapTo;//# sourceMappingURL=mergeMapTo.js.map
  
  /***/ }),
  /* 333 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var mergeScan_1=__webpack_require__(334);Observable_1.Observable.prototype.mergeScan=mergeScan_1.mergeScan;//# sourceMappingURL=mergeScan.js.map
  
  /***/ }),
  /* 334 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var mergeScan_1=__webpack_require__(108);/**
   * Applies an accumulator function over the source Observable where the
   * accumulator function itself returns an Observable, then each intermediate
   * Observable returned is merged into the output Observable.
   *
   * <span class="informal">It's like {@link scan}, but the Observables returned
   * by the accumulator are merged into the outer Observable.</span>
   *
   * @example <caption>Count the number of click events</caption>
   * const click$ = Rx.Observable.fromEvent(document, 'click');
   * const one$ = click$.mapTo(1);
   * const seed = 0;
   * const count$ = one$.mergeScan((acc, one) => Rx.Observable.of(acc + one), seed);
   * count$.subscribe(x => console.log(x));
   *
   * // Results:
   * 1
   * 2
   * 3
   * 4
   * // ...and so on for each click
   *
   * @param {function(acc: R, value: T): Observable<R>} accumulator
   * The accumulator function called on each source value.
   * @param seed The initial accumulation value.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of
   * input Observables being subscribed to concurrently.
   * @return {Observable<R>} An observable of the accumulated values.
   * @method mergeScan
   * @owner Observable
   */function mergeScan(accumulator,seed,concurrent){if(concurrent===void 0){concurrent=Number.POSITIVE_INFINITY;}return mergeScan_1.mergeScan(accumulator,seed,concurrent)(this);}exports.mergeScan=mergeScan;//# sourceMappingURL=mergeScan.js.map
  
  /***/ }),
  /* 335 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var min_1=__webpack_require__(336);Observable_1.Observable.prototype.min=min_1.min;//# sourceMappingURL=min.js.map
  
  /***/ }),
  /* 336 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var min_1=__webpack_require__(109);/**
   * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
   * and when source Observable completes it emits a single item: the item with the smallest value.
   *
   * <img src="./img/min.png" width="100%">
   *
   * @example <caption>Get the minimal value of a series of numbers</caption>
   * Rx.Observable.of(5, 4, 7, 2, 8)
   *   .min()
   *   .subscribe(x => console.log(x)); // -> 2
   *
   * @example <caption>Use a comparer function to get the minimal item</caption>
   * interface Person {
   *   age: number,
   *   name: string
   * }
   * Observable.of<Person>({age: 7, name: 'Foo'},
   *                       {age: 5, name: 'Bar'},
   *                       {age: 9, name: 'Beer'})
   *           .min<Person>( (a: Person, b: Person) => a.age < b.age ? -1 : 1)
   *           .subscribe((x: Person) => console.log(x.name)); // -> 'Bar'
   * }
   *
   * @see {@link max}
   *
   * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
   * value of two items.
   * @return {Observable<R>} An Observable that emits item with the smallest value.
   * @method min
   * @owner Observable
   */function min(comparer){return min_1.min(comparer)(this);}exports.min=min;//# sourceMappingURL=min.js.map
  
  /***/ }),
  /* 337 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var multicast_1=__webpack_require__(338);Observable_1.Observable.prototype.multicast=multicast_1.multicast;//# sourceMappingURL=multicast.js.map
  
  /***/ }),
  /* 338 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var multicast_1=__webpack_require__(14);/* tslint:enable:max-line-length *//**
   * Allows source Observable to be subscribed only once with a Subject of choice,
   * while still sharing its values between multiple subscribers.
   *
   * <span class="informal">Subscribe to Observable once, but send its values to multiple subscribers.</span>
   *
   * <img src="./img/multicast.png" width="100%">
   *
   * `multicast` is an operator that works in two modes.
   *
   * In the first mode you provide a single argument to it, which can be either an initialized Subject or a Subject
   * factory. As a result you will get a special kind of an Observable - a {@link ConnectableObservable}. It can be
   * subscribed multiple times, just as regular Observable, but it won't subscribe to the source Observable at that
   * moment. It will do it only if you call its `connect` method. This means you can essentially control by hand, when
   * source Observable will be actually subscribed. What is more, ConnectableObservable will share this one subscription
   * between all of its subscribers. This means that, for example, `ajax` Observable will only send a request once,
   * even though usually it would send a request per every subscriber. Since it sends a request at the moment of
   * subscription, here request would be sent when the `connect` method of a ConnectableObservable is called.
   *
   * The most common pattern of using ConnectableObservable is calling `connect` when the first consumer subscribes,
   * keeping the subscription alive while several consumers come and go and finally unsubscribing from the source
   * Observable, when the last consumer unsubscribes. To not implement that logic over and over again,
   * ConnectableObservable has a special operator, `refCount`. When called, it returns an Observable, which will count
   * the number of consumers subscribed to it and keep ConnectableObservable connected as long as there is at least
   * one consumer. So if you don't actually need to decide yourself when to connect and disconnect a
   * ConnectableObservable, use `refCount`.
   *
   * The second mode is invoked by calling `multicast` with an additional, second argument - selector function.
   * This function accepts an Observable - which basically mirrors the source Observable - and returns Observable
   * as well, which should be the input stream modified by any operators you want. Note that in this
   * mode you cannot provide initialized Subject as a first argument - it has to be a Subject factory. If
   * you provide selector function, `multicast` returns just a regular Observable, instead of ConnectableObservable.
   * Thus, as usual, each subscription to this stream triggers subscription to the source Observable. However,
   * if inside the selector function you subscribe to the input Observable multiple times, actual source stream
   * will be subscribed only once. So if you have a chain of operators that use some Observable many times,
   * but you want to subscribe to that Observable only once, this is the mode you would use.
   *
   * Subject provided as a first parameter of `multicast` is used as a proxy for the single subscription to the
   * source Observable. It means that all values from the source stream go through that Subject. Thus, if a Subject
   * has some special properties, Observable returned by `multicast` will have them as well. If you want to use
   * `multicast` with a Subject that is one of the ones included in RxJS by default - {@link Subject},
   * {@link AsyncSubject}, {@link BehaviorSubject}, or {@link ReplaySubject} - simply use {@link publish},
   * {@link publishLast}, {@link publishBehavior} or {@link publishReplay} respectively. These are actually
   * just wrappers around `multicast`, with a specific Subject hardcoded inside.
   *
   * Also, if you use {@link publish} or {@link publishReplay} with a ConnectableObservables `refCount` operator,
   * you can simply use {@link share} and {@link shareReplay} respectively, which chain these two.
   *
   * @example <caption>Use ConnectableObservable</caption>
   * const seconds = Rx.Observable.interval(1000);
   * const connectableSeconds = seconds.multicast(new Subject());
   *
   * connectableSeconds.subscribe(value => console.log('first: ' + value));
   * connectableSeconds.subscribe(value => console.log('second: ' + value));
   *
   * // At this point still nothing happens, even though we subscribed twice.
   *
   * connectableSeconds.connect();
   *
   * // From now on `seconds` are being logged to the console,
   * // twice per every second. `seconds` Observable was however only subscribed once,
   * // so under the hood Observable.interval had only one clock started.
   *
   * @example <caption>Use selector</caption>
   * const seconds = Rx.Observable.interval(1000);
   *
   * seconds
   *     .multicast(
   *         () => new Subject(),
   *         seconds => seconds.zip(seconds) // Usually zip would subscribe to `seconds` twice.
   *                                         // Because we are inside selector, `seconds` is subscribed once,
   *     )                                   // thus starting only one clock used internally by Observable.interval.
   *     .subscribe();
   *
   * @see {@link publish}
   * @see {@link publishLast}
   * @see {@link publishBehavior}
   * @see {@link publishReplay}
   * @see {@link share}
   * @see {@link shareReplay}
   *
   * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate Subject through
   * which the source sequence's elements will be multicast to the selector function input Observable or
   * ConnectableObservable returned by the operator.
   * @param {Function} [selector] - Optional selector function that can use the input stream
   * as many times as needed, without causing multiple subscriptions to the source stream.
   * Subscribers to the input source will receive all notifications of the source from the
   * time of the subscription forward.
   * @return {Observable<T>|ConnectableObservable<T>} An Observable that emits the results of invoking the selector
   * on the source stream or a special {@link ConnectableObservable}, if selector was not provided.
   *
   * @method multicast
   * @owner Observable
   */function multicast(subjectOrSubjectFactory,selector){return multicast_1.multicast(subjectOrSubjectFactory,selector)(this);}exports.multicast=multicast;//# sourceMappingURL=multicast.js.map
  
  /***/ }),
  /* 339 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var observeOn_1=__webpack_require__(340);Observable_1.Observable.prototype.observeOn=observeOn_1.observeOn;//# sourceMappingURL=observeOn.js.map
  
  /***/ }),
  /* 340 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var observeOn_1=__webpack_require__(31);/**
   *
   * Re-emits all notifications from source Observable with specified scheduler.
   *
   * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
   *
   * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
   * notifications emitted by the source Observable. It might be useful, if you do not have control over
   * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
   *
   * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
   * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
   * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
   * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
   * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
   * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
   * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
   * little bit more, to ensure that they are emitted at expected moments.
   *
   * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
   * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
   * will delay all notifications - including error notifications - while `delay` will pass through error
   * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
   * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
   * for notification emissions in general.
   *
   * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>
   * const intervals = Rx.Observable.interval(10); // Intervals are scheduled
   *                                               // with async scheduler by default...
   *
   * intervals
   * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame
   * .subscribe(val => {                           // scheduler to ensure smooth animation.
   *   someDiv.style.height = val + 'px';
   * });
   *
   * @see {@link delay}
   *
   * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.
   * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.
   * @return {Observable<T>} Observable that emits the same notifications as the source Observable,
   * but with provided scheduler.
   *
   * @method observeOn
   * @owner Observable
   */function observeOn(scheduler,delay){if(delay===void 0){delay=0;}return observeOn_1.observeOn(scheduler,delay)(this);}exports.observeOn=observeOn;//# sourceMappingURL=observeOn.js.map
  
  /***/ }),
  /* 341 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var onErrorResumeNext_1=__webpack_require__(342);Observable_1.Observable.prototype.onErrorResumeNext=onErrorResumeNext_1.onErrorResumeNext;//# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 342 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var onErrorResumeNext_1=__webpack_require__(45);/* tslint:enable:max-line-length *//**
   * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
   * that was passed.
   *
   * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span>
   *
   * <img src="./img/onErrorResumeNext.png" width="100%">
   *
   * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as
   * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same
   * as the source.
   *
   * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.
   * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`
   * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting
   * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another
   * Observable in provided series, no matter if previous Observable completed or ended with an error. This will
   * be happening until there is no more Observables left in the series, at which point returned Observable will
   * complete - even if the last subscribed stream ended with an error.
   *
   * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive
   * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable
   * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with
   * an error.
   *
   * Note that you do not get any access to errors emitted by the Observables. In particular do not
   * expect these errors to appear in error callback passed to {@link subscribe}. If you want to take
   * specific actions based on what error was emitted by an Observable, you should try out {@link catch} instead.
   *
   *
   * @example <caption>Subscribe to the next Observable after map fails</caption>
   * Rx.Observable.of(1, 2, 3, 0)
   *   .map(x => {
   *       if (x === 0) { throw Error(); }
           return 10 / x;
   *   })
   *   .onErrorResumeNext(Rx.Observable.of(1, 2, 3))
   *   .subscribe(
   *     val => console.log(val),
   *     err => console.log(err),          // Will never be called.
   *     () => console.log('that\'s it!')
   *   );
   *
   * // Logs:
   * // 10
   * // 5
   * // 3.3333333333333335
   * // 1
   * // 2
   * // 3
   * // "that's it!"
   *
   * @see {@link concat}
   * @see {@link catch}
   *
   * @param {...ObservableInput} observables Observables passed either directly or as an array.
   * @return {Observable} An Observable that emits values from source Observable, but - if it errors - subscribes
   * to the next passed Observable and so on, until it completes or runs out of Observables.
   * @method onErrorResumeNext
   * @owner Observable
   */function onErrorResumeNext(){var nextSources=[];for(var _i=0;_i<arguments.length;_i++){nextSources[_i-0]=arguments[_i];}return onErrorResumeNext_1.onErrorResumeNext.apply(void 0,nextSources)(this);}exports.onErrorResumeNext=onErrorResumeNext;//# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 343 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var pairwise_1=__webpack_require__(344);Observable_1.Observable.prototype.pairwise=pairwise_1.pairwise;//# sourceMappingURL=pairwise.js.map
  
  /***/ }),
  /* 344 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var pairwise_1=__webpack_require__(111);/**
   * Groups pairs of consecutive emissions together and emits them as an array of
   * two values.
   *
   * <span class="informal">Puts the current value and previous value together as
   * an array, and emits that.</span>
   *
   * <img src="./img/pairwise.png" width="100%">
   *
   * The Nth emission from the source Observable will cause the output Observable
   * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
   * pair. For this reason, `pairwise` emits on the second and subsequent
   * emissions from the source Observable, but not on the first emission, because
   * there is no previous value in that case.
   *
   * @example <caption>On every click (starting from the second), emit the relative distance to the previous click</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var pairs = clicks.pairwise();
   * var distance = pairs.map(pair => {
   *   var x0 = pair[0].clientX;
   *   var y0 = pair[0].clientY;
   *   var x1 = pair[1].clientX;
   *   var y1 = pair[1].clientY;
   *   return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
   * });
   * distance.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   *
   * @return {Observable<Array<T>>} An Observable of pairs (as arrays) of
   * consecutive values from the source Observable.
   * @method pairwise
   * @owner Observable
   */function pairwise(){return pairwise_1.pairwise()(this);}exports.pairwise=pairwise;//# sourceMappingURL=pairwise.js.map
  
  /***/ }),
  /* 345 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var partition_1=__webpack_require__(346);Observable_1.Observable.prototype.partition=partition_1.partition;//# sourceMappingURL=partition.js.map
  
  /***/ }),
  /* 346 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var partition_1=__webpack_require__(112);/**
   * Splits the source Observable into two, one with values that satisfy a
   * predicate, and another with values that don't satisfy the predicate.
   *
   * <span class="informal">It's like {@link filter}, but returns two Observables:
   * one like the output of {@link filter}, and the other with values that did not
   * pass the condition.</span>
   *
   * <img src="./img/partition.png" width="100%">
   *
   * `partition` outputs an array with two Observables that partition the values
   * from the source Observable through the given `predicate` function. The first
   * Observable in that array emits source values for which the predicate argument
   * returns true. The second Observable emits source values for which the
   * predicate returns false. The first behaves like {@link filter} and the second
   * behaves like {@link filter} with the predicate negated.
   *
   * @example <caption>Partition click events into those on DIV elements and those elsewhere</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var parts = clicks.partition(ev => ev.target.tagName === 'DIV');
   * var clicksOnDivs = parts[0];
   * var clicksElsewhere = parts[1];
   * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
   * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
   *
   * @see {@link filter}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates each value emitted by the source Observable. If it returns `true`,
   * the value is emitted on the first Observable in the returned array, if
   * `false` the value is emitted on the second Observable in the array. The
   * `index` parameter is the number `i` for the i-th source emission that has
   * happened since the subscription, starting from the number `0`.
   * @param {any} [thisArg] An optional argument to determine the value of `this`
   * in the `predicate` function.
   * @return {[Observable<T>, Observable<T>]} An array with two Observables: one
   * with values that passed the predicate, and another with values that did not
   * pass the predicate.
   * @method partition
   * @owner Observable
   */function partition(predicate,thisArg){return partition_1.partition(predicate,thisArg)(this);}exports.partition=partition;//# sourceMappingURL=partition.js.map
  
  /***/ }),
  /* 347 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  function not(pred,thisArg){function notPred(){return!notPred.pred.apply(notPred.thisArg,arguments);}notPred.pred=pred;notPred.thisArg=thisArg;return notPred;}exports.not=not;//# sourceMappingURL=not.js.map
  
  /***/ }),
  /* 348 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var pluck_1=__webpack_require__(349);Observable_1.Observable.prototype.pluck=pluck_1.pluck;//# sourceMappingURL=pluck.js.map
  
  /***/ }),
  /* 349 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var pluck_1=__webpack_require__(113);/**
   * Maps each source value (an object) to its specified nested property.
   *
   * <span class="informal">Like {@link map}, but meant only for picking one of
   * the nested properties of every emitted object.</span>
   *
   * <img src="./img/pluck.png" width="100%">
   *
   * Given a list of strings describing a path to an object property, retrieves
   * the value of a specified nested property from all values in the source
   * Observable. If a property can't be resolved, it will return `undefined` for
   * that value.
   *
   * @example <caption>Map every click to the tagName of the clicked target element</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var tagNames = clicks.pluck('target', 'tagName');
   * tagNames.subscribe(x => console.log(x));
   *
   * @see {@link map}
   *
   * @param {...string} properties The nested properties to pluck from each source
   * value (an object).
   * @return {Observable} A new Observable of property values from the source values.
   * @method pluck
   * @owner Observable
   */function pluck(){var properties=[];for(var _i=0;_i<arguments.length;_i++){properties[_i-0]=arguments[_i];}return pluck_1.pluck.apply(void 0,properties)(this);}exports.pluck=pluck;//# sourceMappingURL=pluck.js.map
  
  /***/ }),
  /* 350 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var publish_1=__webpack_require__(351);Observable_1.Observable.prototype.publish=publish_1.publish;//# sourceMappingURL=publish.js.map
  
  /***/ }),
  /* 351 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var publish_1=__webpack_require__(114);/* tslint:enable:max-line-length *//**
   * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
   * before it begins emitting items to those Observers that have subscribed to it.
   *
   * <img src="./img/publish.png" width="100%">
   *
   * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times
   * as needed, without causing multiple subscriptions to the source sequence.
   * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
   * @return A ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.
   * @method publish
   * @owner Observable
   */function publish(selector){return publish_1.publish(selector)(this);}exports.publish=publish;//# sourceMappingURL=publish.js.map
  
  /***/ }),
  /* 352 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var publishBehavior_1=__webpack_require__(353);Observable_1.Observable.prototype.publishBehavior=publishBehavior_1.publishBehavior;//# sourceMappingURL=publishBehavior.js.map
  
  /***/ }),
  /* 353 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var publishBehavior_1=__webpack_require__(115);/**
   * @param value
   * @return {ConnectableObservable<T>}
   * @method publishBehavior
   * @owner Observable
   */function publishBehavior(value){return publishBehavior_1.publishBehavior(value)(this);}exports.publishBehavior=publishBehavior;//# sourceMappingURL=publishBehavior.js.map
  
  /***/ }),
  /* 354 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var publishReplay_1=__webpack_require__(355);Observable_1.Observable.prototype.publishReplay=publishReplay_1.publishReplay;//# sourceMappingURL=publishReplay.js.map
  
  /***/ }),
  /* 355 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var publishReplay_1=__webpack_require__(117);/* tslint:enable:max-line-length *//**
   * @param bufferSize
   * @param windowTime
   * @param selectorOrScheduler
   * @param scheduler
   * @return {Observable<T> | ConnectableObservable<T>}
   * @method publishReplay
   * @owner Observable
   */function publishReplay(bufferSize,windowTime,selectorOrScheduler,scheduler){return publishReplay_1.publishReplay(bufferSize,windowTime,selectorOrScheduler,scheduler)(this);}exports.publishReplay=publishReplay;//# sourceMappingURL=publishReplay.js.map
  
  /***/ }),
  /* 356 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var publishLast_1=__webpack_require__(357);Observable_1.Observable.prototype.publishLast=publishLast_1.publishLast;//# sourceMappingURL=publishLast.js.map
  
  /***/ }),
  /* 357 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var publishLast_1=__webpack_require__(118);/**
   * @return {ConnectableObservable<T>}
   * @method publishLast
   * @owner Observable
   */function publishLast(){//TODO(benlesh): correct type-flow through here.
  return publishLast_1.publishLast()(this);}exports.publishLast=publishLast;//# sourceMappingURL=publishLast.js.map
  
  /***/ }),
  /* 358 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var race_1=__webpack_require__(359);Observable_1.Observable.prototype.race=race_1.race;//# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 359 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var race_1=__webpack_require__(119);// NOTE: to support backwards compatability with 5.4.* and lower
  var race_2=__webpack_require__(44);exports.raceStatic=race_2.race;/* tslint:enable:max-line-length *//**
   * Returns an Observable that mirrors the first source Observable to emit an item
   * from the combination of this Observable and supplied Observables.
   * @param {...Observables} ...observables Sources used to race for which Observable emits first.
   * @return {Observable} An Observable that mirrors the output of the first Observable to emit an item.
   * @method race
   * @owner Observable
   */function race(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return race_1.race.apply(void 0,observables)(this);}exports.race=race;//# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 360 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var reduce_1=__webpack_require__(361);Observable_1.Observable.prototype.reduce=reduce_1.reduce;//# sourceMappingURL=reduce.js.map
  
  /***/ }),
  /* 361 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var reduce_1=__webpack_require__(24);/* tslint:enable:max-line-length *//**
   * Applies an accumulator function over the source Observable, and returns the
   * accumulated result when the source completes, given an optional seed value.
   *
   * <span class="informal">Combines together all values emitted on the source,
   * using an accumulator function that knows how to join a new source value into
   * the accumulation from the past.</span>
   *
   * <img src="./img/reduce.png" width="100%">
   *
   * Like
   * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),
   * `reduce` applies an `accumulator` function against an accumulation and each
   * value of the source Observable (from the past) to reduce it to a single
   * value, emitted on the output Observable. Note that `reduce` will only emit
   * one value, only when the source Observable completes. It is equivalent to
   * applying operator {@link scan} followed by operator {@link last}.
   *
   * Returns an Observable that applies a specified `accumulator` function to each
   * item emitted by the source Observable. If a `seed` value is specified, then
   * that value will be used as the initial value for the accumulator. If no seed
   * value is specified, the first item of the source is used as the seed.
   *
   * @example <caption>Count the number of click events that happened in 5 seconds</caption>
   * var clicksInFiveSeconds = Rx.Observable.fromEvent(document, 'click')
   *   .takeUntil(Rx.Observable.interval(5000));
   * var ones = clicksInFiveSeconds.mapTo(1);
   * var seed = 0;
   * var count = ones.reduce((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link count}
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link scan}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator The accumulator function
   * called on each source value.
   * @param {R} [seed] The initial accumulation value.
   * @return {Observable<R>} An Observable that emits a single value that is the
   * result of accumulating the values emitted by the source Observable.
   * @method reduce
   * @owner Observable
   */function reduce(accumulator,seed){// providing a seed of `undefined` *should* be valid and trigger
  // hasSeed! so don't use `seed !== undefined` checks!
  // For this reason, we have to check it here at the original call site
  // otherwise inside Operator/Subscriber we won't know if `undefined`
  // means they didn't provide anything or if they literally provided `undefined`
  if(arguments.length>=2){return reduce_1.reduce(accumulator,seed)(this);}return reduce_1.reduce(accumulator)(this);}exports.reduce=reduce;//# sourceMappingURL=reduce.js.map
  
  /***/ }),
  /* 362 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var repeat_1=__webpack_require__(363);Observable_1.Observable.prototype.repeat=repeat_1.repeat;//# sourceMappingURL=repeat.js.map
  
  /***/ }),
  /* 363 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var repeat_1=__webpack_require__(120);/**
   * Returns an Observable that repeats the stream of items emitted by the source Observable at most count times.
   *
   * <img src="./img/repeat.png" width="100%">
   *
   * @param {number} [count] The number of times the source Observable items are repeated, a count of 0 will yield
   * an empty Observable.
   * @return {Observable} An Observable that repeats the stream of items emitted by the source Observable at most
   * count times.
   * @method repeat
   * @owner Observable
   */function repeat(count){if(count===void 0){count=-1;}return repeat_1.repeat(count)(this);}exports.repeat=repeat;//# sourceMappingURL=repeat.js.map
  
  /***/ }),
  /* 364 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var repeatWhen_1=__webpack_require__(365);Observable_1.Observable.prototype.repeatWhen=repeatWhen_1.repeatWhen;//# sourceMappingURL=repeatWhen.js.map
  
  /***/ }),
  /* 365 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var repeatWhen_1=__webpack_require__(121);/**
   * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
   * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
   * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
   * this method will resubscribe to the source Observable.
   *
   * <img src="./img/repeatWhen.png" width="100%">
   *
   * @param {function(notifications: Observable): Observable} notifier - Receives an Observable of notifications with
   * which a user can `complete` or `error`, aborting the repetition.
   * @return {Observable} The source Observable modified with repeat logic.
   * @method repeatWhen
   * @owner Observable
   */function repeatWhen(notifier){return repeatWhen_1.repeatWhen(notifier)(this);}exports.repeatWhen=repeatWhen;//# sourceMappingURL=repeatWhen.js.map
  
  /***/ }),
  /* 366 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var retry_1=__webpack_require__(367);Observable_1.Observable.prototype.retry=retry_1.retry;//# sourceMappingURL=retry.js.map
  
  /***/ }),
  /* 367 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var retry_1=__webpack_require__(122);/**
   * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
   * calls `error`, this method will resubscribe to the source Observable for a maximum of `count` resubscriptions (given
   * as a number parameter) rather than propagating the `error` call.
   *
   * <img src="./img/retry.png" width="100%">
   *
   * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted
   * during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second
   * time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications
   * would be: [1, 2, 1, 2, 3, 4, 5, `complete`].
   * @param {number} count - Number of retry attempts before failing.
   * @return {Observable} The source Observable modified with the retry logic.
   * @method retry
   * @owner Observable
   */function retry(count){if(count===void 0){count=-1;}return retry_1.retry(count)(this);}exports.retry=retry;//# sourceMappingURL=retry.js.map
  
  /***/ }),
  /* 368 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var retryWhen_1=__webpack_require__(369);Observable_1.Observable.prototype.retryWhen=retryWhen_1.retryWhen;//# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  /* 369 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var retryWhen_1=__webpack_require__(123);/**
   * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
   * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.
   * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
   * subscription. Otherwise this method will resubscribe to the source Observable.
   *
   * <img src="./img/retryWhen.png" width="100%">
   *
   * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a
   * user can `complete` or `error`, aborting the retry.
   * @return {Observable} The source Observable modified with retry logic.
   * @method retryWhen
   * @owner Observable
   */function retryWhen(notifier){return retryWhen_1.retryWhen(notifier)(this);}exports.retryWhen=retryWhen;//# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  /* 370 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var sample_1=__webpack_require__(371);Observable_1.Observable.prototype.sample=sample_1.sample;//# sourceMappingURL=sample.js.map
  
  /***/ }),
  /* 371 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var sample_1=__webpack_require__(124);/**
   * Emits the most recently emitted value from the source Observable whenever
   * another Observable, the `notifier`, emits.
   *
   * <span class="informal">It's like {@link sampleTime}, but samples whenever
   * the `notifier` Observable emits something.</span>
   *
   * <img src="./img/sample.png" width="100%">
   *
   * Whenever the `notifier` Observable emits a value or completes, `sample`
   * looks at the source Observable and emits whichever value it has most recently
   * emitted since the previous sampling, unless the source has not emitted
   * anything since the previous sampling. The `notifier` is subscribed to as soon
   * as the output Observable is subscribed.
   *
   * @example <caption>On every click, sample the most recent "seconds" timer</caption>
   * var seconds = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = seconds.sample(clicks);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounce}
   * @see {@link sampleTime}
   * @see {@link throttle}
   *
   * @param {Observable<any>} notifier The Observable to use for sampling the
   * source Observable.
   * @return {Observable<T>} An Observable that emits the results of sampling the
   * values emitted by the source Observable whenever the notifier Observable
   * emits value or completes.
   * @method sample
   * @owner Observable
   */function sample(notifier){return sample_1.sample(notifier)(this);}exports.sample=sample;//# sourceMappingURL=sample.js.map
  
  /***/ }),
  /* 372 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var sampleTime_1=__webpack_require__(373);Observable_1.Observable.prototype.sampleTime=sampleTime_1.sampleTime;//# sourceMappingURL=sampleTime.js.map
  
  /***/ }),
  /* 373 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var sampleTime_1=__webpack_require__(125);/**
   * Emits the most recently emitted value from the source Observable within
   * periodic time intervals.
   *
   * <span class="informal">Samples the source Observable at periodic time
   * intervals, emitting what it samples.</span>
   *
   * <img src="./img/sampleTime.png" width="100%">
   *
   * `sampleTime` periodically looks at the source Observable and emits whichever
   * value it has most recently emitted since the previous sampling, unless the
   * source has not emitted anything since the previous sampling. The sampling
   * happens periodically in time every `period` milliseconds (or the time unit
   * defined by the optional `scheduler` argument). The sampling starts as soon as
   * the output Observable is subscribed.
   *
   * @example <caption>Every second, emit the most recent click at most once</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.sampleTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sample}
   * @see {@link throttleTime}
   *
   * @param {number} period The sampling period expressed in milliseconds or the
   * time unit determined internally by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the sampling.
   * @return {Observable<T>} An Observable that emits the results of sampling the
   * values emitted by the source Observable at the specified time interval.
   * @method sampleTime
   * @owner Observable
   */function sampleTime(period,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return sampleTime_1.sampleTime(period,scheduler)(this);}exports.sampleTime=sampleTime;//# sourceMappingURL=sampleTime.js.map
  
  /***/ }),
  /* 374 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var scan_1=__webpack_require__(375);Observable_1.Observable.prototype.scan=scan_1.scan;//# sourceMappingURL=scan.js.map
  
  /***/ }),
  /* 375 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var scan_1=__webpack_require__(52);/* tslint:enable:max-line-length *//**
   * Applies an accumulator function over the source Observable, and returns each
   * intermediate result, with an optional seed value.
   *
   * <span class="informal">It's like {@link reduce}, but emits the current
   * accumulation whenever the source emits a value.</span>
   *
   * <img src="./img/scan.png" width="100%">
   *
   * Combines together all values emitted on the source, using an accumulator
   * function that knows how to join a new source value into the accumulation from
   * the past. Is similar to {@link reduce}, but emits the intermediate
   * accumulations.
   *
   * Returns an Observable that applies a specified `accumulator` function to each
   * item emitted by the source Observable. If a `seed` value is specified, then
   * that value will be used as the initial value for the accumulator. If no seed
   * value is specified, the first item of the source is used as the seed.
   *
   * @example <caption>Count the number of click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var ones = clicks.mapTo(1);
   * var seed = 0;
   * var count = ones.scan((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link reduce}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator
   * The accumulator function called on each source value.
   * @param {T|R} [seed] The initial accumulation value.
   * @return {Observable<R>} An observable of the accumulated values.
   * @method scan
   * @owner Observable
   */function scan(accumulator,seed){if(arguments.length>=2){return scan_1.scan(accumulator,seed)(this);}return scan_1.scan(accumulator)(this);}exports.scan=scan;//# sourceMappingURL=scan.js.map
  
  /***/ }),
  /* 376 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var sequenceEqual_1=__webpack_require__(377);Observable_1.Observable.prototype.sequenceEqual=sequenceEqual_1.sequenceEqual;//# sourceMappingURL=sequenceEqual.js.map
  
  /***/ }),
  /* 377 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var sequenceEqual_1=__webpack_require__(126);/**
   * Compares all values of two observables in sequence using an optional comparor function
   * and returns an observable of a single boolean value representing whether or not the two sequences
   * are equal.
   *
   * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
   *
   * <img src="./img/sequenceEqual.png" width="100%">
   *
   * `sequenceEqual` subscribes to two observables and buffers incoming values from each observable. Whenever either
   * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
   * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
   * observables completes, the operator will wait for the other observable to complete; If the other
   * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
   * completes or emits after the other complets, the returned observable will never complete.
   *
   * @example <caption>figure out if the Konami code matches</caption>
   * var code = Rx.Observable.from([
   *  "ArrowUp",
   *  "ArrowUp",
   *  "ArrowDown",
   *  "ArrowDown",
   *  "ArrowLeft",
   *  "ArrowRight",
   *  "ArrowLeft",
   *  "ArrowRight",
   *  "KeyB",
   *  "KeyA",
   *  "Enter" // no start key, clearly.
   * ]);
   *
   * var keys = Rx.Observable.fromEvent(document, 'keyup')
   *  .map(e => e.code);
   * var matches = keys.bufferCount(11, 1)
   *  .mergeMap(
   *    last11 =>
   *      Rx.Observable.from(last11)
   *        .sequenceEqual(code)
   *   );
   * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
   *
   * @see {@link combineLatest}
   * @see {@link zip}
   * @see {@link withLatestFrom}
   *
   * @param {Observable} compareTo The observable sequence to compare the source sequence to.
   * @param {function} [comparor] An optional function to compare each value pair
   * @return {Observable} An Observable of a single boolean value representing whether or not
   * the values emitted by both observables were equal in sequence.
   * @method sequenceEqual
   * @owner Observable
   */function sequenceEqual(compareTo,comparor){return sequenceEqual_1.sequenceEqual(compareTo,comparor)(this);}exports.sequenceEqual=sequenceEqual;//# sourceMappingURL=sequenceEqual.js.map
  
  /***/ }),
  /* 378 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var share_1=__webpack_require__(379);Observable_1.Observable.prototype.share=share_1.share;//# sourceMappingURL=share.js.map
  
  /***/ }),
  /* 379 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var share_1=__webpack_require__(127);/**
   * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one
   * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will
   * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.
   *
   * This behaves similarly to .publish().refCount(), with a behavior difference when the source observable emits complete.
   * .publish().refCount() will not resubscribe to the original source, however .share() will resubscribe to the original source.
   * Observable.of("test").publish().refCount() will not re-emit "test" on new subscriptions, Observable.of("test").share() will
   * re-emit "test" to new subscriptions.
   *
   * <img src="./img/share.png" width="100%">
   *
   * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.
   * @method share
   * @owner Observable
   */function share(){return share_1.share()(this);}exports.share=share;;//# sourceMappingURL=share.js.map
  
  /***/ }),
  /* 380 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var shareReplay_1=__webpack_require__(381);Observable_1.Observable.prototype.shareReplay=shareReplay_1.shareReplay;//# sourceMappingURL=shareReplay.js.map
  
  /***/ }),
  /* 381 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var shareReplay_1=__webpack_require__(128);/**
   * @method shareReplay
   * @owner Observable
   */function shareReplay(bufferSize,windowTime,scheduler){return shareReplay_1.shareReplay(bufferSize,windowTime,scheduler)(this);}exports.shareReplay=shareReplay;;//# sourceMappingURL=shareReplay.js.map
  
  /***/ }),
  /* 382 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var single_1=__webpack_require__(383);Observable_1.Observable.prototype.single=single_1.single;//# sourceMappingURL=single.js.map
  
  /***/ }),
  /* 383 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var single_1=__webpack_require__(129);/**
   * Returns an Observable that emits the single item emitted by the source Observable that matches a specified
   * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no
   * such items, notify of an IllegalArgumentException or NoSuchElementException respectively.
   *
   * <img src="./img/single.png" width="100%">
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits the single item emitted by the source Observable that matches
   * the predicate.
   .
   * @method single
   * @owner Observable
   */function single(predicate){return single_1.single(predicate)(this);}exports.single=single;//# sourceMappingURL=single.js.map
  
  /***/ }),
  /* 384 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var skip_1=__webpack_require__(385);Observable_1.Observable.prototype.skip=skip_1.skip;//# sourceMappingURL=skip.js.map
  
  /***/ }),
  /* 385 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var skip_1=__webpack_require__(130);/**
   * Returns an Observable that skips the first `count` items emitted by the source Observable.
   *
   * <img src="./img/skip.png" width="100%">
   *
   * @param {Number} count - The number of times, items emitted by source Observable should be skipped.
   * @return {Observable} An Observable that skips values emitted by the source Observable.
   *
   * @method skip
   * @owner Observable
   */function skip(count){return skip_1.skip(count)(this);}exports.skip=skip;//# sourceMappingURL=skip.js.map
  
  /***/ }),
  /* 386 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var skipLast_1=__webpack_require__(387);Observable_1.Observable.prototype.skipLast=skipLast_1.skipLast;//# sourceMappingURL=skipLast.js.map
  
  /***/ }),
  /* 387 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var skipLast_1=__webpack_require__(131);/**
   * Skip the last `count` values emitted by the source Observable.
   *
   * <img src="./img/skipLast.png" width="100%">
   *
   * `skipLast` returns an Observable that accumulates a queue with a length
   * enough to store the first `count` values. As more values are received,
   * values are taken from the front of the queue and produced on the result
   * sequence. This causes values to be delayed.
   *
   * @example <caption>Skip the last 2 values of an Observable with many values</caption>
   * var many = Rx.Observable.range(1, 5);
   * var skipLastTwo = many.skipLast(2);
   * skipLastTwo.subscribe(x => console.log(x));
   *
   * // Results in:
   * // 1 2 3
   *
   * @see {@link skip}
   * @see {@link skipUntil}
   * @see {@link skipWhile}
   * @see {@link take}
   *
   * @throws {ArgumentOutOfRangeError} When using `skipLast(i)`, it throws
   * ArgumentOutOrRangeError if `i < 0`.
   *
   * @param {number} count Number of elements to skip from the end of the source Observable.
   * @returns {Observable<T>} An Observable that skips the last count values
   * emitted by the source Observable.
   * @method skipLast
   * @owner Observable
   */function skipLast(count){return skipLast_1.skipLast(count)(this);}exports.skipLast=skipLast;//# sourceMappingURL=skipLast.js.map
  
  /***/ }),
  /* 388 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var skipUntil_1=__webpack_require__(389);Observable_1.Observable.prototype.skipUntil=skipUntil_1.skipUntil;//# sourceMappingURL=skipUntil.js.map
  
  /***/ }),
  /* 389 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var skipUntil_1=__webpack_require__(132);/**
   * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
   *
   * <img src="./img/skipUntil.png" width="100%">
   *
   * @param {Observable} notifier - The second Observable that has to emit an item before the source Observable's elements begin to
   * be mirrored by the resulting Observable.
   * @return {Observable<T>} An Observable that skips items from the source Observable until the second Observable emits
   * an item, then emits the remaining items.
   * @method skipUntil
   * @owner Observable
   */function skipUntil(notifier){return skipUntil_1.skipUntil(notifier)(this);}exports.skipUntil=skipUntil;//# sourceMappingURL=skipUntil.js.map
  
  /***/ }),
  /* 390 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var skipWhile_1=__webpack_require__(391);Observable_1.Observable.prototype.skipWhile=skipWhile_1.skipWhile;//# sourceMappingURL=skipWhile.js.map
  
  /***/ }),
  /* 391 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var skipWhile_1=__webpack_require__(133);/**
   * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds
   * true, but emits all further source items as soon as the condition becomes false.
   *
   * <img src="./img/skipWhile.png" width="100%">
   *
   * @param {Function} predicate - A function to test each item emitted from the source Observable.
   * @return {Observable<T>} An Observable that begins emitting items emitted by the source Observable when the
   * specified predicate becomes false.
   * @method skipWhile
   * @owner Observable
   */function skipWhile(predicate){return skipWhile_1.skipWhile(predicate)(this);}exports.skipWhile=skipWhile;//# sourceMappingURL=skipWhile.js.map
  
  /***/ }),
  /* 392 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var startWith_1=__webpack_require__(393);Observable_1.Observable.prototype.startWith=startWith_1.startWith;//# sourceMappingURL=startWith.js.map
  
  /***/ }),
  /* 393 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var startWith_1=__webpack_require__(134);/* tslint:enable:max-line-length *//**
   * Returns an Observable that emits the items you specify as arguments before it begins to emit
   * items emitted by the source Observable.
   *
   * <img src="./img/startWith.png" width="100%">
   *
   * @param {...T} values - Items you want the modified Observable to emit first.
   * @param {Scheduler} [scheduler] - A {@link IScheduler} to use for scheduling
   * the emissions of the `next` notifications.
   * @return {Observable} An Observable that emits the items in the specified Iterable and then emits the items
   * emitted by the source Observable.
   * @method startWith
   * @owner Observable
   */function startWith(){var array=[];for(var _i=0;_i<arguments.length;_i++){array[_i-0]=arguments[_i];}return startWith_1.startWith.apply(void 0,array)(this);}exports.startWith=startWith;//# sourceMappingURL=startWith.js.map
  
  /***/ }),
  /* 394 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var subscribeOn_1=__webpack_require__(395);Observable_1.Observable.prototype.subscribeOn=subscribeOn_1.subscribeOn;//# sourceMappingURL=subscribeOn.js.map
  
  /***/ }),
  /* 395 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var subscribeOn_1=__webpack_require__(396);/**
   * Asynchronously subscribes Observers to this Observable on the specified IScheduler.
   *
   * <img src="./img/subscribeOn.png" width="100%">
   *
   * @param {Scheduler} scheduler - The IScheduler to perform subscription actions on.
   * @return {Observable<T>} The source Observable modified so that its subscriptions happen on the specified IScheduler.
   .
   * @method subscribeOn
   * @owner Observable
   */function subscribeOn(scheduler,delay){if(delay===void 0){delay=0;}return subscribeOn_1.subscribeOn(scheduler,delay)(this);}exports.subscribeOn=subscribeOn;//# sourceMappingURL=subscribeOn.js.map
  
  /***/ }),
  /* 396 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var SubscribeOnObservable_1=__webpack_require__(397);/**
   * Asynchronously subscribes Observers to this Observable on the specified IScheduler.
   *
   * <img src="./img/subscribeOn.png" width="100%">
   *
   * @param {Scheduler} scheduler - The IScheduler to perform subscription actions on.
   * @return {Observable<T>} The source Observable modified so that its subscriptions happen on the specified IScheduler.
   .
   * @method subscribeOn
   * @owner Observable
   */function subscribeOn(scheduler,delay){if(delay===void 0){delay=0;}return function subscribeOnOperatorFunction(source){return source.lift(new SubscribeOnOperator(scheduler,delay));};}exports.subscribeOn=subscribeOn;var SubscribeOnOperator=function(){function SubscribeOnOperator(scheduler,delay){this.scheduler=scheduler;this.delay=delay;}SubscribeOnOperator.prototype.call=function(subscriber,source){return new SubscribeOnObservable_1.SubscribeOnObservable(source,this.delay,this.scheduler).subscribe(subscriber);};return SubscribeOnOperator;}();//# sourceMappingURL=subscribeOn.js.map
  
  /***/ }),
  /* 397 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var asap_1=__webpack_require__(135);var isNumeric_1=__webpack_require__(19);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */var SubscribeOnObservable=function(_super){__extends(SubscribeOnObservable,_super);function SubscribeOnObservable(source,delayTime,scheduler){if(delayTime===void 0){delayTime=0;}if(scheduler===void 0){scheduler=asap_1.asap;}_super.call(this);this.source=source;this.delayTime=delayTime;this.scheduler=scheduler;if(!isNumeric_1.isNumeric(delayTime)||delayTime<0){this.delayTime=0;}if(!scheduler||typeof scheduler.schedule!=='function'){this.scheduler=asap_1.asap;}}SubscribeOnObservable.create=function(source,delay,scheduler){if(delay===void 0){delay=0;}if(scheduler===void 0){scheduler=asap_1.asap;}return new SubscribeOnObservable(source,delay,scheduler);};SubscribeOnObservable.dispatch=function(arg){var source=arg.source,subscriber=arg.subscriber;return this.add(source.subscribe(subscriber));};SubscribeOnObservable.prototype._subscribe=function(subscriber){var delay=this.delayTime;var source=this.source;var scheduler=this.scheduler;return scheduler.schedule(SubscribeOnObservable.dispatch,delay,{source:source,subscriber:subscriber});};return SubscribeOnObservable;}(Observable_1.Observable);exports.SubscribeOnObservable=SubscribeOnObservable;//# sourceMappingURL=SubscribeOnObservable.js.map
  
  /***/ }),
  /* 398 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Immediate_1=__webpack_require__(399);var AsyncAction_1=__webpack_require__(20);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var AsapAction=function(_super){__extends(AsapAction,_super);function AsapAction(scheduler,work){_super.call(this,scheduler,work);this.scheduler=scheduler;this.work=work;}AsapAction.prototype.requestAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If delay is greater than 0, request as an async action.
  if(delay!==null&&delay>0){return _super.prototype.requestAsyncId.call(this,scheduler,id,delay);}// Push the action to the end of the scheduler queue.
  scheduler.actions.push(this);// If a microtask has already been scheduled, don't schedule another
  // one. If a microtask hasn't been scheduled yet, schedule one now. Return
  // the current scheduled microtask id.
  return scheduler.scheduled||(scheduler.scheduled=Immediate_1.Immediate.setImmediate(scheduler.flush.bind(scheduler,null)));};AsapAction.prototype.recycleAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If delay exists and is greater than 0, or if the delay is null (the
  // action wasn't rescheduled) but was originally scheduled as an async
  // action, then recycle as an async action.
  if(delay!==null&&delay>0||delay===null&&this.delay>0){return _super.prototype.recycleAsyncId.call(this,scheduler,id,delay);}// If the scheduler queue is empty, cancel the requested microtask and
  // set the scheduled flag to undefined so the next AsapAction will schedule
  // its own.
  if(scheduler.actions.length===0){Immediate_1.Immediate.clearImmediate(id);scheduler.scheduled=undefined;}// Return undefined so the action knows to request a new async id if it's rescheduled.
  return undefined;};return AsapAction;}(AsyncAction_1.AsyncAction);exports.AsapAction=AsapAction;//# sourceMappingURL=AsapAction.js.map
  
  /***/ }),
  /* 399 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(clearImmediate, setImmediate) {/**
  Some credit for this helper goes to http://github.com/YuzuJS/setImmediate
  */var root_1=__webpack_require__(9);var ImmediateDefinition=function(){function ImmediateDefinition(root){this.root=root;if(root.setImmediate&&typeof root.setImmediate==='function'){this.setImmediate=root.setImmediate.bind(root);this.clearImmediate=root.clearImmediate.bind(root);}else{this.nextHandle=1;this.tasksByHandle={};this.currentlyRunningATask=false;// Don't get fooled by e.g. browserify environments.
  if(this.canUseProcessNextTick()){// For Node.js before 0.9
  this.setImmediate=this.createProcessNextTickSetImmediate();}else if(this.canUsePostMessage()){// For non-IE10 modern browsers
  this.setImmediate=this.createPostMessageSetImmediate();}else if(this.canUseMessageChannel()){// For web workers, where supported
  this.setImmediate=this.createMessageChannelSetImmediate();}else if(this.canUseReadyStateChange()){// For IE 6–8
  this.setImmediate=this.createReadyStateChangeSetImmediate();}else{// For older browsers
  this.setImmediate=this.createSetTimeoutSetImmediate();}var ci=function clearImmediate(handle){delete clearImmediate.instance.tasksByHandle[handle];};ci.instance=this;this.clearImmediate=ci;}}ImmediateDefinition.prototype.identify=function(o){return this.root.Object.prototype.toString.call(o);};ImmediateDefinition.prototype.canUseProcessNextTick=function(){return this.identify(this.root.process)==='[object process]';};ImmediateDefinition.prototype.canUseMessageChannel=function(){return Boolean(this.root.MessageChannel);};ImmediateDefinition.prototype.canUseReadyStateChange=function(){var document=this.root.document;return Boolean(document&&'onreadystatechange'in document.createElement('script'));};ImmediateDefinition.prototype.canUsePostMessage=function(){var root=this.root;// The test against `importScripts` prevents this implementation from being installed inside a web worker,
  // where `root.postMessage` means something completely different and can't be used for this purpose.
  if(root.postMessage&&!root.importScripts){var postMessageIsAsynchronous_1=true;var oldOnMessage=root.onmessage;root.onmessage=function(){postMessageIsAsynchronous_1=false;};root.postMessage('','*');root.onmessage=oldOnMessage;return postMessageIsAsynchronous_1;}return false;};// This function accepts the same arguments as setImmediate, but
  // returns a function that requires no arguments.
  ImmediateDefinition.prototype.partiallyApplied=function(handler){var args=[];for(var _i=1;_i<arguments.length;_i++){args[_i-1]=arguments[_i];}var fn=function result(){var _a=result,handler=_a.handler,args=_a.args;if(typeof handler==='function'){handler.apply(undefined,args);}else{new Function(''+handler)();}};fn.handler=handler;fn.args=args;return fn;};ImmediateDefinition.prototype.addFromSetImmediateArguments=function(args){this.tasksByHandle[this.nextHandle]=this.partiallyApplied.apply(undefined,args);return this.nextHandle++;};ImmediateDefinition.prototype.createProcessNextTickSetImmediate=function(){var fn=function setImmediate(){var instance=setImmediate.instance;var handle=instance.addFromSetImmediateArguments(arguments);instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent,handle));return handle;};fn.instance=this;return fn;};ImmediateDefinition.prototype.createPostMessageSetImmediate=function(){// Installs an event handler on `global` for the `message` event: see
  // * https://developer.mozilla.org/en/DOM/window.postMessage
  // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
  var root=this.root;var messagePrefix='setImmediate$'+root.Math.random()+'$';var onGlobalMessage=function globalMessageHandler(event){var instance=globalMessageHandler.instance;if(event.source===root&&typeof event.data==='string'&&event.data.indexOf(messagePrefix)===0){instance.runIfPresent(+event.data.slice(messagePrefix.length));}};onGlobalMessage.instance=this;root.addEventListener('message',onGlobalMessage,false);var fn=function setImmediate(){var _a=setImmediate,messagePrefix=_a.messagePrefix,instance=_a.instance;var handle=instance.addFromSetImmediateArguments(arguments);instance.root.postMessage(messagePrefix+handle,'*');return handle;};fn.instance=this;fn.messagePrefix=messagePrefix;return fn;};ImmediateDefinition.prototype.runIfPresent=function(handle){// From the spec: 'Wait until any invocations of this algorithm started before this one have completed.'
  // So if we're currently running a task, we'll need to delay this invocation.
  if(this.currentlyRunningATask){// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
  // 'too much recursion' error.
  this.root.setTimeout(this.partiallyApplied(this.runIfPresent,handle),0);}else{var task=this.tasksByHandle[handle];if(task){this.currentlyRunningATask=true;try{task();}finally{this.clearImmediate(handle);this.currentlyRunningATask=false;}}}};ImmediateDefinition.prototype.createMessageChannelSetImmediate=function(){var _this=this;var channel=new this.root.MessageChannel();channel.port1.onmessage=function(event){var handle=event.data;_this.runIfPresent(handle);};var fn=function setImmediate(){var _a=setImmediate,channel=_a.channel,instance=_a.instance;var handle=instance.addFromSetImmediateArguments(arguments);channel.port2.postMessage(handle);return handle;};fn.channel=channel;fn.instance=this;return fn;};ImmediateDefinition.prototype.createReadyStateChangeSetImmediate=function(){var fn=function setImmediate(){var instance=setImmediate.instance;var root=instance.root;var doc=root.document;var html=doc.documentElement;var handle=instance.addFromSetImmediateArguments(arguments);// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
  // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
  var script=doc.createElement('script');script.onreadystatechange=function(){instance.runIfPresent(handle);script.onreadystatechange=null;html.removeChild(script);script=null;};html.appendChild(script);return handle;};fn.instance=this;return fn;};ImmediateDefinition.prototype.createSetTimeoutSetImmediate=function(){var fn=function setImmediate(){var instance=setImmediate.instance;var handle=instance.addFromSetImmediateArguments(arguments);instance.root.setTimeout(instance.partiallyApplied(instance.runIfPresent,handle),0);return handle;};fn.instance=this;return fn;};return ImmediateDefinition;}();exports.ImmediateDefinition=ImmediateDefinition;exports.Immediate=new ImmediateDefinition(root_1.root);//# sourceMappingURL=Immediate.js.map
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(136).clearImmediate, __webpack_require__(136).setImmediate))
  
  /***/ }),
  /* 400 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(global, process) {(function(global,undefined){"use strict";if(global.setImmediate){return;}var nextHandle=1;// Spec says greater than zero
  var tasksByHandle={};var currentlyRunningATask=false;var doc=global.document;var registerImmediate;function setImmediate(callback){// Callback can either be a function or a string
  if(typeof callback!=="function"){callback=new Function(""+callback);}// Copy function arguments
  var args=new Array(arguments.length-1);for(var i=0;i<args.length;i++){args[i]=arguments[i+1];}// Store and register the task
  var task={callback:callback,args:args};tasksByHandle[nextHandle]=task;registerImmediate(nextHandle);return nextHandle++;}function clearImmediate(handle){delete tasksByHandle[handle];}function run(task){var callback=task.callback;var args=task.args;switch(args.length){case 0:callback();break;case 1:callback(args[0]);break;case 2:callback(args[0],args[1]);break;case 3:callback(args[0],args[1],args[2]);break;default:callback.apply(undefined,args);break;}}function runIfPresent(handle){// From the spec: "Wait until any invocations of this algorithm started before this one have completed."
  // So if we're currently running a task, we'll need to delay this invocation.
  if(currentlyRunningATask){// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
  // "too much recursion" error.
  setTimeout(runIfPresent,0,handle);}else{var task=tasksByHandle[handle];if(task){currentlyRunningATask=true;try{run(task);}finally{clearImmediate(handle);currentlyRunningATask=false;}}}}function installNextTickImplementation(){registerImmediate=function registerImmediate(handle){process.nextTick(function(){runIfPresent(handle);});};}function canUsePostMessage(){// The test against `importScripts` prevents this implementation from being installed inside a web worker,
  // where `global.postMessage` means something completely different and can't be used for this purpose.
  if(global.postMessage&&!global.importScripts){var postMessageIsAsynchronous=true;var oldOnMessage=global.onmessage;global.onmessage=function(){postMessageIsAsynchronous=false;};global.postMessage("","*");global.onmessage=oldOnMessage;return postMessageIsAsynchronous;}}function installPostMessageImplementation(){// Installs an event handler on `global` for the `message` event: see
  // * https://developer.mozilla.org/en/DOM/window.postMessage
  // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
  var messagePrefix="setImmediate$"+Math.random()+"$";var onGlobalMessage=function onGlobalMessage(event){if(event.source===global&&typeof event.data==="string"&&event.data.indexOf(messagePrefix)===0){runIfPresent(+event.data.slice(messagePrefix.length));}};if(global.addEventListener){global.addEventListener("message",onGlobalMessage,false);}else{global.attachEvent("onmessage",onGlobalMessage);}registerImmediate=function registerImmediate(handle){global.postMessage(messagePrefix+handle,"*");};}function installMessageChannelImplementation(){var channel=new MessageChannel();channel.port1.onmessage=function(event){var handle=event.data;runIfPresent(handle);};registerImmediate=function registerImmediate(handle){channel.port2.postMessage(handle);};}function installReadyStateChangeImplementation(){var html=doc.documentElement;registerImmediate=function registerImmediate(handle){// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
  // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
  var script=doc.createElement("script");script.onreadystatechange=function(){runIfPresent(handle);script.onreadystatechange=null;html.removeChild(script);script=null;};html.appendChild(script);};}function installSetTimeoutImplementation(){registerImmediate=function registerImmediate(handle){setTimeout(runIfPresent,0,handle);};}// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
  var attachTo=Object.getPrototypeOf&&Object.getPrototypeOf(global);attachTo=attachTo&&attachTo.setTimeout?attachTo:global;// Don't get fooled by e.g. browserify environments.
  if({}.toString.call(global.process)==="[object process]"){// For Node.js before 0.9
  installNextTickImplementation();}else if(canUsePostMessage()){// For non-IE10 modern browsers
  installPostMessageImplementation();}else if(global.MessageChannel){// For web workers, where supported
  installMessageChannelImplementation();}else if(doc&&"onreadystatechange"in doc.createElement("script")){// For IE 6–8
  installReadyStateChangeImplementation();}else{// For older browsers
  installSetTimeoutImplementation();}attachTo.setImmediate=setImmediate;attachTo.clearImmediate=clearImmediate;})(typeof self==="undefined"?typeof global==="undefined"?undefined:global:self);
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(57), __webpack_require__(401)))
  
  /***/ }),
  /* 401 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // shim for using process in browser
  var process=module.exports={};// cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  var cachedSetTimeout;var cachedClearTimeout;function defaultSetTimout(){throw new Error('setTimeout has not been defined');}function defaultClearTimeout(){throw new Error('clearTimeout has not been defined');}(function(){try{if(typeof setTimeout==='function'){cachedSetTimeout=setTimeout;}else{cachedSetTimeout=defaultSetTimout;}}catch(e){cachedSetTimeout=defaultSetTimout;}try{if(typeof clearTimeout==='function'){cachedClearTimeout=clearTimeout;}else{cachedClearTimeout=defaultClearTimeout;}}catch(e){cachedClearTimeout=defaultClearTimeout;}})();function runTimeout(fun){if(cachedSetTimeout===setTimeout){//normal enviroments in sane situations
  return setTimeout(fun,0);}// if setTimeout wasn't available but was latter defined
  if((cachedSetTimeout===defaultSetTimout||!cachedSetTimeout)&&setTimeout){cachedSetTimeout=setTimeout;return setTimeout(fun,0);}try{// when when somebody has screwed with setTimeout but no I.E. maddness
  return cachedSetTimeout(fun,0);}catch(e){try{// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  return cachedSetTimeout.call(null,fun,0);}catch(e){// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  return cachedSetTimeout.call(this,fun,0);}}}function runClearTimeout(marker){if(cachedClearTimeout===clearTimeout){//normal enviroments in sane situations
  return clearTimeout(marker);}// if clearTimeout wasn't available but was latter defined
  if((cachedClearTimeout===defaultClearTimeout||!cachedClearTimeout)&&clearTimeout){cachedClearTimeout=clearTimeout;return clearTimeout(marker);}try{// when when somebody has screwed with setTimeout but no I.E. maddness
  return cachedClearTimeout(marker);}catch(e){try{// When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  return cachedClearTimeout.call(null,marker);}catch(e){// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  return cachedClearTimeout.call(this,marker);}}}var queue=[];var draining=false;var currentQueue;var queueIndex=-1;function cleanUpNextTick(){if(!draining||!currentQueue){return;}draining=false;if(currentQueue.length){queue=currentQueue.concat(queue);}else{queueIndex=-1;}if(queue.length){drainQueue();}}function drainQueue(){if(draining){return;}var timeout=runTimeout(cleanUpNextTick);draining=true;var len=queue.length;while(len){currentQueue=queue;queue=[];while(++queueIndex<len){if(currentQueue){currentQueue[queueIndex].run();}}queueIndex=-1;len=queue.length;}currentQueue=null;draining=false;runClearTimeout(timeout);}process.nextTick=function(fun){var args=new Array(arguments.length-1);if(arguments.length>1){for(var i=1;i<arguments.length;i++){args[i-1]=arguments[i];}}queue.push(new Item(fun,args));if(queue.length===1&&!draining){runTimeout(drainQueue);}};// v8 likes predictible objects
  function Item(fun,array){this.fun=fun;this.array=array;}Item.prototype.run=function(){this.fun.apply(null,this.array);};process.title='browser';process.browser=true;process.env={};process.argv=[];process.version='';// empty string to avoid regexp issues
  process.versions={};function noop(){}process.on=noop;process.addListener=noop;process.once=noop;process.off=noop;process.removeListener=noop;process.removeAllListeners=noop;process.emit=noop;process.prependListener=noop;process.prependOnceListener=noop;process.listeners=function(name){return[];};process.binding=function(name){throw new Error('process.binding is not supported');};process.cwd=function(){return'/';};process.chdir=function(dir){throw new Error('process.chdir is not supported');};process.umask=function(){return 0;};
  
  /***/ }),
  /* 402 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncScheduler_1=__webpack_require__(21);var AsapScheduler=function(_super){__extends(AsapScheduler,_super);function AsapScheduler(){_super.apply(this,arguments);}AsapScheduler.prototype.flush=function(action){this.active=true;this.scheduled=undefined;var actions=this.actions;var error;var index=-1;var count=actions.length;action=action||actions.shift();do{if(error=action.execute(action.state,action.delay)){break;}}while(++index<count&&(action=actions.shift()));this.active=false;if(error){while(++index<count&&(action=actions.shift())){action.unsubscribe();}throw error;}};return AsapScheduler;}(AsyncScheduler_1.AsyncScheduler);exports.AsapScheduler=AsapScheduler;//# sourceMappingURL=AsapScheduler.js.map
  
  /***/ }),
  /* 403 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var switch_1=__webpack_require__(404);Observable_1.Observable.prototype.switch=switch_1._switch;Observable_1.Observable.prototype._switch=switch_1._switch;//# sourceMappingURL=switch.js.map
  
  /***/ }),
  /* 404 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var switchAll_1=__webpack_require__(137);/**
   * Converts a higher-order Observable into a first-order Observable by
   * subscribing to only the most recently emitted of those inner Observables.
   *
   * <span class="informal">Flattens an Observable-of-Observables by dropping the
   * previous inner Observable once a new one appears.</span>
   *
   * <img src="./img/switch.png" width="100%">
   *
   * `switch` subscribes to an Observable that emits Observables, also known as a
   * higher-order Observable. Each time it observes one of these emitted inner
   * Observables, the output Observable subscribes to the inner Observable and
   * begins emitting the items emitted by that. So far, it behaves
   * like {@link mergeAll}. However, when a new inner Observable is emitted,
   * `switch` unsubscribes from the earlier-emitted inner Observable and
   * subscribes to the new inner Observable and begins emitting items from it. It
   * continues to behave like this for subsequent inner Observables.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * // Each click event is mapped to an Observable that ticks every second
   * var higherOrder = clicks.map((ev) => Rx.Observable.interval(1000));
   * var switched = higherOrder.switch();
   * // The outcome is that `switched` is essentially a timer that restarts
   * // on every click. The interval Observables from older clicks do not merge
   * // with the current interval Observable.
   * switched.subscribe(x => console.log(x));
   *
   * @see {@link combineAll}
   * @see {@link concatAll}
   * @see {@link exhaust}
   * @see {@link mergeAll}
   * @see {@link switchMap}
   * @see {@link switchMapTo}
   * @see {@link zipAll}
   *
   * @return {Observable<T>} An Observable that emits the items emitted by the
   * Observable most recently emitted by the source Observable.
   * @method switch
   * @name switch
   * @owner Observable
   */function _switch(){return switchAll_1.switchAll()(this);}exports._switch=_switch;//# sourceMappingURL=switch.js.map
  
  /***/ }),
  /* 405 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var switchMap_1=__webpack_require__(406);Observable_1.Observable.prototype.switchMap=switchMap_1.switchMap;//# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  /* 406 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var switchMap_1=__webpack_require__(55);/* tslint:enable:max-line-length *//**
   * Projects each source value to an Observable which is merged in the output
   * Observable, emitting values only from the most recently projected Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link switch}.</span>
   *
   * <img src="./img/switchMap.png" width="100%">
   *
   * Returns an Observable that emits items based on applying a function that you
   * supply to each item emitted by the source Observable, where that function
   * returns an (so-called "inner") Observable. Each time it observes one of these
   * inner Observables, the output Observable begins emitting the items emitted by
   * that inner Observable. When a new inner Observable is emitted, `switchMap`
   * stops emitting items from the earlier-emitted inner Observable and begins
   * emitting items from the new one. It continues to behave like this for
   * subsequent inner Observables.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switch}
   * @see {@link switchMapTo}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking only the values from the most recently
   * projected inner Observable.
   * @method switchMap
   * @owner Observable
   */function switchMap(project,resultSelector){return switchMap_1.switchMap(project,resultSelector)(this);}exports.switchMap=switchMap;//# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  /* 407 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var switchMapTo_1=__webpack_require__(408);Observable_1.Observable.prototype.switchMapTo=switchMapTo_1.switchMapTo;//# sourceMappingURL=switchMapTo.js.map
  
  /***/ }),
  /* 408 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var switchMapTo_1=__webpack_require__(138);/* tslint:enable:max-line-length *//**
   * Projects each source value to the same Observable which is flattened multiple
   * times with {@link switch} in the output Observable.
   *
   * <span class="informal">It's like {@link switchMap}, but maps each value
   * always to the same inner Observable.</span>
   *
   * <img src="./img/switchMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then flattens those resulting Observables into one
   * single Observable, which is the output Observable. The output Observables
   * emits values only from the most recently emitted instance of
   * `innerObservable`.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMapTo(Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMapTo}
   * @see {@link switch}
   * @see {@link switchMap}
   * @see {@link mergeMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable, and taking only the values
   * from the most recently projected inner Observable.
   * @method switchMapTo
   * @owner Observable
   */function switchMapTo(innerObservable,resultSelector){return switchMapTo_1.switchMapTo(innerObservable,resultSelector)(this);}exports.switchMapTo=switchMapTo;//# sourceMappingURL=switchMapTo.js.map
  
  /***/ }),
  /* 409 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var take_1=__webpack_require__(410);Observable_1.Observable.prototype.take=take_1.take;//# sourceMappingURL=take.js.map
  
  /***/ }),
  /* 410 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var take_1=__webpack_require__(139);/**
   * Emits only the first `count` values emitted by the source Observable.
   *
   * <span class="informal">Takes the first `count` values from the source, then
   * completes.</span>
   *
   * <img src="./img/take.png" width="100%">
   *
   * `take` returns an Observable that emits only the first `count` values emitted
   * by the source Observable. If the source emits fewer than `count` values then
   * all of its values are emitted. After that, it completes, regardless if the
   * source completes.
   *
   * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>
   * var interval = Rx.Observable.interval(1000);
   * var five = interval.take(5);
   * five.subscribe(x => console.log(x));
   *
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of `next` values to emit.
   * @return {Observable<T>} An Observable that emits only the first `count`
   * values emitted by the source Observable, or all of the values from the source
   * if the source emits fewer than `count` values.
   * @method take
   * @owner Observable
   */function take(count){return take_1.take(count)(this);}exports.take=take;//# sourceMappingURL=take.js.map
  
  /***/ }),
  /* 411 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var takeLast_1=__webpack_require__(412);Observable_1.Observable.prototype.takeLast=takeLast_1.takeLast;//# sourceMappingURL=takeLast.js.map
  
  /***/ }),
  /* 412 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var takeLast_1=__webpack_require__(53);/**
   * Emits only the last `count` values emitted by the source Observable.
   *
   * <span class="informal">Remembers the latest `count` values, then emits those
   * only when the source completes.</span>
   *
   * <img src="./img/takeLast.png" width="100%">
   *
   * `takeLast` returns an Observable that emits at most the last `count` values
   * emitted by the source Observable. If the source emits fewer than `count`
   * values then all of its values are emitted. This operator must wait until the
   * `complete` notification emission from the source in order to emit the `next`
   * values on the output Observable, because otherwise it is impossible to know
   * whether or not more values will be emitted on the source. For this reason,
   * all values are emitted synchronously, followed by the complete notification.
   *
   * @example <caption>Take the last 3 values of an Observable with many values</caption>
   * var many = Rx.Observable.range(1, 100);
   * var lastThree = many.takeLast(3);
   * lastThree.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `takeLast(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of values to emit from the end of
   * the sequence of values emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits at most the last count
   * values emitted by the source Observable.
   * @method takeLast
   * @owner Observable
   */function takeLast(count){return takeLast_1.takeLast(count)(this);}exports.takeLast=takeLast;//# sourceMappingURL=takeLast.js.map
  
  /***/ }),
  /* 413 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var takeUntil_1=__webpack_require__(414);Observable_1.Observable.prototype.takeUntil=takeUntil_1.takeUntil;//# sourceMappingURL=takeUntil.js.map
  
  /***/ }),
  /* 414 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var takeUntil_1=__webpack_require__(140);/**
   * Emits the values emitted by the source Observable until a `notifier`
   * Observable emits a value.
   *
   * <span class="informal">Lets values pass until a second Observable,
   * `notifier`, emits something. Then, it completes.</span>
   *
   * <img src="./img/takeUntil.png" width="100%">
   *
   * `takeUntil` subscribes and begins mirroring the source Observable. It also
   * monitors a second Observable, `notifier` that you provide. If the `notifier`
   * emits a value, the output Observable stops mirroring the source Observable
   * and completes.
   *
   * @example <caption>Tick every second until the first click happens</caption>
   * var interval = Rx.Observable.interval(1000);
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = interval.takeUntil(clicks);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeLast}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @param {Observable} notifier The Observable whose first emitted value will
   * cause the output Observable of `takeUntil` to stop emitting values from the
   * source Observable.
   * @return {Observable<T>} An Observable that emits the values from the source
   * Observable until such time as `notifier` emits its first value.
   * @method takeUntil
   * @owner Observable
   */function takeUntil(notifier){return takeUntil_1.takeUntil(notifier)(this);}exports.takeUntil=takeUntil;//# sourceMappingURL=takeUntil.js.map
  
  /***/ }),
  /* 415 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var takeWhile_1=__webpack_require__(416);Observable_1.Observable.prototype.takeWhile=takeWhile_1.takeWhile;//# sourceMappingURL=takeWhile.js.map
  
  /***/ }),
  /* 416 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var takeWhile_1=__webpack_require__(141);/**
   * Emits values emitted by the source Observable so long as each value satisfies
   * the given `predicate`, and then completes as soon as this `predicate` is not
   * satisfied.
   *
   * <span class="informal">Takes values from the source only while they pass the
   * condition given. When the first value does not satisfy, it completes.</span>
   *
   * <img src="./img/takeWhile.png" width="100%">
   *
   * `takeWhile` subscribes and begins mirroring the source Observable. Each value
   * emitted on the source is given to the `predicate` function which returns a
   * boolean, representing a condition to be satisfied by the source values. The
   * output Observable emits the source values until such time as the `predicate`
   * returns false, at which point `takeWhile` stops mirroring the source
   * Observable and completes the output Observable.
   *
   * @example <caption>Emit click events only while the clientX property is greater than 200</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.takeWhile(ev => ev.clientX > 200);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link skip}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates a value emitted by the source Observable and returns a boolean.
   * Also takes the (zero-based) index as the second argument.
   * @return {Observable<T>} An Observable that emits the values from the source
   * Observable so long as each value satisfies the condition defined by the
   * `predicate`, then completes.
   * @method takeWhile
   * @owner Observable
   */function takeWhile(predicate){return takeWhile_1.takeWhile(predicate)(this);}exports.takeWhile=takeWhile;//# sourceMappingURL=takeWhile.js.map
  
  /***/ }),
  /* 417 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var throttle_1=__webpack_require__(418);Observable_1.Observable.prototype.throttle=throttle_1.throttle;//# sourceMappingURL=throttle.js.map
  
  /***/ }),
  /* 418 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var throttle_1=__webpack_require__(38);/**
   * Emits a value from the source Observable, then ignores subsequent source
   * values for a duration determined by another Observable, then repeats this
   * process.
   *
   * <span class="informal">It's like {@link throttleTime}, but the silencing
   * duration is determined by a second Observable.</span>
   *
   * <img src="./img/throttle.png" width="100%">
   *
   * `throttle` emits the source Observable values on the output Observable
   * when its internal timer is disabled, and ignores source values when the timer
   * is enabled. Initially, the timer is disabled. As soon as the first source
   * value arrives, it is forwarded to the output Observable, and then the timer
   * is enabled by calling the `durationSelector` function with the source value,
   * which returns the "duration" Observable. When the duration Observable emits a
   * value or completes, the timer is disabled, and this process repeats for the
   * next source value.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.throttle(ev => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link audit}
   * @see {@link debounce}
   * @see {@link delayWhen}
   * @see {@link sample}
   * @see {@link throttleTime}
   *
   * @param {function(value: T): SubscribableOrPromise} durationSelector A function
   * that receives a value from the source Observable, for computing the silencing
   * duration for each source value, returned as an Observable or a Promise.
   * @param {Object} config a configuration object to define `leading` and `trailing` behavior. Defaults
   * to `{ leading: true, trailing: false }`.
   * @return {Observable<T>} An Observable that performs the throttle operation to
   * limit the rate of emissions from the source.
   * @method throttle
   * @owner Observable
   */function throttle(durationSelector,config){if(config===void 0){config=throttle_1.defaultThrottleConfig;}return throttle_1.throttle(durationSelector,config)(this);}exports.throttle=throttle;//# sourceMappingURL=throttle.js.map
  
  /***/ }),
  /* 419 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var throttleTime_1=__webpack_require__(420);Observable_1.Observable.prototype.throttleTime=throttleTime_1.throttleTime;//# sourceMappingURL=throttleTime.js.map
  
  /***/ }),
  /* 420 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var throttle_1=__webpack_require__(38);var throttleTime_1=__webpack_require__(142);/**
   * Emits a value from the source Observable, then ignores subsequent source
   * values for `duration` milliseconds, then repeats this process.
   *
   * <span class="informal">Lets a value pass, then ignores source values for the
   * next `duration` milliseconds.</span>
   *
   * <img src="./img/throttleTime.png" width="100%">
   *
   * `throttleTime` emits the source Observable values on the output Observable
   * when its internal timer is disabled, and ignores source values when the timer
   * is enabled. Initially, the timer is disabled. As soon as the first source
   * value arrives, it is forwarded to the output Observable, and then the timer
   * is enabled. After `duration` milliseconds (or the time unit determined
   * internally by the optional `scheduler`) has passed, the timer is disabled,
   * and this process repeats for the next source value. Optionally takes a
   * {@link IScheduler} for managing timers.
   *
   * @example <caption>Emit clicks at a rate of at most one click per second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.throttleTime(1000);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link auditTime}
   * @see {@link debounceTime}
   * @see {@link delay}
   * @see {@link sampleTime}
   * @see {@link throttle}
   *
   * @param {number} duration Time to wait before emitting another value after
   * emitting the last value, measured in milliseconds or the time unit determined
   * internally by the optional `scheduler`.
   * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for
   * managing the timers that handle the throttling.
   * @return {Observable<T>} An Observable that performs the throttle operation to
   * limit the rate of emissions from the source.
   * @method throttleTime
   * @owner Observable
   */function throttleTime(duration,scheduler,config){if(scheduler===void 0){scheduler=async_1.async;}if(config===void 0){config=throttle_1.defaultThrottleConfig;}return throttleTime_1.throttleTime(duration,scheduler,config)(this);}exports.throttleTime=throttleTime;//# sourceMappingURL=throttleTime.js.map
  
  /***/ }),
  /* 421 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var timeInterval_1=__webpack_require__(143);Observable_1.Observable.prototype.timeInterval=timeInterval_1.timeInterval;//# sourceMappingURL=timeInterval.js.map
  
  /***/ }),
  /* 422 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var timeout_1=__webpack_require__(423);Observable_1.Observable.prototype.timeout=timeout_1.timeout;//# sourceMappingURL=timeout.js.map
  
  /***/ }),
  /* 423 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var timeout_1=__webpack_require__(145);/**
   *
   * Errors if Observable does not emit a value in given time span.
   *
   * <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span>
   *
   * <img src="./img/timeout.png" width="100%">
   *
   * `timeout` operator accepts as an argument either a number or a Date.
   *
   * If number was provided, it returns an Observable that behaves like a source
   * Observable, unless there is a period of time where there is no value emitted.
   * So if you provide `100` as argument and first value comes after 50ms from
   * the moment of subscription, this value will be simply re-emitted by the resulting
   * Observable. If however after that 100ms passes without a second value being emitted,
   * stream will end with an error and source Observable will be unsubscribed.
   * These checks are performed throughout whole lifecycle of Observable - from the moment
   * it was subscribed to, until it completes or errors itself. Thus every value must be
   * emitted within specified period since previous value.
   *
   * If provided argument was Date, returned Observable behaves differently. It throws
   * if Observable did not complete before provided Date. This means that periods between
   * emission of particular values do not matter in this case. If Observable did not complete
   * before provided Date, source Observable will be unsubscribed. Other than that, resulting
   * stream behaves just as source Observable.
   *
   * `timeout` accepts also a Scheduler as a second parameter. It is used to schedule moment (or moments)
   * when returned Observable will check if source stream emitted value or completed.
   *
   * @example <caption>Check if ticks are emitted within certain timespan</caption>
   * const seconds = Rx.Observable.interval(1000);
   *
   * seconds.timeout(1100) // Let's use bigger timespan to be safe,
   *                       // since `interval` might fire a bit later then scheduled.
   * .subscribe(
   *     value => console.log(value), // Will emit numbers just as regular `interval` would.
   *     err => console.log(err) // Will never be called.
   * );
   *
   * seconds.timeout(900).subscribe(
   *     value => console.log(value), // Will never be called.
   *     err => console.log(err) // Will emit error before even first value is emitted,
   *                             // since it did not arrive within 900ms period.
   * );
   *
   * @example <caption>Use Date to check if Observable completed</caption>
   * const seconds = Rx.Observable.interval(1000);
   *
   * seconds.timeout(new Date("December 17, 2020 03:24:00"))
   * .subscribe(
   *     value => console.log(value), // Will emit values as regular `interval` would
   *                                  // until December 17, 2020 at 03:24:00.
   *     err => console.log(err) // On December 17, 2020 at 03:24:00 it will emit an error,
   *                             // since Observable did not complete by then.
   * );
   *
   * @see {@link timeoutWith}
   *
   * @param {number|Date} due Number specifying period within which Observable must emit values
   *                          or Date specifying before when Observable should complete
   * @param {Scheduler} [scheduler] Scheduler controlling when timeout checks occur.
   * @return {Observable<T>} Observable that mirrors behaviour of source, unless timeout checks fail.
   * @method timeout
   * @owner Observable
   */function timeout(due,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return timeout_1.timeout(due,scheduler)(this);}exports.timeout=timeout;//# sourceMappingURL=timeout.js.map
  
  /***/ }),
  /* 424 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var timeoutWith_1=__webpack_require__(425);Observable_1.Observable.prototype.timeoutWith=timeoutWith_1.timeoutWith;//# sourceMappingURL=timeoutWith.js.map
  
  /***/ }),
  /* 425 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var timeoutWith_1=__webpack_require__(147);/* tslint:enable:max-line-length *//**
   *
   * Errors if Observable does not emit a value in given time span, in case of which
   * subscribes to the second Observable.
   *
   * <span class="informal">It's a version of `timeout` operator that let's you specify fallback Observable.</span>
   *
   * <img src="./img/timeoutWith.png" width="100%">
   *
   * `timeoutWith` is a variation of `timeout` operator. It behaves exactly the same,
   * still accepting as a first argument either a number or a Date, which control - respectively -
   * when values of source Observable should be emitted or when it should complete.
   *
   * The only difference is that it accepts a second, required parameter. This parameter
   * should be an Observable which will be subscribed when source Observable fails any timeout check.
   * So whenever regular `timeout` would emit an error, `timeoutWith` will instead start re-emitting
   * values from second Observable. Note that this fallback Observable is not checked for timeouts
   * itself, so it can emit values and complete at arbitrary points in time. From the moment of a second
   * subscription, Observable returned from `timeoutWith` simply mirrors fallback stream. When that
   * stream completes, it completes as well.
   *
   * Scheduler, which in case of `timeout` is provided as as second argument, can be still provided
   * here - as a third, optional parameter. It still is used to schedule timeout checks and -
   * as a consequence - when second Observable will be subscribed, since subscription happens
   * immediately after failing check.
   *
   * @example <caption>Add fallback observable</caption>
   * const seconds = Rx.Observable.interval(1000);
   * const minutes = Rx.Observable.interval(60 * 1000);
   *
   * seconds.timeoutWith(900, minutes)
   *     .subscribe(
   *         value => console.log(value), // After 900ms, will start emitting `minutes`,
   *                                      // since first value of `seconds` will not arrive fast enough.
   *         err => console.log(err) // Would be called after 900ms in case of `timeout`,
   *                                 // but here will never be called.
   *     );
   *
   * @param {number|Date} due Number specifying period within which Observable must emit values
   *                          or Date specifying before when Observable should complete
   * @param {Observable<T>} withObservable Observable which will be subscribed if source fails timeout check.
   * @param {Scheduler} [scheduler] Scheduler controlling when timeout checks occur.
   * @return {Observable<T>} Observable that mirrors behaviour of source or, when timeout check fails, of an Observable
   *                          passed as a second parameter.
   * @method timeoutWith
   * @owner Observable
   */function timeoutWith(due,withObservable,scheduler){if(scheduler===void 0){scheduler=async_1.async;}return timeoutWith_1.timeoutWith(due,withObservable,scheduler)(this);}exports.timeoutWith=timeoutWith;//# sourceMappingURL=timeoutWith.js.map
  
  /***/ }),
  /* 426 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var timestamp_1=__webpack_require__(427);Observable_1.Observable.prototype.timestamp=timestamp_1.timestamp;//# sourceMappingURL=timestamp.js.map
  
  /***/ }),
  /* 427 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var timestamp_1=__webpack_require__(56);/**
   * @param scheduler
   * @return {Observable<Timestamp<any>>|WebSocketSubject<T>|Observable<T>}
   * @method timestamp
   * @owner Observable
   */function timestamp(scheduler){if(scheduler===void 0){scheduler=async_1.async;}return timestamp_1.timestamp(scheduler)(this);}exports.timestamp=timestamp;//# sourceMappingURL=timestamp.js.map
  
  /***/ }),
  /* 428 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var toArray_1=__webpack_require__(429);Observable_1.Observable.prototype.toArray=toArray_1.toArray;//# sourceMappingURL=toArray.js.map
  
  /***/ }),
  /* 429 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var toArray_1=__webpack_require__(148);/**
   * Collects all source emissions and emits them as an array when the source completes.
   *
   * <span class="informal">Get all values inside an array when the source completes</span>
   *
   * <img src="./img/toArray.png" width="100%">
   *
   * `toArray` will wait until the source Observable completes
   * before emitting the array containing all emissions.
   * When the source Observable errors no array will be emitted.
   *
   * @example <caption>Create array from input</caption>
   * const input = Rx.Observable.interval(100).take(4);
   *
   * input.toArray()
   *   .subscribe(arr => console.log(arr)); // [0,1,2,3]
   *
   * @see {@link buffer}
   *
   * @return {Observable<any[]>|WebSocketSubject<T>|Observable<T>}
   * @method toArray
   * @owner Observable
   */function toArray(){return toArray_1.toArray()(this);}exports.toArray=toArray;//# sourceMappingURL=toArray.js.map
  
  /***/ }),
  /* 430 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // HACK: does nothing, because `toPromise` now lives on the `Observable` itself.
  // leaving this module here to prevent breakage.
  //# sourceMappingURL=toPromise.js.map
  
  
  /***/ }),
  /* 431 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var window_1=__webpack_require__(432);Observable_1.Observable.prototype.window=window_1.window;//# sourceMappingURL=window.js.map
  
  /***/ }),
  /* 432 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var window_1=__webpack_require__(149);/**
   * Branch out the source Observable values as a nested Observable whenever
   * `windowBoundaries` emits.
   *
   * <span class="informal">It's like {@link buffer}, but emits a nested Observable
   * instead of an array.</span>
   *
   * <img src="./img/window.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits connected, non-overlapping
   * windows. It emits the current window and opens a new one whenever the
   * Observable `windowBoundaries` emits an item. Because each window is an
   * Observable, the output is a higher-order Observable.
   *
   * @example <caption>In every window of 1 second each, emit at most 2 click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var interval = Rx.Observable.interval(1000);
   * var result = clicks.window(interval)
   *   .map(win => win.take(2)) // each window has at most 2 emissions
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link windowWhen}
   * @see {@link buffer}
   *
   * @param {Observable<any>} windowBoundaries An Observable that completes the
   * previous window and starts a new window.
   * @return {Observable<Observable<T>>} An Observable of windows, which are
   * Observables emitting values of the source Observable.
   * @method window
   * @owner Observable
   */function window(windowBoundaries){return window_1.window(windowBoundaries)(this);}exports.window=window;//# sourceMappingURL=window.js.map
  
  /***/ }),
  /* 433 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var windowCount_1=__webpack_require__(434);Observable_1.Observable.prototype.windowCount=windowCount_1.windowCount;//# sourceMappingURL=windowCount.js.map
  
  /***/ }),
  /* 434 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var windowCount_1=__webpack_require__(150);/**
   * Branch out the source Observable values as a nested Observable with each
   * nested Observable emitting at most `windowSize` values.
   *
   * <span class="informal">It's like {@link bufferCount}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowCount.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits windows every `startWindowEvery`
   * items, each containing no more than `windowSize` items. When the source
   * Observable completes or encounters an error, the output Observable emits
   * the current window and propagates the notification from the source
   * Observable. If `startWindowEvery` is not provided, then new windows are
   * started immediately at the start of the source and when each window completes
   * with size `windowSize`.
   *
   * @example <caption>Ignore every 3rd click event, starting from the first one</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.windowCount(3)
   *   .map(win => win.skip(1)) // skip first of every 3 clicks
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @example <caption>Ignore every 3rd click event, starting from the third one</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.windowCount(2, 3)
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link windowWhen}
   * @see {@link bufferCount}
   *
   * @param {number} windowSize The maximum number of values emitted by each
   * window.
   * @param {number} [startWindowEvery] Interval at which to start a new window.
   * For example if `startWindowEvery` is `2`, then a new window will be started
   * on every other value from the source. A new window is started at the
   * beginning of the source by default.
   * @return {Observable<Observable<T>>} An Observable of windows, which in turn
   * are Observable of values.
   * @method windowCount
   * @owner Observable
   */function windowCount(windowSize,startWindowEvery){if(startWindowEvery===void 0){startWindowEvery=0;}return windowCount_1.windowCount(windowSize,startWindowEvery)(this);}exports.windowCount=windowCount;//# sourceMappingURL=windowCount.js.map
  
  /***/ }),
  /* 435 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var windowTime_1=__webpack_require__(436);Observable_1.Observable.prototype.windowTime=windowTime_1.windowTime;//# sourceMappingURL=windowTime.js.map
  
  /***/ }),
  /* 436 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var async_1=__webpack_require__(4);var isNumeric_1=__webpack_require__(19);var isScheduler_1=__webpack_require__(10);var windowTime_1=__webpack_require__(151);function windowTime(windowTimeSpan){var scheduler=async_1.async;var windowCreationInterval=null;var maxWindowSize=Number.POSITIVE_INFINITY;if(isScheduler_1.isScheduler(arguments[3])){scheduler=arguments[3];}if(isScheduler_1.isScheduler(arguments[2])){scheduler=arguments[2];}else if(isNumeric_1.isNumeric(arguments[2])){maxWindowSize=arguments[2];}if(isScheduler_1.isScheduler(arguments[1])){scheduler=arguments[1];}else if(isNumeric_1.isNumeric(arguments[1])){windowCreationInterval=arguments[1];}return windowTime_1.windowTime(windowTimeSpan,windowCreationInterval,maxWindowSize,scheduler)(this);}exports.windowTime=windowTime;//# sourceMappingURL=windowTime.js.map
  
  /***/ }),
  /* 437 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var windowToggle_1=__webpack_require__(438);Observable_1.Observable.prototype.windowToggle=windowToggle_1.windowToggle;//# sourceMappingURL=windowToggle.js.map
  
  /***/ }),
  /* 438 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var windowToggle_1=__webpack_require__(152);/**
   * Branch out the source Observable values as a nested Observable starting from
   * an emission from `openings` and ending when the output of `closingSelector`
   * emits.
   *
   * <span class="informal">It's like {@link bufferToggle}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowToggle.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits windows that contain those items
   * emitted by the source Observable between the time when the `openings`
   * Observable emits an item and when the Observable returned by
   * `closingSelector` emits an item.
   *
   * @example <caption>Every other second, emit the click events from the next 500ms</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var openings = Rx.Observable.interval(1000);
   * var result = clicks.windowToggle(openings, i =>
   *   i % 2 ? Rx.Observable.interval(500) : Rx.Observable.empty()
   * ).mergeAll();
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowWhen}
   * @see {@link bufferToggle}
   *
   * @param {Observable<O>} openings An observable of notifications to start new
   * windows.
   * @param {function(value: O): Observable} closingSelector A function that takes
   * the value emitted by the `openings` observable and returns an Observable,
   * which, when it emits (either `next` or `complete`), signals that the
   * associated window should complete.
   * @return {Observable<Observable<T>>} An observable of windows, which in turn
   * are Observables.
   * @method windowToggle
   * @owner Observable
   */function windowToggle(openings,closingSelector){return windowToggle_1.windowToggle(openings,closingSelector)(this);}exports.windowToggle=windowToggle;//# sourceMappingURL=windowToggle.js.map
  
  /***/ }),
  /* 439 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var windowWhen_1=__webpack_require__(440);Observable_1.Observable.prototype.windowWhen=windowWhen_1.windowWhen;//# sourceMappingURL=windowWhen.js.map
  
  /***/ }),
  /* 440 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var windowWhen_1=__webpack_require__(153);/**
   * Branch out the source Observable values as a nested Observable using a
   * factory function of closing Observables to determine when to start a new
   * window.
   *
   * <span class="informal">It's like {@link bufferWhen}, but emits a nested
   * Observable instead of an array.</span>
   *
   * <img src="./img/windowWhen.png" width="100%">
   *
   * Returns an Observable that emits windows of items it collects from the source
   * Observable. The output Observable emits connected, non-overlapping windows.
   * It emits the current window and opens a new one whenever the Observable
   * produced by the specified `closingSelector` function emits an item. The first
   * window is opened immediately when subscribing to the output Observable.
   *
   * @example <caption>Emit only the first two clicks events in every window of [1-5] random seconds</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks
   *   .windowWhen(() => Rx.Observable.interval(1000 + Math.random() * 4000))
   *   .map(win => win.take(2)) // each window has at most 2 emissions
   *   .mergeAll(); // flatten the Observable-of-Observables
   * result.subscribe(x => console.log(x));
   *
   * @see {@link window}
   * @see {@link windowCount}
   * @see {@link windowTime}
   * @see {@link windowToggle}
   * @see {@link bufferWhen}
   *
   * @param {function(): Observable} closingSelector A function that takes no
   * arguments and returns an Observable that signals (on either `next` or
   * `complete`) when to close the previous window and start a new one.
   * @return {Observable<Observable<T>>} An observable of windows, which in turn
   * are Observables.
   * @method windowWhen
   * @owner Observable
   */function windowWhen(closingSelector){return windowWhen_1.windowWhen(closingSelector)(this);}exports.windowWhen=windowWhen;//# sourceMappingURL=windowWhen.js.map
  
  /***/ }),
  /* 441 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var withLatestFrom_1=__webpack_require__(442);Observable_1.Observable.prototype.withLatestFrom=withLatestFrom_1.withLatestFrom;//# sourceMappingURL=withLatestFrom.js.map
  
  /***/ }),
  /* 442 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var withLatestFrom_1=__webpack_require__(154);/* tslint:enable:max-line-length *//**
   * Combines the source Observable with other Observables to create an Observable
   * whose values are calculated from the latest values of each, only when the
   * source emits.
   *
   * <span class="informal">Whenever the source Observable emits a value, it
   * computes a formula using that value plus the latest values from other input
   * Observables, then emits the output of that formula.</span>
   *
   * <img src="./img/withLatestFrom.png" width="100%">
   *
   * `withLatestFrom` combines each value from the source Observable (the
   * instance) with the latest values from the other input Observables only when
   * the source emits a value, optionally using a `project` function to determine
   * the value to be emitted on the output Observable. All input Observables must
   * emit at least one value before the output Observable will emit a value.
   *
   * @example <caption>On every click event, emit an array with the latest timer event plus the click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var result = clicks.withLatestFrom(timer);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineLatest}
   *
   * @param {ObservableInput} other An input Observable to combine with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Function} [project] Projection function for combining values
   * together. Receives all values in order of the Observables passed, where the
   * first parameter is a value from the source Observable. (e.g.
   * `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not
   * passed, arrays will be emitted on the output Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @method withLatestFrom
   * @owner Observable
   */function withLatestFrom(){var args=[];for(var _i=0;_i<arguments.length;_i++){args[_i-0]=arguments[_i];}return withLatestFrom_1.withLatestFrom.apply(void 0,args)(this);}exports.withLatestFrom=withLatestFrom;//# sourceMappingURL=withLatestFrom.js.map
  
  /***/ }),
  /* 443 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var zip_1=__webpack_require__(444);Observable_1.Observable.prototype.zip=zip_1.zipProto;//# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 444 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var zip_1=__webpack_require__(35);/* tslint:enable:max-line-length *//**
   * @param observables
   * @return {Observable<R>}
   * @method zip
   * @owner Observable
   */function zipProto(){var observables=[];for(var _i=0;_i<arguments.length;_i++){observables[_i-0]=arguments[_i];}return zip_1.zip.apply(void 0,observables)(this);}exports.zipProto=zipProto;//# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 445 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var Observable_1=__webpack_require__(0);var zipAll_1=__webpack_require__(446);Observable_1.Observable.prototype.zipAll=zipAll_1.zipAll;//# sourceMappingURL=zipAll.js.map
  
  /***/ }),
  /* 446 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var zipAll_1=__webpack_require__(155);/**
   * @param project
   * @return {Observable<R>|WebSocketSubject<T>|Observable<T>}
   * @method zipAll
   * @owner Observable
   */function zipAll(project){return zipAll_1.zipAll(project)(this);}exports.zipAll=zipAll;//# sourceMappingURL=zipAll.js.map
  
  /***/ }),
  /* 447 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var Notification_1=__webpack_require__(17);var ColdObservable_1=__webpack_require__(448);var HotObservable_1=__webpack_require__(449);var SubscriptionLog_1=__webpack_require__(157);var VirtualTimeScheduler_1=__webpack_require__(159);var defaultMaxFrame=750;var TestScheduler=function(_super){__extends(TestScheduler,_super);function TestScheduler(assertDeepEqual){_super.call(this,VirtualTimeScheduler_1.VirtualAction,defaultMaxFrame);this.assertDeepEqual=assertDeepEqual;this.hotObservables=[];this.coldObservables=[];this.flushTests=[];}TestScheduler.prototype.createTime=function(marbles){var indexOf=marbles.indexOf('|');if(indexOf===-1){throw new Error('marble diagram for time should have a completion marker "|"');}return indexOf*TestScheduler.frameTimeFactor;};TestScheduler.prototype.createColdObservable=function(marbles,values,error){if(marbles.indexOf('^')!==-1){throw new Error('cold observable cannot have subscription offset "^"');}if(marbles.indexOf('!')!==-1){throw new Error('cold observable cannot have unsubscription marker "!"');}var messages=TestScheduler.parseMarbles(marbles,values,error);var cold=new ColdObservable_1.ColdObservable(messages,this);this.coldObservables.push(cold);return cold;};TestScheduler.prototype.createHotObservable=function(marbles,values,error){if(marbles.indexOf('!')!==-1){throw new Error('hot observable cannot have unsubscription marker "!"');}var messages=TestScheduler.parseMarbles(marbles,values,error);var subject=new HotObservable_1.HotObservable(messages,this);this.hotObservables.push(subject);return subject;};TestScheduler.prototype.materializeInnerObservable=function(observable,outerFrame){var _this=this;var messages=[];observable.subscribe(function(value){messages.push({frame:_this.frame-outerFrame,notification:Notification_1.Notification.createNext(value)});},function(err){messages.push({frame:_this.frame-outerFrame,notification:Notification_1.Notification.createError(err)});},function(){messages.push({frame:_this.frame-outerFrame,notification:Notification_1.Notification.createComplete()});});return messages;};TestScheduler.prototype.expectObservable=function(observable,unsubscriptionMarbles){var _this=this;if(unsubscriptionMarbles===void 0){unsubscriptionMarbles=null;}var actual=[];var flushTest={actual:actual,ready:false};var unsubscriptionFrame=TestScheduler.parseMarblesAsSubscriptions(unsubscriptionMarbles).unsubscribedFrame;var subscription;this.schedule(function(){subscription=observable.subscribe(function(x){var value=x;// Support Observable-of-Observables
  if(x instanceof Observable_1.Observable){value=_this.materializeInnerObservable(value,_this.frame);}actual.push({frame:_this.frame,notification:Notification_1.Notification.createNext(value)});},function(err){actual.push({frame:_this.frame,notification:Notification_1.Notification.createError(err)});},function(){actual.push({frame:_this.frame,notification:Notification_1.Notification.createComplete()});});},0);if(unsubscriptionFrame!==Number.POSITIVE_INFINITY){this.schedule(function(){return subscription.unsubscribe();},unsubscriptionFrame);}this.flushTests.push(flushTest);return{toBe:function toBe(marbles,values,errorValue){flushTest.ready=true;flushTest.expected=TestScheduler.parseMarbles(marbles,values,errorValue,true);}};};TestScheduler.prototype.expectSubscriptions=function(actualSubscriptionLogs){var flushTest={actual:actualSubscriptionLogs,ready:false};this.flushTests.push(flushTest);return{toBe:function toBe(marbles){var marblesArray=typeof marbles==='string'?[marbles]:marbles;flushTest.ready=true;flushTest.expected=marblesArray.map(function(marbles){return TestScheduler.parseMarblesAsSubscriptions(marbles);});}};};TestScheduler.prototype.flush=function(){var hotObservables=this.hotObservables;while(hotObservables.length>0){hotObservables.shift().setup();}_super.prototype.flush.call(this);var readyFlushTests=this.flushTests.filter(function(test){return test.ready;});while(readyFlushTests.length>0){var test=readyFlushTests.shift();this.assertDeepEqual(test.actual,test.expected);}};TestScheduler.parseMarblesAsSubscriptions=function(marbles){if(typeof marbles!=='string'){return new SubscriptionLog_1.SubscriptionLog(Number.POSITIVE_INFINITY);}var len=marbles.length;var groupStart=-1;var subscriptionFrame=Number.POSITIVE_INFINITY;var unsubscriptionFrame=Number.POSITIVE_INFINITY;for(var i=0;i<len;i++){var frame=i*this.frameTimeFactor;var c=marbles[i];switch(c){case'-':case' ':break;case'(':groupStart=frame;break;case')':groupStart=-1;break;case'^':if(subscriptionFrame!==Number.POSITIVE_INFINITY){throw new Error('found a second subscription point \'^\' in a '+'subscription marble diagram. There can only be one.');}subscriptionFrame=groupStart>-1?groupStart:frame;break;case'!':if(unsubscriptionFrame!==Number.POSITIVE_INFINITY){throw new Error('found a second subscription point \'^\' in a '+'subscription marble diagram. There can only be one.');}unsubscriptionFrame=groupStart>-1?groupStart:frame;break;default:throw new Error('there can only be \'^\' and \'!\' markers in a '+'subscription marble diagram. Found instead \''+c+'\'.');}}if(unsubscriptionFrame<0){return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame);}else{return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame,unsubscriptionFrame);}};TestScheduler.parseMarbles=function(marbles,values,errorValue,materializeInnerObservables){if(materializeInnerObservables===void 0){materializeInnerObservables=false;}if(marbles.indexOf('!')!==-1){throw new Error('conventional marble diagrams cannot have the '+'unsubscription marker "!"');}var len=marbles.length;var testMessages=[];var subIndex=marbles.indexOf('^');var frameOffset=subIndex===-1?0:subIndex*-this.frameTimeFactor;var getValue=(typeof values==='undefined'?'undefined':_typeof(values))!=='object'?function(x){return x;}:function(x){// Support Observable-of-Observables
  if(materializeInnerObservables&&values[x]instanceof ColdObservable_1.ColdObservable){return values[x].messages;}return values[x];};var groupStart=-1;for(var i=0;i<len;i++){var frame=i*this.frameTimeFactor+frameOffset;var notification=void 0;var c=marbles[i];switch(c){case'-':case' ':break;case'(':groupStart=frame;break;case')':groupStart=-1;break;case'|':notification=Notification_1.Notification.createComplete();break;case'^':break;case'#':notification=Notification_1.Notification.createError(errorValue||'error');break;default:notification=Notification_1.Notification.createNext(getValue(c));break;}if(notification){testMessages.push({frame:groupStart>-1?groupStart:frame,notification:notification});}}return testMessages;};return TestScheduler;}(VirtualTimeScheduler_1.VirtualTimeScheduler);exports.TestScheduler=TestScheduler;//# sourceMappingURL=TestScheduler.js.map
  
  /***/ }),
  /* 448 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Observable_1=__webpack_require__(0);var Subscription_1=__webpack_require__(5);var SubscriptionLoggable_1=__webpack_require__(156);var applyMixins_1=__webpack_require__(158);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var ColdObservable=function(_super){__extends(ColdObservable,_super);function ColdObservable(messages,scheduler){_super.call(this,function(subscriber){var observable=this;var index=observable.logSubscribedFrame();subscriber.add(new Subscription_1.Subscription(function(){observable.logUnsubscribedFrame(index);}));observable.scheduleMessages(subscriber);return subscriber;});this.messages=messages;this.subscriptions=[];this.scheduler=scheduler;}ColdObservable.prototype.scheduleMessages=function(subscriber){var messagesLength=this.messages.length;for(var i=0;i<messagesLength;i++){var message=this.messages[i];subscriber.add(this.scheduler.schedule(function(_a){var message=_a.message,subscriber=_a.subscriber;message.notification.observe(subscriber);},message.frame,{message:message,subscriber:subscriber}));}};return ColdObservable;}(Observable_1.Observable);exports.ColdObservable=ColdObservable;applyMixins_1.applyMixins(ColdObservable,[SubscriptionLoggable_1.SubscriptionLoggable]);//# sourceMappingURL=ColdObservable.js.map
  
  /***/ }),
  /* 449 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var Subject_1=__webpack_require__(6);var Subscription_1=__webpack_require__(5);var SubscriptionLoggable_1=__webpack_require__(156);var applyMixins_1=__webpack_require__(158);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var HotObservable=function(_super){__extends(HotObservable,_super);function HotObservable(messages,scheduler){_super.call(this);this.messages=messages;this.subscriptions=[];this.scheduler=scheduler;}HotObservable.prototype._subscribe=function(subscriber){var subject=this;var index=subject.logSubscribedFrame();subscriber.add(new Subscription_1.Subscription(function(){subject.logUnsubscribedFrame(index);}));return _super.prototype._subscribe.call(this,subscriber);};HotObservable.prototype.setup=function(){var subject=this;var messagesLength=subject.messages.length;/* tslint:disable:no-var-keyword */for(var i=0;i<messagesLength;i++){(function(){var message=subject.messages[i];/* tslint:enable */subject.scheduler.schedule(function(){message.notification.observe(subject);},message.frame);})();}};return HotObservable;}(Subject_1.Subject);exports.HotObservable=HotObservable;applyMixins_1.applyMixins(HotObservable,[SubscriptionLoggable_1.SubscriptionLoggable]);//# sourceMappingURL=HotObservable.js.map
  
  /***/ }),
  /* 450 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var AnimationFrameAction_1=__webpack_require__(451);var AnimationFrameScheduler_1=__webpack_require__(453);/**
   *
   * Animation Frame Scheduler
   *
   * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span>
   *
   * When `animationFrame` scheduler is used with delay, it will fall back to {@link async} scheduler
   * behaviour.
   *
   * Without delay, `animationFrame` scheduler can be used to create smooth browser animations.
   * It makes sure scheduled task will happen just before next browser content repaint,
   * thus performing animations as efficiently as possible.
   *
   * @example <caption>Schedule div height animation</caption>
   * const div = document.querySelector('.some-div');
   *
   * Rx.Scheduler.schedule(function(height) {
   *   div.style.height = height + "px";
   *
   *   this.schedule(height + 1);  // `this` references currently executing Action,
   *                               // which we reschedule with new state
   * }, 0, 0);
   *
   * // You will see .some-div element growing in height
   *
   *
   * @static true
   * @name animationFrame
   * @owner Scheduler
   */exports.animationFrame=new AnimationFrameScheduler_1.AnimationFrameScheduler(AnimationFrameAction_1.AnimationFrameAction);//# sourceMappingURL=animationFrame.js.map
  
  /***/ }),
  /* 451 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncAction_1=__webpack_require__(20);var AnimationFrame_1=__webpack_require__(452);/**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */var AnimationFrameAction=function(_super){__extends(AnimationFrameAction,_super);function AnimationFrameAction(scheduler,work){_super.call(this,scheduler,work);this.scheduler=scheduler;this.work=work;}AnimationFrameAction.prototype.requestAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If delay is greater than 0, request as an async action.
  if(delay!==null&&delay>0){return _super.prototype.requestAsyncId.call(this,scheduler,id,delay);}// Push the action to the end of the scheduler queue.
  scheduler.actions.push(this);// If an animation frame has already been requested, don't request another
  // one. If an animation frame hasn't been requested yet, request one. Return
  // the current animation frame request id.
  return scheduler.scheduled||(scheduler.scheduled=AnimationFrame_1.AnimationFrame.requestAnimationFrame(scheduler.flush.bind(scheduler,null)));};AnimationFrameAction.prototype.recycleAsyncId=function(scheduler,id,delay){if(delay===void 0){delay=0;}// If delay exists and is greater than 0, or if the delay is null (the
  // action wasn't rescheduled) but was originally scheduled as an async
  // action, then recycle as an async action.
  if(delay!==null&&delay>0||delay===null&&this.delay>0){return _super.prototype.recycleAsyncId.call(this,scheduler,id,delay);}// If the scheduler queue is empty, cancel the requested animation frame and
  // set the scheduled flag to undefined so the next AnimationFrameAction will
  // request its own.
  if(scheduler.actions.length===0){AnimationFrame_1.AnimationFrame.cancelAnimationFrame(id);scheduler.scheduled=undefined;}// Return undefined so the action knows to request a new async id if it's rescheduled.
  return undefined;};return AnimationFrameAction;}(AsyncAction_1.AsyncAction);exports.AnimationFrameAction=AnimationFrameAction;//# sourceMappingURL=AnimationFrameAction.js.map
  
  /***/ }),
  /* 452 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var root_1=__webpack_require__(9);var RequestAnimationFrameDefinition=function(){function RequestAnimationFrameDefinition(root){if(root.requestAnimationFrame){this.cancelAnimationFrame=root.cancelAnimationFrame.bind(root);this.requestAnimationFrame=root.requestAnimationFrame.bind(root);}else if(root.mozRequestAnimationFrame){this.cancelAnimationFrame=root.mozCancelAnimationFrame.bind(root);this.requestAnimationFrame=root.mozRequestAnimationFrame.bind(root);}else if(root.webkitRequestAnimationFrame){this.cancelAnimationFrame=root.webkitCancelAnimationFrame.bind(root);this.requestAnimationFrame=root.webkitRequestAnimationFrame.bind(root);}else if(root.msRequestAnimationFrame){this.cancelAnimationFrame=root.msCancelAnimationFrame.bind(root);this.requestAnimationFrame=root.msRequestAnimationFrame.bind(root);}else if(root.oRequestAnimationFrame){this.cancelAnimationFrame=root.oCancelAnimationFrame.bind(root);this.requestAnimationFrame=root.oRequestAnimationFrame.bind(root);}else{this.cancelAnimationFrame=root.clearTimeout.bind(root);this.requestAnimationFrame=function(cb){return root.setTimeout(cb,1000/60);};}}return RequestAnimationFrameDefinition;}();exports.RequestAnimationFrameDefinition=RequestAnimationFrameDefinition;exports.AnimationFrame=new RequestAnimationFrameDefinition(root_1.root);//# sourceMappingURL=AnimationFrame.js.map
  
  /***/ }),
  /* 453 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var __extends=undefined&&undefined.__extends||function(d,b){for(var p in b){if(b.hasOwnProperty(p))d[p]=b[p];}function __(){this.constructor=d;}d.prototype=b===null?Object.create(b):(__.prototype=b.prototype,new __());};var AsyncScheduler_1=__webpack_require__(21);var AnimationFrameScheduler=function(_super){__extends(AnimationFrameScheduler,_super);function AnimationFrameScheduler(){_super.apply(this,arguments);}AnimationFrameScheduler.prototype.flush=function(action){this.active=true;this.scheduled=undefined;var actions=this.actions;var error;var index=-1;var count=actions.length;action=action||actions.shift();do{if(error=action.execute(action.state,action.delay)){break;}}while(++index<count&&(action=actions.shift()));this.active=false;if(error){while(++index<count&&(action=actions.shift())){action.unsubscribe();}throw error;}};return AnimationFrameScheduler;}(AsyncScheduler_1.AsyncScheduler);exports.AnimationFrameScheduler=AnimationFrameScheduler;//# sourceMappingURL=AnimationFrameScheduler.js.map
  
  /***/ }),
  /* 454 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var audit_1=__webpack_require__(51);exports.audit=audit_1.audit;var auditTime_1=__webpack_require__(100);exports.auditTime=auditTime_1.auditTime;var buffer_1=__webpack_require__(72);exports.buffer=buffer_1.buffer;var bufferCount_1=__webpack_require__(73);exports.bufferCount=bufferCount_1.bufferCount;var bufferTime_1=__webpack_require__(74);exports.bufferTime=bufferTime_1.bufferTime;var bufferToggle_1=__webpack_require__(75);exports.bufferToggle=bufferToggle_1.bufferToggle;var bufferWhen_1=__webpack_require__(76);exports.bufferWhen=bufferWhen_1.bufferWhen;var catchError_1=__webpack_require__(77);exports.catchError=catchError_1.catchError;var combineAll_1=__webpack_require__(78);exports.combineAll=combineAll_1.combineAll;var combineLatest_1=__webpack_require__(30);exports.combineLatest=combineLatest_1.combineLatest;var concat_1=__webpack_require__(79);exports.concat=concat_1.concat;var concatAll_1=__webpack_require__(43);exports.concatAll=concatAll_1.concatAll;var concatMap_1=__webpack_require__(46);exports.concatMap=concatMap_1.concatMap;var concatMapTo_1=__webpack_require__(80);exports.concatMapTo=concatMapTo_1.concatMapTo;var count_1=__webpack_require__(81);exports.count=count_1.count;var debounce_1=__webpack_require__(83);exports.debounce=debounce_1.debounce;var debounceTime_1=__webpack_require__(84);exports.debounceTime=debounceTime_1.debounceTime;var defaultIfEmpty_1=__webpack_require__(47);exports.defaultIfEmpty=defaultIfEmpty_1.defaultIfEmpty;var delay_1=__webpack_require__(85);exports.delay=delay_1.delay;var delayWhen_1=__webpack_require__(86);exports.delayWhen=delayWhen_1.delayWhen;var dematerialize_1=__webpack_require__(82);exports.dematerialize=dematerialize_1.dematerialize;var distinct_1=__webpack_require__(87);exports.distinct=distinct_1.distinct;var distinctUntilChanged_1=__webpack_require__(48);exports.distinctUntilChanged=distinctUntilChanged_1.distinctUntilChanged;var distinctUntilKeyChanged_1=__webpack_require__(88);exports.distinctUntilKeyChanged=distinctUntilKeyChanged_1.distinctUntilKeyChanged;var elementAt_1=__webpack_require__(93);exports.elementAt=elementAt_1.elementAt;var every_1=__webpack_require__(102);exports.every=every_1.every;var exhaust_1=__webpack_require__(90);exports.exhaust=exhaust_1.exhaust;var exhaustMap_1=__webpack_require__(91);exports.exhaustMap=exhaustMap_1.exhaustMap;var expand_1=__webpack_require__(92);exports.expand=expand_1.expand;var filter_1=__webpack_require__(49);exports.filter=filter_1.filter;var finalize_1=__webpack_require__(94);exports.finalize=finalize_1.finalize;var find_1=__webpack_require__(50);exports.find=find_1.find;var findIndex_1=__webpack_require__(95);exports.findIndex=findIndex_1.findIndex;var first_1=__webpack_require__(96);exports.first=first_1.first;var groupBy_1=__webpack_require__(97);exports.groupBy=groupBy_1.groupBy;var ignoreElements_1=__webpack_require__(98);exports.ignoreElements=ignoreElements_1.ignoreElements;var isEmpty_1=__webpack_require__(99);exports.isEmpty=isEmpty_1.isEmpty;var last_1=__webpack_require__(101);exports.last=last_1.last;var map_1=__webpack_require__(22);exports.map=map_1.map;var mapTo_1=__webpack_require__(103);exports.mapTo=mapTo_1.mapTo;var materialize_1=__webpack_require__(104);exports.materialize=materialize_1.materialize;var max_1=__webpack_require__(105);exports.max=max_1.max;var merge_1=__webpack_require__(106);exports.merge=merge_1.merge;var mergeAll_1=__webpack_require__(32);exports.mergeAll=mergeAll_1.mergeAll;var mergeMap_1=__webpack_require__(18);exports.mergeMap=mergeMap_1.mergeMap;var mergeMap_2=__webpack_require__(18);exports.flatMap=mergeMap_2.mergeMap;var mergeMapTo_1=__webpack_require__(107);exports.mergeMapTo=mergeMapTo_1.mergeMapTo;var mergeScan_1=__webpack_require__(108);exports.mergeScan=mergeScan_1.mergeScan;var min_1=__webpack_require__(109);exports.min=min_1.min;var multicast_1=__webpack_require__(14);exports.multicast=multicast_1.multicast;var observeOn_1=__webpack_require__(31);exports.observeOn=observeOn_1.observeOn;var onErrorResumeNext_1=__webpack_require__(45);exports.onErrorResumeNext=onErrorResumeNext_1.onErrorResumeNext;var pairwise_1=__webpack_require__(111);exports.pairwise=pairwise_1.pairwise;var partition_1=__webpack_require__(112);exports.partition=partition_1.partition;var pluck_1=__webpack_require__(113);exports.pluck=pluck_1.pluck;var publish_1=__webpack_require__(114);exports.publish=publish_1.publish;var publishBehavior_1=__webpack_require__(115);exports.publishBehavior=publishBehavior_1.publishBehavior;var publishLast_1=__webpack_require__(118);exports.publishLast=publishLast_1.publishLast;var publishReplay_1=__webpack_require__(117);exports.publishReplay=publishReplay_1.publishReplay;var race_1=__webpack_require__(119);exports.race=race_1.race;var reduce_1=__webpack_require__(24);exports.reduce=reduce_1.reduce;var repeat_1=__webpack_require__(120);exports.repeat=repeat_1.repeat;var repeatWhen_1=__webpack_require__(121);exports.repeatWhen=repeatWhen_1.repeatWhen;var retry_1=__webpack_require__(122);exports.retry=retry_1.retry;var retryWhen_1=__webpack_require__(123);exports.retryWhen=retryWhen_1.retryWhen;var refCount_1=__webpack_require__(54);exports.refCount=refCount_1.refCount;var sample_1=__webpack_require__(124);exports.sample=sample_1.sample;var sampleTime_1=__webpack_require__(125);exports.sampleTime=sampleTime_1.sampleTime;var scan_1=__webpack_require__(52);exports.scan=scan_1.scan;var sequenceEqual_1=__webpack_require__(126);exports.sequenceEqual=sequenceEqual_1.sequenceEqual;var share_1=__webpack_require__(127);exports.share=share_1.share;var shareReplay_1=__webpack_require__(128);exports.shareReplay=shareReplay_1.shareReplay;var single_1=__webpack_require__(129);exports.single=single_1.single;var skip_1=__webpack_require__(130);exports.skip=skip_1.skip;var skipLast_1=__webpack_require__(131);exports.skipLast=skipLast_1.skipLast;var skipUntil_1=__webpack_require__(132);exports.skipUntil=skipUntil_1.skipUntil;var skipWhile_1=__webpack_require__(133);exports.skipWhile=skipWhile_1.skipWhile;var startWith_1=__webpack_require__(134);exports.startWith=startWith_1.startWith;/**
   * TODO(https://github.com/ReactiveX/rxjs/issues/2900): Add back subscribeOn once it can be
   * treeshaken. Currently if this export is added back, it
   * forces apps to bring in asap scheduler along with
   * Immediate, root, and other supporting code.
   */// export { subscribeOn } from './operators/subscribeOn';
  var switchAll_1=__webpack_require__(137);exports.switchAll=switchAll_1.switchAll;var switchMap_1=__webpack_require__(55);exports.switchMap=switchMap_1.switchMap;var switchMapTo_1=__webpack_require__(138);exports.switchMapTo=switchMapTo_1.switchMapTo;var take_1=__webpack_require__(139);exports.take=take_1.take;var takeLast_1=__webpack_require__(53);exports.takeLast=takeLast_1.takeLast;var takeUntil_1=__webpack_require__(140);exports.takeUntil=takeUntil_1.takeUntil;var takeWhile_1=__webpack_require__(141);exports.takeWhile=takeWhile_1.takeWhile;var tap_1=__webpack_require__(89);exports.tap=tap_1.tap;var throttle_1=__webpack_require__(38);exports.throttle=throttle_1.throttle;var throttleTime_1=__webpack_require__(142);exports.throttleTime=throttleTime_1.throttleTime;var timeInterval_1=__webpack_require__(144);exports.timeInterval=timeInterval_1.timeInterval;var timeout_1=__webpack_require__(145);exports.timeout=timeout_1.timeout;var timeoutWith_1=__webpack_require__(147);exports.timeoutWith=timeoutWith_1.timeoutWith;var timestamp_1=__webpack_require__(56);exports.timestamp=timestamp_1.timestamp;var toArray_1=__webpack_require__(148);exports.toArray=toArray_1.toArray;var window_1=__webpack_require__(149);exports.window=window_1.window;var windowCount_1=__webpack_require__(150);exports.windowCount=windowCount_1.windowCount;var windowTime_1=__webpack_require__(151);exports.windowTime=windowTime_1.windowTime;var windowToggle_1=__webpack_require__(152);exports.windowToggle=windowToggle_1.windowToggle;var windowWhen_1=__webpack_require__(153);exports.windowWhen=windowWhen_1.windowWhen;var withLatestFrom_1=__webpack_require__(154);exports.withLatestFrom=withLatestFrom_1.withLatestFrom;var zip_1=__webpack_require__(35);exports.zip=zip_1.zip;var zipAll_1=__webpack_require__(155);exports.zipAll=zipAll_1.zipAll;//# sourceMappingURL=operators.js.map
  
  /***/ }),
  /* 455 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(exports,"__esModule",{value:true});var _Rx=__webpack_require__(39);function _toConsumableArray(arr){if(Array.isArray(arr)){for(var i=0,arr2=Array(arr.length);i<arr.length;i++){arr2[i]=arr[i];}return arr2;}else{return Array.from(arr);}}/**
   * @fileOverview Module for auto shift of elements for adaptive sites
   *
   * @author Alex | RG team
   *//**
   * Module name
   * Имя модуля
   * @type {String}
   */var __name__='ShiftBlock';/**
   * Options as default for module
   * Параметры по-умолчанию
   *
   * @type {Object}
   */var __options__={// Find processed blocks every time
  // or once on first init
  //
  // Ищем обрабатываемые блоки каждый раз, при измененнии экрана
  // или только раз при инициализации
  hot:false,// selector for processing block
  //
  // селектор для обрабатываемых блоков
  blocksSelector:'.shift',// attribute for active block
  // (module add it for block)
  //
  // аттрибут, который добавляется к активному, для данного типа экрана, блоку
  showAttr:'data-is-show',// ID for searching blocks of the same type
  //
  // аттрибут в который передается идентификатор для одного типа блока
  idBlockAttr:'data-shift-id',// store list screen type current block
  //
  // в значении аттрибута хранится список типов экранов для блока,
  // где его нужно показывать
  screenTypeAttr:'data-shift-type'/**
   * Get module name
   * Получить имя модуля
   * @return {String} module name
   */};var getModuleName=function getModuleName(){return __name__;};/**
   * Find all blocks for module of passed selector
   * Поиск всех блоков для шифтера, по переданному селектору
   *
   * @param {Obejct} param param for processing (параметры для обработки)
   *                       - hot (see options)
   *                       - selector (see options)
   *
   * @return {Function} return cyrring function with element store (возвращает карированную функцию, с возможностью получения данных из хранилища)
   */var findBlocks=function findBlocks(param){// Store for blocks
  // if hot - enable, then empty everything
  //
  // Стор для блоков
  // будет всегда пустой, если включен флаг hot
  var store=void 0;// Helper function - get all blocks
  //
  // Хелпер получить блоки
  var __get__=function __get__(selector){return[].concat(_toConsumableArray(document.querySelectorAll(selector)));};// If hot disable, then store elements as buffer
  //
  // Если нет флага, получать блоки заново при запуске процесса
  // то сохраняем блок в замыкании
  if(!param.hot){store=__get__(param.selector);}return function(){return store||__get__(param.selector);};};/**
   * Hide all blocks at passed id and attr
   * Скрыть все блоки, по переданному id и аттрибуту
   *
   * @param {Object} param param for function (параметры для функции)
   *                       - blocks for hide (блоки, которые надо скрыть)
   *                       - showAttr for show element (аттрибут для показа элемента)
   *
   * @return {void}
   */var hideBlocks=function hideBlocks(param){var blocks=param.blocks,showAttr=param.showAttr;blocks.forEach(function(block){// remove attribute for hide block
  //
  // Удаляем аттрибут, чтобы скрыть блок
  block.removeAttribute(showAttr);// remove block content
  //
  // Удаляем контент блока
  block.innerHTML='';});};/**
   * Shift block
   *
   * Перемещение блока
   *
   * @param {Object} param param for function (параметры для функции)
   *                       - showAttr for show element (аттрибут для показа элемента)
   *                       - block for shift (элемент DOM, который будем перемещать)
   *
   * @return {void}
   */var shift=function shift(param){var block=param.block,showAttr=param.showAttr,idBlockAttr=param.idBlockAttr;var blocks=[].concat(_toConsumableArray(document.querySelectorAll('['+idBlockAttr+'='+block.getAttribute(idBlockAttr)+']['+showAttr+']')));// work if block no itself (it may happen with first init)
  //
  // Работаем если только это не один и тот же блок (может быть, при первой инициализации)
  if(blocks[0]!==block){// add content
  //
  // Заполняем контентом
  block.innerHTML=blocks[0].innerHTML;// find all showed blocks with target ID and hide it
  // remove arrtibute and remove content
  //
  // Находим все показанные блоки с таким id и скрываем их
  // убирая аттрибут и удаляя контент блока
  hideBlocks({blocks:blocks,showAttr:showAttr});// show block
  //
  // Показываем блок
  block.setAttribute(showAttr,'');}};/**
   * Run module. Begin shifting blocks when screen is change
   * Запускаем модуль. Начинают шифтиться блоки, по изменению экрана
   *
   * @param  {Rx} screen$ observable screen changes (поток изменения типа экрана)
   * @param  {Object} param param for module (параметры для работы модуля)
   *
   * @return {Rx} return observable of blocks (вовзращаем поток блоков)
   */var run$=function run$(screen$,param){var blocks=param.blocks,screenTypeAttr=param.screenTypeAttr;// if screen type changed
  //
  // При изменении типа экрана
  return screen$.switchMap(function(info){// create observable from finded blocks
  //
  // Формируем поток из всех найденных блоков
  return _Rx.Observable.from(blocks)// filter blocks only for current screen type
  //
  // Фильтруем только те, что должны быть обработаны в этом типе экрана
  .filter(function(block){return block.getAttribute(screenTypeAttr).split(' ').includes(info.type);});});};/**
   * Module init
   * Инициализация модуля
   *
   * @param  {Object} options параметры для инициалиазции
   *                          - hot (see options)
   *                          - blocksSelector (see options)
   *                          - showAttr (see options)
   *                          - idBlockAttr (see options)
   *                          - screenTypeAttr (see options)
   *                          - screen$ observable screen types (поток с изменениями типа экрана)
   *
   * @return {void}
   */var init=function init(options){var _Object$assign=Object.assign({},__options__,options),screen$=_Object$assign.screen$,hot=_Object$assign.hot,blocksSelector=_Object$assign.blocksSelector,showAttr=_Object$assign.showAttr,idBlockAttr=_Object$assign.idBlockAttr,screenTypeAttr=_Object$assign.screenTypeAttr;// if screen observable pass for init
  //
  // Если был передан поток при инициализации
  if(screen$){// find blocks for process
  //
  // Ищем элементы для перемещения по странице
  var blocks=findBlocks({hot:hot,selector:blocksSelector})();// run module
  //
  // Запускаем модуль
  run$(screen$,{blocks:blocks,screenTypeAttr:screenTypeAttr}).subscribe(function(block){shift({block:block,showAttr:showAttr,idBlockAttr:idBlockAttr});});}else{// if screen observable not pass, throw error
  //
  // Если мы не получили поток при инициализации
  // выдаем ошибку
  throw new Error('\u041C\u043E\u0434\u0443\u043B\u044C '+__name__+', \u0434\u043B\u044F \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u043D\u0443\u0436\u0435\u043D \u043F\u043E\u0442\u043E\u043A, \u0441\u0432\u043E\u0439\u0441\u0442\u0432\u043E screen$');}};exports.default={getModuleName:getModuleName,init:init};
  
  /***/ }),
  /* 456 */,
  /* 457 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  var _Rx=__webpack_require__(39);var _screenViewer=__webpack_require__(458);var _screenViewer2=_interopRequireDefault(_screenViewer);var _shiftBlock=__webpack_require__(455);var _shiftBlock2=_interopRequireDefault(_shiftBlock);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj};}_screenViewer2.default.setup({map:{'768':'mobile','990':'tablet','1260':'tabletLandscape','1760':'desktop'},default:'desktopFull'});var screen$=_screenViewer2.default.init$([_Rx.Observable.fromEvent(window,'load').map(function(){return window.innerWidth;}),_Rx.Observable.fromEvent(window,'resize').map(function(event){return event.target.innerWidth;})]);// Init module
  _shiftBlock2.default.init({screen$:screen$});
  
  /***/ }),
  /* 458 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};(function webpackUniversalModuleDefinition(root,factory){if(( false?'undefined':_typeof(exports))==='object'&&( false?'undefined':_typeof(module))==='object')module.exports=factory(__webpack_require__(39));else if(true)!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(39)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));else if((typeof exports==='undefined'?'undefined':_typeof(exports))==='object')exports["ScreenViewer"]=factory(require("rxjs/Rx"));else root["ScreenViewer"]=factory(root["rxjs/Rx"]);})(undefined,function(__WEBPACK_EXTERNAL_MODULE_1__){return(/******/function(modules){// webpackBootstrap
  /******/// The module cache
  /******/var installedModules={};/******//******/// The require function
  /******/function __webpack_require__(moduleId){/******//******/// Check if module is in cache
  /******/if(installedModules[moduleId]){/******/return installedModules[moduleId].exports;/******/}/******/// Create a new module (and put it into the cache)
  /******/var module=installedModules[moduleId]={/******/i:moduleId,/******/l:false,/******/exports:{}/******/};/******//******/// Execute the module function
  /******/modules[moduleId].call(module.exports,module,module.exports,__webpack_require__);/******//******/// Flag the module as loaded
  /******/module.l=true;/******//******/// Return the exports of the module
  /******/return module.exports;/******/}/******//******//******/// expose the modules object (__webpack_modules__)
  /******/__webpack_require__.m=modules;/******//******/// expose the module cache
  /******/__webpack_require__.c=installedModules;/******//******/// define getter function for harmony exports
  /******/__webpack_require__.d=function(exports,name,getter){/******/if(!__webpack_require__.o(exports,name)){/******/Object.defineProperty(exports,name,{/******/configurable:false,/******/enumerable:true,/******/get:getter/******/});/******/}/******/};/******//******/// getDefaultExport function for compatibility with non-harmony modules
  /******/__webpack_require__.n=function(module){/******/var getter=module&&module.__esModule?/******/function getDefault(){return module['default'];}:/******/function getModuleExports(){return module;};/******/__webpack_require__.d(getter,'a',getter);/******/return getter;/******/};/******//******/// Object.prototype.hasOwnProperty.call
  /******/__webpack_require__.o=function(object,property){return Object.prototype.hasOwnProperty.call(object,property);};/******//******/// __webpack_public_path__
  /******/__webpack_require__.p="";/******//******/// Load entry module and return exports
  /******/return __webpack_require__(__webpack_require__.s=0);/******/}(/************************************************************************//******/[/* 0 *//***/function(module,exports,__webpack_require__){"use strict";/* WEBPACK VAR INJECTION */(function(Rx){Object.defineProperty(exports,"__esModule",{value:true});function _toConsumableArray(arr){if(Array.isArray(arr)){for(var i=0,arr2=Array(arr.length);i<arr.length;i++){arr2[i]=arr[i];}return arr2;}else{return Array.from(arr);}}/**
   * Map of screen types dependensed of screen width
   * @type {Object}
  */var __screenMap__={// Common types
  // Everything is less
  map:{'768':'mobile','1280':'tablet'},// Value as default
  default:'desktop'/**
   * Module name
   * @type {String}
   */};/**
   * @fileOverview Module for definition screen type by RxJS
   * For why? More comfortably using adaptive site created by screen types, than using particular sizes.
   * This addition absctract layer give to you flexible and maintainable.
   * How it works? Module define some kind of size (in this case it's screen width), that it receive and compare it with needed screen type.
   *
   * @author nanomen
   */// import Rx from 'rxjs'
  /**
   * Type for screen map object
   */var __name__='ScreenViewer';/**
   * Get module name
   * @return {String} module name
   */var getModuleName=function getModuleName(){return __name__;};/**
   * Get common screen map
   * @return {Object} map
   */var getScreenMap=function getScreenMap(){return __screenMap__.map;};/**
   * Get default screen type
   * @return {Object} default type
   */var getScreenMapDefault=function getScreenMapDefault(){return __screenMap__.default;};/**
   * Setup user screen map
   *
   * @param  {Object} screenMap
   *
   * @return {Object} return new screen map
   */var __setScreenMap__=function __setScreenMap__(screenMap){__screenMap__=screenMap;return __screenMap__;};/**
   * Method for init module, call for init observer
   *
   * @param {Array} observableList список потоков, обрабатывая которые, нужно проверять ширину экрана
   *                               по-умолчанию, передаем
   *
   *                               observable.on('load').map(() => window.innerWidth)
   *                               observable.on('ready').map(event => event.target.innerWidth)
   *                               observable.on('ready').map(event => event.target.innerWidth)
   *
   * @return {Rx} Поток изменяемой ширины и типов (приходит от совмещения других потоков)
   *              изменяется только тогда, когда меняется значение типа
   */var __init__=function __init__(observableList){var _Rx$Observable;if(!Array.isArray(observableList)||observableList.length<1){throw new Error('Module '+__name__+', to method init$, should pass an array with observables');}/**
      * Map of screen types
      * @type {Object}
      */var screenMap=getScreenMap();/**
     * Screen type as default
     * @type {String}
     */var screenMapDefault=getScreenMapDefault();/**
      * Observable from screen map
      * @type {Rx}
      */var screenMap$=void 0;// Setup screen types flow
  screenMap$=Rx.Observable.from(Object.keys(screenMap));/**
     * Association observable of widths (from merge passed observables)
     * @type {Rx}
     */return(_Rx$Observable=Rx.Observable// merge flows
  ).merge.apply(_Rx$Observable,_toConsumableArray(observableList))// Filter null values (passed from first render page)
  .filter(function(width){return!!width;})// Переключаемся на поток из карты типов,
  // передаем в него текущую ширину браузера
  .switchMap(function(width){return screenMap$// Фильтруем всех, кто больше, чем ширина браузера
  .filter(function(widthOfMap){return width<+widthOfMap;})// Преобразовываем значение в тип экрана,
  // если передается значение пустое, значит нужно подставлять тип по-умолчанию
  // говорит о том, что мы выше самой верхней границы типов
  .map(function(widthOfMap){return widthOfMap?screenMap[widthOfMap]:widthOfMap;})// Если после фильтрации, значения нет, подставляем по-умолчанию (последний в списке)
  .defaultIfEmpty(screenMapDefault)// Забираем первое значение из потока
  .first()// Преобразуем в результирующий объект с параметрами
  .map(function(type){return{width:width,type:type};});})// Фильтруем, пропуская только уникальные значения
  .distinctUntilChanged(function(prev,cur){return prev.type===cur.type;});};var/**
     * Установить новую карту типов экрана
     *
     * @param  {Object} userScreenMap пользовательская карта разрешений
     *
     * @return {Function} возвращаем метод инициализации, формирую цепочку
     *
     */setup=function setup(userScreenMap){__setScreenMap__(userScreenMap);return __init__;};exports.default={// Get module name
  getModuleName:getModuleName,// Get common screen map
  getScreenMap:getScreenMap,// Get default screen type
  getScreenMapDefault:getScreenMapDefault,// Setup user screen map
  setup:setup,// module init
  init$:__init__};/* WEBPACK VAR INJECTION */}).call(exports,__webpack_require__(1));/***/},/* 1 *//***/function(module,exports){module.exports=__WEBPACK_EXTERNAL_MODULE_1__;/***/}]/******/));});
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(459)(module)))
  
  /***/ }),
  /* 459 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  module.exports=function(module){if(!module.webpackPolyfill){module.deprecate=function(){};module.paths=[];// module.parent = undefined by default
  if(!module.children)module.children=[];Object.defineProperty(module,"loaded",{enumerable:true,get:function get(){return module.l;}});Object.defineProperty(module,"id",{enumerable:true,get:function get(){return module.i;}});module.webpackPolyfill=1;}return module;};
  
  /***/ })
  /******/ ]);