text: /**
   * angular2-multiselect-dropdown - Angular 2 and angular 4 multiselect dropdown component.
   * @version v2.10.2
   * @author undefined
   * @link undefined
   * @license MIT
   */
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"));
  	else if(typeof define === 'function' && define.amd)
  		define(["@angular/core", "@angular/common", "@angular/forms"], factory);
  	else if(typeof exports === 'object')
  		exports["ticktock"] = factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"));
  	else
  		root["ticktock"] = factory(root["ng"]["core"], root["ng"]["common"], root["ng"]["forms"]);
  })(this, function(__WEBPACK_EXTERNAL_MODULE_24__, __WEBPACK_EXTERNAL_MODULE_466__, __WEBPACK_EXTERNAL_MODULE_467__) {
  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;
  /******/
  /******/ 	// identity function for calling harmony imports with the correct context
  /******/ 	__webpack_require__.i = function(value) { return value; };
  /******/
  /******/ 	// 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 = 468);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var root_1 = __webpack_require__(9);
  var toSubscriber_1 = __webpack_require__(463);
  var observable_1 = __webpack_require__(33);
  var pipe_1 = __webpack_require__(58);
  /**
   * 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 ? 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 __extends = (this && this.__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__(38);
  var Subscription_1 = __webpack_require__(5);
  var Observer_1 = __webpack_require__(63);
  var rxSubscriber_1 = __webpack_require__(34);
  /**
   * 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 === 'object') {
                      if (destinationOrNext instanceof Subscriber) {
                          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 () { 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 = (this && this.__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__(160);
  var isPromise_1 = __webpack_require__(162);
  var isObject_1 = __webpack_require__(161);
  var Observable_1 = __webpack_require__(0);
  var iterator_1 = __webpack_require__(21);
  var InnerSubscriber_1 = __webpack_require__(170);
  var observable_1 = __webpack_require__(33);
  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__(19);
  var AsyncScheduler_1 = __webpack_require__(20);
  /**
   *
   * 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 isArray_1 = __webpack_require__(11);
  var isObject_1 = __webpack_require__(161);
  var isFunction_1 = __webpack_require__(38);
  var tryCatch_1 = __webpack_require__(8);
  var errorObject_1 = __webpack_require__(7);
  var UnsubscriptionError_1 = __webpack_require__(157);
  /**
   * 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) {
              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 = (this && this.__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__(36);
  var SubjectSubscription_1 = __webpack_require__(64);
  var rxSubscriber_1 = __webpack_require__(34);
  /**
   * @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__(164)))
  
  /***/ }),
  /* 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 = (this && this.__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__(40);
  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 = (this && this.__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__(65);
  /* 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 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
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var scan_1 = __webpack_require__(53);
  var takeLast_1 = __webpack_require__(55);
  var defaultIfEmpty_1 = __webpack_require__(46);
  var pipe_1 = __webpack_require__(58);
  /* 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
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(444);
  /**
   * 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
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(172);
  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
  
  /***/ }),
  /* 21 */
  /***/ (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
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 23 */
  /***/ (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
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE_24__;
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __metadata = (this && this.__metadata) || function (k, v) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var core_1 = __webpack_require__(24);
  var Item = /** @class */ (function () {
      function Item() {
      }
      __decorate([
          core_1.ContentChild(core_1.TemplateRef),
          __metadata("design:type", core_1.TemplateRef)
      ], Item.prototype, "template", void 0);
      Item = __decorate([
          core_1.Component({
              selector: 'c-item',
              template: ""
          }),
          __metadata("design:paramtypes", [])
      ], Item);
      return Item;
  }());
  exports.Item = Item;
  var Badge = /** @class */ (function () {
      function Badge() {
      }
      __decorate([
          core_1.ContentChild(core_1.TemplateRef),
          __metadata("design:type", core_1.TemplateRef)
      ], Badge.prototype, "template", void 0);
      Badge = __decorate([
          core_1.Component({
              selector: 'c-badge',
              template: ""
          }),
          __metadata("design:paramtypes", [])
      ], Badge);
      return Badge;
  }());
  exports.Badge = Badge;
  var Search = /** @class */ (function () {
      function Search() {
      }
      __decorate([
          core_1.ContentChild(core_1.TemplateRef),
          __metadata("design:type", core_1.TemplateRef)
      ], Search.prototype, "template", void 0);
      Search = __decorate([
          core_1.Component({
              selector: 'c-search',
              template: ""
          }),
          __metadata("design:paramtypes", [])
      ], Search);
      return Search;
  }());
  exports.Search = Search;
  var TemplateRenderer = /** @class */ (function () {
      function TemplateRenderer(viewContainer) {
          this.viewContainer = viewContainer;
      }
      TemplateRenderer.prototype.ngOnInit = function () {
          this.view = this.viewContainer.createEmbeddedView(this.data.template, {
              '\$implicit': this.data,
              'item': this.item
          });
      };
      TemplateRenderer.prototype.ngOnDestroy = function () {
          this.view.destroy();
      };
      __decorate([
          core_1.Input(),
          __metadata("design:type", Object)
      ], TemplateRenderer.prototype, "data", void 0);
      __decorate([
          core_1.Input(),
          __metadata("design:type", Object)
      ], TemplateRenderer.prototype, "item", void 0);
      TemplateRenderer = __decorate([
          core_1.Component({
              selector: 'c-templateRenderer',
              template: ""
          }),
          __metadata("design:paramtypes", [core_1.ViewContainerRef])
      ], TemplateRenderer);
      return TemplateRenderer;
  }());
  exports.TemplateRenderer = TemplateRenderer;
  
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(153);
  var Subscription_1 = __webpack_require__(5);
  var observeOn_1 = __webpack_require__(30);
  var ObjectUnsubscribedError_1 = __webpack_require__(36);
  var SubjectSubscription_1 = __webpack_require__(64);
  /**
   * @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
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeMap_1 = __webpack_require__(17);
  var identity_1 = __webpack_require__(159);
  /**
   * 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
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(15);
  /**
   *
   * 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
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(21);
  /* 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
  
  /***/ }),
  /* 33 */
  /***/ (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
  
  /***/ }),
  /* 34 */
  /***/ (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
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  function isDate(value) {
      return value instanceof Date && !isNaN(+value);
  }
  exports.isDate = isDate;
  //# sourceMappingURL=isDate.js.map
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  function isFunction(x) {
      return typeof x === 'function';
  }
  exports.isFunction = isFunction;
  //# sourceMappingURL=isFunction.js.map
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __metadata = (this && this.__metadata) || function (k, v) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var core_1 = __webpack_require__(24);
  var forms_1 = __webpack_require__(467);
  var common_1 = __webpack_require__(466);
  var multiselect_model_1 = __webpack_require__(165);
  var clickOutside_1 = __webpack_require__(59);
  var list_filter_1 = __webpack_require__(60);
  var menu_item_1 = __webpack_require__(25);
  var multiselect_service_1 = __webpack_require__(61);
  exports.DROPDOWN_CONTROL_VALUE_ACCESSOR = {
      provide: forms_1.NG_VALUE_ACCESSOR,
      useExisting: core_1.forwardRef(function () { return AngularMultiSelect; }),
      multi: true
  };
  exports.DROPDOWN_CONTROL_VALIDATION = {
      provide: forms_1.NG_VALIDATORS,
      useExisting: core_1.forwardRef(function () { return AngularMultiSelect; }),
      multi: true,
  };
  var noop = function () {
  };
  var AngularMultiSelect = /** @class */ (function () {
      function AngularMultiSelect(_elementRef, cdr, ds) {
          this._elementRef = _elementRef;
          this.cdr = cdr;
          this.ds = ds;
          this.onSelect = new core_1.EventEmitter();
          this.onDeSelect = new core_1.EventEmitter();
          this.onSelectAll = new core_1.EventEmitter();
          this.onDeSelectAll = new core_1.EventEmitter();
          this.onOpen = new core_1.EventEmitter();
          this.onClose = new core_1.EventEmitter();
          this.isActive = false;
          this.isSelectAll = false;
          this.isFilterSelectAll = false;
          this.isInfiniteFilterSelectAll = false;
          this.chunkIndex = [];
          this.cachedItems = [];
          this.itemHeight = 41.6;
          this.filterLength = 0;
          this.infiniteFilterLength = 0;
          this.defaultSettings = {
              singleSelection: false,
              text: 'Select',
              enableCheckAll: true,
              selectAllText: 'Select All',
              unSelectAllText: 'UnSelect All',
              filterSelectAllText: 'Select all filtered results',
              filterUnSelectAllText: 'UnSelect all filtered results',
              enableSearchFilter: false,
              searchBy: [],
              maxHeight: 300,
              badgeShowLimit: 999999999999,
              classes: '',
              disabled: false,
              searchPlaceholderText: 'Search',
              showCheckbox: true,
              noDataLabel: 'No Data Available',
              searchAutofocus: true,
              lazyLoading: false,
              labelKey: 'itemName',
              primaryKey: 'id',
              position: 'bottom',
              enableFilterSelectAll: true
          };
          this.filteredList = [];
          this.onTouchedCallback = noop;
          this.onChangeCallback = noop;
      }
      AngularMultiSelect.prototype.ngOnInit = function () {
          var _this = this;
          this.settings = Object.assign(this.defaultSettings, this.settings);
          if (this.settings.groupBy) {
              this.groupedData = this.transformData(this.data, this.settings.groupBy);
          }
          this.totalRows = (this.data && this.data.length);
          this.cachedItems = this.data;
          this.screenItemsLen = Math.ceil(this.settings.maxHeight / this.itemHeight);
          this.cachedItemsLen = this.screenItemsLen * 3;
          this.totalHeight = this.itemHeight * this.totalRows;
          this.maxBuffer = this.screenItemsLen * this.itemHeight;
          this.lastScrolled = 0;
          this.renderChunk(0, this.cachedItemsLen / 2);
          if (this.settings.position == 'top') {
              setTimeout(function () {
                  _this.selectedListHeight = { val: 0 };
                  _this.selectedListHeight.val = _this.selectedListElem.nativeElement.clientHeight;
              });
          }
          this.subscription = this.ds.getData().subscribe(function (data) {
              _this.filterLength = data.length;
              _this.onFilterChange(data);
          });
      };
      AngularMultiSelect.prototype.ngOnChanges = function (changes) {
          if (changes.data && !changes.data.firstChange) {
              if (this.settings.groupBy) {
                  this.groupedData = this.transformData(this.data, this.settings.groupBy);
                  if (this.data.length == 0) {
                      this.selectedItems = [];
                  }
              }
          }
          if (changes.settings && !changes.settings.firstChange) {
              this.settings = Object.assign(this.defaultSettings, this.settings);
          }
      };
      AngularMultiSelect.prototype.ngDoCheck = function () {
          if (this.selectedItems) {
              if (this.selectedItems.length == 0 || this.data.length == 0 || this.selectedItems.length < this.data.length) {
                  this.isSelectAll = false;
              }
          }
      };
      AngularMultiSelect.prototype.ngAfterViewInit = function () {
          if (this.settings.lazyLoading) {
              this._elementRef.nativeElement.getElementsByClassName("lazyContainer")[0].addEventListener('scroll', this.onScroll.bind(this));
          }
      };
      AngularMultiSelect.prototype.ngAfterViewChecked = function () {
          if (this.selectedListElem.nativeElement.clientHeight && this.settings.position == 'top' && this.selectedListHeight) {
              this.selectedListHeight.val = this.selectedListElem.nativeElement.clientHeight;
              this.cdr.detectChanges();
          }
      };
      AngularMultiSelect.prototype.onItemClick = function (item, index, evt) {
          if (this.settings.disabled) {
              return false;
          }
          var found = this.isSelected(item);
          var limit = this.selectedItems.length < this.settings.limitSelection ? true : false;
          if (!found) {
              if (this.settings.limitSelection) {
                  if (limit) {
                      this.addSelected(item);
                      this.onSelect.emit(item);
                  }
              }
              else {
                  this.addSelected(item);
                  this.onSelect.emit(item);
              }
          }
          else {
              this.removeSelected(item);
              this.onDeSelect.emit(item);
          }
          if (this.isSelectAll || this.data.length > this.selectedItems.length) {
              this.isSelectAll = false;
          }
          if (this.data.length == this.selectedItems.length) {
              this.isSelectAll = true;
          }
      };
      AngularMultiSelect.prototype.validate = function (c) {
          return null;
      };
      AngularMultiSelect.prototype.writeValue = function (value) {
          if (value !== undefined && value !== null) {
              if (this.settings.singleSelection) {
                  try {
                      if (value.length > 1) {
                          this.selectedItems = [value[0]];
                          throw new multiselect_model_1.MyException(404, { "msg": "Single Selection Mode, Selected Items cannot have more than one item." });
                      }
                      else {
                          this.selectedItems = value;
                      }
                  }
                  catch (e) {
                      console.error(e.body.msg);
                  }
              }
              else {
                  if (this.settings.limitSelection) {
                      this.selectedItems = value.slice(0, this.settings.limitSelection);
                  }
                  else {
                      this.selectedItems = value;
                  }
                  if (this.selectedItems.length === this.data.length && this.data.length > 0) {
                      this.isSelectAll = true;
                  }
              }
          }
          else {
              this.selectedItems = [];
          }
      };
      //From ControlValueAccessor interface
      AngularMultiSelect.prototype.registerOnChange = function (fn) {
          this.onChangeCallback = fn;
      };
      //From ControlValueAccessor interface
      AngularMultiSelect.prototype.registerOnTouched = function (fn) {
          this.onTouchedCallback = fn;
      };
      AngularMultiSelect.prototype.trackByFn = function (index, item) {
          return item[this.settings.primaryKey];
      };
      AngularMultiSelect.prototype.isSelected = function (clickedItem) {
          var _this = this;
          var found = false;
          this.selectedItems && this.selectedItems.forEach(function (item) {
              if (clickedItem[_this.settings.primaryKey] === item[_this.settings.primaryKey]) {
                  found = true;
              }
          });
          return found;
      };
      AngularMultiSelect.prototype.addSelected = function (item) {
          if (this.settings.singleSelection) {
              this.selectedItems = [];
              this.selectedItems.push(item);
              this.closeDropdown();
          }
          else
              this.selectedItems.push(item);
          this.onChangeCallback(this.selectedItems);
          this.onTouchedCallback(this.selectedItems);
      };
      AngularMultiSelect.prototype.removeSelected = function (clickedItem) {
          var _this = this;
          this.selectedItems && this.selectedItems.forEach(function (item) {
              if (clickedItem[_this.settings.primaryKey] === item[_this.settings.primaryKey]) {
                  _this.selectedItems.splice(_this.selectedItems.indexOf(item), 1);
              }
          });
          this.onChangeCallback(this.selectedItems);
          this.onTouchedCallback(this.selectedItems);
      };
      AngularMultiSelect.prototype.toggleDropdown = function (evt) {
          var _this = this;
          if (this.settings.disabled) {
              return false;
          }
          this.isActive = !this.isActive;
          if (this.isActive && this.searchInput) {
              if (this.settings.searchAutofocus && this.settings.enableSearchFilter && !this.searchTempl) {
                  setTimeout(function () {
                      _this.searchInput.nativeElement.focus();
                  }, 0);
              }
              this.onOpen.emit(true);
          }
          else {
              this.onClose.emit(false);
          }
          evt.preventDefault();
      };
      AngularMultiSelect.prototype.closeDropdown = function () {
          if (this.searchInput && this.settings.lazyLoading) {
              this.searchInput.nativeElement.value = "";
              this.data = [];
              this.data = this.cachedItems;
              this.totalHeight = this.itemHeight * this.data.length;
              this.totalRows = this.data.length;
              this.updateView(this.scrollTop);
          }
          if (this.searchInput) {
              this.searchInput.nativeElement.value = "";
          }
          this.filter = "";
          this.isActive = false;
          this.onClose.emit(false);
      };
      AngularMultiSelect.prototype.toggleSelectAll = function () {
          console.log(this.ds.getData());
          console.log(this.filter);
          if (!this.isSelectAll) {
              this.selectedItems = [];
              this.selectedItems = this.data.slice();
              this.isSelectAll = true;
              this.onChangeCallback(this.selectedItems);
              this.onTouchedCallback(this.selectedItems);
              this.onSelectAll.emit(this.selectedItems);
          }
          else {
              this.selectedItems = [];
              this.isSelectAll = false;
              this.onChangeCallback(this.selectedItems);
              this.onTouchedCallback(this.selectedItems);
              this.onDeSelectAll.emit(this.selectedItems);
          }
      };
      AngularMultiSelect.prototype.toggleFilterSelectAll = function () {
          var _this = this;
          if (!this.isFilterSelectAll) {
              this.ds.getFilteredData().forEach(function (item) {
                  if (!_this.isSelected(item)) {
                      _this.addSelected(item);
                  }
              });
              this.isFilterSelectAll = true;
          }
          else {
              this.ds.getFilteredData().forEach(function (item) {
                  if (_this.isSelected(item)) {
                      _this.removeSelected(item);
                  }
              });
              this.isFilterSelectAll = false;
          }
      };
      AngularMultiSelect.prototype.toggleInfiniteFilterSelectAll = function () {
          var _this = this;
          if (!this.isInfiniteFilterSelectAll) {
              this.data.forEach(function (item) {
                  if (!_this.isSelected(item)) {
                      _this.addSelected(item);
                  }
              });
              this.isInfiniteFilterSelectAll = true;
          }
          else {
              this.data.forEach(function (item) {
                  if (_this.isSelected(item)) {
                      _this.removeSelected(item);
                  }
              });
              this.isInfiniteFilterSelectAll = false;
          }
      };
      AngularMultiSelect.prototype.clearSearch = function () {
          this.filter = "";
          this.isFilterSelectAll = false;
      };
      AngularMultiSelect.prototype.onFilterChange = function (data) {
          var _this = this;
          if (this.filter && this.filter == "" || data.length == 0) {
              this.isFilterSelectAll = false;
          }
          var cnt = 0;
          data.forEach(function (item) {
              if (_this.isSelected(item)) {
                  cnt++;
              }
          });
          if (cnt > 0 && this.filterLength == cnt) {
              this.isFilterSelectAll = true;
          }
          else if (cnt > 0 && this.filterLength != cnt) {
              this.isFilterSelectAll = false;
          }
          this.cdr.detectChanges();
      };
      AngularMultiSelect.prototype.transformData = function (arr, field) {
          var groupedObj = arr.reduce(function (prev, cur) {
              if (!prev[cur[field]]) {
                  prev[cur[field]] = [cur];
              }
              else {
                  prev[cur[field]].push(cur);
              }
              return prev;
          }, {});
          var tempArr = [];
          Object.keys(groupedObj).map(function (x) {
              tempArr.push({ key: x, value: groupedObj[x] });
          });
          return tempArr;
      };
      AngularMultiSelect.prototype.renderChunk = function (fromPos, howMany) {
          this.chunkArray = [];
          this.chunkIndex = [];
          var finalItem = fromPos + howMany;
          if (finalItem > this.totalRows)
              finalItem = this.totalRows;
          for (var i = fromPos; i < finalItem; i++) {
              this.chunkIndex.push((i * this.itemHeight) + 'px');
              this.chunkArray.push(this.data[i]);
          }
      };
      AngularMultiSelect.prototype.onScroll = function (e) {
          this.scrollTop = e.target.scrollTop;
          this.updateView(this.scrollTop);
      };
      AngularMultiSelect.prototype.updateView = function (scrollTop) {
          var scrollPos = scrollTop ? scrollTop : 0;
          var first = (scrollPos / this.itemHeight) - this.screenItemsLen;
          var firstTemp = "" + first;
          first = parseInt(firstTemp) < 0 ? 0 : parseInt(firstTemp);
          this.renderChunk(first, this.cachedItemsLen);
          this.lastRepaintY = scrollPos;
      };
      AngularMultiSelect.prototype.filterInfiniteList = function (evt) {
          var filteredElems = [];
          this.data = this.cachedItems.slice();
          if (evt.target.value.toString() != '') {
              this.data.filter(function (el) {
                  for (var prop in el) {
                      if (el[prop].toString().toLowerCase().indexOf(evt.target.value.toString().toLowerCase()) >= 0) {
                          filteredElems.push(el);
                          break;
                      }
                  }
              });
              //this.cachedItems = this.data;
              this.totalHeight = this.itemHeight * filteredElems.length;
              this.totalRows = filteredElems.length;
              this.data = [];
              this.data = filteredElems;
              this.infiniteFilterLength = this.data.length;
              this.updateView(this.scrollTop);
          }
          else if (evt.target.value.toString() == '' && this.cachedItems.length > 0) {
              this.data = [];
              this.data = this.cachedItems;
              this.totalHeight = this.itemHeight * this.data.length;
              this.totalRows = this.data.length;
              this.infiniteFilterLength = 0;
              this.updateView(this.scrollTop);
          }
      };
      AngularMultiSelect.prototype.resetInfiniteSearch = function () {
          this.filter = "";
          this.isInfiniteFilterSelectAll = false;
          this.data = [];
          this.data = this.cachedItems;
          this.totalHeight = this.itemHeight * this.data.length;
          this.totalRows = this.data.length;
          this.infiniteFilterLength = 0;
          this.updateView(this.scrollTop);
      };
      AngularMultiSelect.prototype.ngOnDestroy = function () {
          this.subscription.unsubscribe();
      };
      __decorate([
          core_1.Input(),
          __metadata("design:type", Array)
      ], AngularMultiSelect.prototype, "data", void 0);
      __decorate([
          core_1.Input(),
          __metadata("design:type", Object)
      ], AngularMultiSelect.prototype, "settings", void 0);
      __decorate([
          core_1.Output('onSelect'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onSelect", void 0);
      __decorate([
          core_1.Output('onDeSelect'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onDeSelect", void 0);
      __decorate([
          core_1.Output('onSelectAll'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onSelectAll", void 0);
      __decorate([
          core_1.Output('onDeSelectAll'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onDeSelectAll", void 0);
      __decorate([
          core_1.Output('onOpen'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onOpen", void 0);
      __decorate([
          core_1.Output('onClose'),
          __metadata("design:type", core_1.EventEmitter)
      ], AngularMultiSelect.prototype, "onClose", void 0);
      __decorate([
          core_1.ContentChild(menu_item_1.Item),
          __metadata("design:type", menu_item_1.Item)
      ], AngularMultiSelect.prototype, "itemTempl", void 0);
      __decorate([
          core_1.ContentChild(menu_item_1.Badge),
          __metadata("design:type", menu_item_1.Badge)
      ], AngularMultiSelect.prototype, "badgeTempl", void 0);
      __decorate([
          core_1.ContentChild(menu_item_1.Search),
          __metadata("design:type", menu_item_1.Search)
      ], AngularMultiSelect.prototype, "searchTempl", void 0);
      __decorate([
          core_1.ViewChild('searchInput'),
          __metadata("design:type", core_1.ElementRef)
      ], AngularMultiSelect.prototype, "searchInput", void 0);
      __decorate([
          core_1.ViewChild('selectedList'),
          __metadata("design:type", core_1.ElementRef)
      ], AngularMultiSelect.prototype, "selectedListElem", void 0);
      AngularMultiSelect = __decorate([
          core_1.Component({
              selector: 'angular2-multiselect',
              template: __webpack_require__(169),
              host: { '[class]': 'defaultSettings.classes' },
              styles: [__webpack_require__(465)],
              providers: [exports.DROPDOWN_CONTROL_VALUE_ACCESSOR, exports.DROPDOWN_CONTROL_VALIDATION],
          }),
          __metadata("design:paramtypes", [core_1.ElementRef, core_1.ChangeDetectorRef, multiselect_service_1.DataService])
      ], AngularMultiSelect);
      return AngularMultiSelect;
  }());
  exports.AngularMultiSelect = AngularMultiSelect;
  var AngularMultiSelectModule = /** @class */ (function () {
      function AngularMultiSelectModule() {
      }
      AngularMultiSelectModule = __decorate([
          core_1.NgModule({
              imports: [common_1.CommonModule, forms_1.FormsModule],
              declarations: [AngularMultiSelect, clickOutside_1.ClickOutsideDirective, clickOutside_1.ScrollDirective, clickOutside_1.styleDirective, list_filter_1.ListFilterPipe, menu_item_1.Item, menu_item_1.TemplateRenderer, menu_item_1.Badge, menu_item_1.Search, clickOutside_1.setPosition],
              exports: [AngularMultiSelect, clickOutside_1.ClickOutsideDirective, clickOutside_1.ScrollDirective, clickOutside_1.styleDirective, list_filter_1.ListFilterPipe, menu_item_1.Item, menu_item_1.TemplateRenderer, menu_item_1.Badge, menu_item_1.Search, clickOutside_1.setPosition],
              providers: [multiselect_service_1.DataService]
          })
      ], AngularMultiSelectModule);
      return AngularMultiSelectModule;
  }());
  exports.AngularMultiSelectModule = AngularMultiSelectModule;
  
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var isScheduler_1 = __webpack_require__(10);
  var of_1 = __webpack_require__(70);
  var from_1 = __webpack_require__(69);
  var concatAll_1 = __webpack_require__(44);
  /* 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
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 44 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeAll_1 = __webpack_require__(29);
  /**
   * 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
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeMap_1 = __webpack_require__(17);
  /* 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
  
  /***/ }),
  /* 46 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 47 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 48 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 49 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 50 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var ArrayObservable_1 = __webpack_require__(12);
  var mergeAll_1 = __webpack_require__(29);
  var isScheduler_1 = __webpack_require__(10);
  /* tslint:enable:max-line-length */
  function merge() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      return function (source) { return source.lift.call(mergeStatic.apply(void 0, [source].concat(observables))); };
  }
  exports.merge = 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 (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 mergeStatic() {
      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.mergeStatic = mergeStatic;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 51 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 52 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 53 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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 () {
              return this._seed;
          },
          set: function (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
  
  /***/ }),
  /* 54 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 55 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(22);
  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
  
  /***/ }),
  /* 56 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var map_1 = __webpack_require__(16);
  /**
   * @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";
  
  /* tslint:disable:no-empty */
  function noop() { }
  exports.noop = noop;
  //# sourceMappingURL=noop.js.map
  
  /***/ }),
  /* 58 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var noop_1 = __webpack_require__(57);
  /* 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
  
  /***/ }),
  /* 59 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __metadata = (this && this.__metadata) || function (k, v) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var core_1 = __webpack_require__(24);
  var ClickOutsideDirective = /** @class */ (function () {
      function ClickOutsideDirective(_elementRef) {
          this._elementRef = _elementRef;
          this.clickOutside = new core_1.EventEmitter();
      }
      ClickOutsideDirective.prototype.onClick = function (event, targetElement) {
          if (!targetElement) {
              return;
          }
          var clickedInside = this._elementRef.nativeElement.contains(targetElement);
          if (!clickedInside) {
              this.clickOutside.emit(event);
          }
      };
      __decorate([
          core_1.Output(),
          __metadata("design:type", Object)
      ], ClickOutsideDirective.prototype, "clickOutside", void 0);
      __decorate([
          core_1.HostListener('document:click', ['$event', '$event.target']),
          core_1.HostListener('document:touchstart', ['$event', '$event.target']),
          __metadata("design:type", Function),
          __metadata("design:paramtypes", [MouseEvent, HTMLElement]),
          __metadata("design:returntype", void 0)
      ], ClickOutsideDirective.prototype, "onClick", null);
      ClickOutsideDirective = __decorate([
          core_1.Directive({
              selector: '[clickOutside]'
          }),
          __metadata("design:paramtypes", [core_1.ElementRef])
      ], ClickOutsideDirective);
      return ClickOutsideDirective;
  }());
  exports.ClickOutsideDirective = ClickOutsideDirective;
  var ScrollDirective = /** @class */ (function () {
      function ScrollDirective(_elementRef) {
          this._elementRef = _elementRef;
          this.scroll = new core_1.EventEmitter();
      }
      ScrollDirective.prototype.onClick = function (event, targetElement) {
          this.scroll.emit(event);
      };
      __decorate([
          core_1.Output(),
          __metadata("design:type", Object)
      ], ScrollDirective.prototype, "scroll", void 0);
      __decorate([
          core_1.HostListener('scroll', ['$event']),
          __metadata("design:type", Function),
          __metadata("design:paramtypes", [MouseEvent, HTMLElement]),
          __metadata("design:returntype", void 0)
      ], ScrollDirective.prototype, "onClick", null);
      ScrollDirective = __decorate([
          core_1.Directive({
              selector: '[scroll]'
          }),
          __metadata("design:paramtypes", [core_1.ElementRef])
      ], ScrollDirective);
      return ScrollDirective;
  }());
  exports.ScrollDirective = ScrollDirective;
  var styleDirective = /** @class */ (function () {
      function styleDirective(el) {
          this.el = el;
      }
      styleDirective.prototype.ngOnInit = function () {
          this.el.nativeElement.style.top = this.styleVal;
      };
      styleDirective.prototype.ngOnChanges = function () {
          this.el.nativeElement.style.top = this.styleVal;
      };
      __decorate([
          core_1.Input('styleProp'),
          __metadata("design:type", Number)
      ], styleDirective.prototype, "styleVal", void 0);
      styleDirective = __decorate([
          core_1.Directive({
              selector: '[styleProp]'
          }),
          __metadata("design:paramtypes", [core_1.ElementRef])
      ], styleDirective);
      return styleDirective;
  }());
  exports.styleDirective = styleDirective;
  var setPosition = /** @class */ (function () {
      function setPosition(el) {
          this.el = el;
      }
      setPosition.prototype.ngOnInit = function () {
          if (this.height) {
              this.el.nativeElement.style.bottom = parseInt(this.height + 15 + "") + 'px';
          }
      };
      setPosition.prototype.ngOnChanges = function () {
          if (this.height) {
              this.el.nativeElement.style.bottom = parseInt(this.height + 15 + "") + 'px';
          }
      };
      __decorate([
          core_1.Input('setPosition'),
          __metadata("design:type", Number)
      ], setPosition.prototype, "height", void 0);
      setPosition = __decorate([
          core_1.Directive({
              selector: '[setPosition]'
          }),
          __metadata("design:paramtypes", [core_1.ElementRef])
      ], setPosition);
      return setPosition;
  }());
  exports.setPosition = setPosition;
  
  
  /***/ }),
  /* 60 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __metadata = (this && this.__metadata) || function (k, v) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var core_1 = __webpack_require__(24);
  var multiselect_service_1 = __webpack_require__(61);
  var ListFilterPipe = /** @class */ (function () {
      function ListFilterPipe(ds) {
          this.ds = ds;
          this.filteredList = [];
      }
      ListFilterPipe.prototype.transform = function (items, filter, searchBy) {
          var _this = this;
          if (!items || !filter) {
              this.ds.setData(items);
              return items;
          }
          this.filteredList = items.filter(function (item) { return _this.applyFilter(item, filter, searchBy); });
          this.ds.setData(this.filteredList);
          return this.filteredList;
      };
      ListFilterPipe.prototype.applyFilter = function (item, filter, searchBy) {
          var found = false;
          if (searchBy.length > 0) {
              for (var t = 0; t < searchBy.length; t++) {
                  if (filter && item[searchBy[t]] && item[searchBy[t]] != "") {
                      if (item[searchBy[t]].toString().toLowerCase().indexOf(filter.toLowerCase()) >= 0) {
                          found = true;
                      }
                  }
              }
          }
          else {
              for (var prop in item) {
                  if (filter && item[prop]) {
                      if (item[prop].toString().toLowerCase().indexOf(filter.toLowerCase()) >= 0) {
                          found = true;
                      }
                  }
              }
          }
          return found;
      };
      ListFilterPipe = __decorate([
          core_1.Pipe({
              name: 'listFilter',
              pure: true
          }),
          __metadata("design:paramtypes", [multiselect_service_1.DataService])
      ], ListFilterPipe);
      return ListFilterPipe;
  }());
  exports.ListFilterPipe = ListFilterPipe;
  
  
  /***/ }),
  /* 61 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var core_1 = __webpack_require__(24);
  var rxjs_1 = __webpack_require__(171);
  var DataService = /** @class */ (function () {
      function DataService() {
          this.filteredData = [];
          this.subject = new rxjs_1.Subject();
      }
      DataService.prototype.setData = function (data) {
          this.filteredData = data;
          this.subject.next(data);
      };
      DataService.prototype.getData = function () {
          return this.subject.asObservable();
      };
      DataService.prototype.getFilteredData = function () {
          if (this.filteredData && this.filteredData.length > 0) {
              return this.filteredData;
          }
          else {
              return [];
          }
      };
      DataService = __decorate([
          core_1.Injectable()
      ], DataService);
      return DataService;
  }());
  exports.DataService = DataService;
  
  
  /***/ }),
  /* 62 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(36);
  /**
   * @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 () {
              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
  
  /***/ }),
  /* 63 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  exports.empty = {
      closed: true,
      next: function (value) { },
      error: function (err) { throw err; },
      complete: function () { }
  };
  //# sourceMappingURL=Observer.js.map
  
  /***/ }),
  /* 64 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 65 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(52);
  /**
   * @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
  
  /***/ }),
  /* 66 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(160);
  var isPromise_1 = __webpack_require__(162);
  var PromiseObservable_1 = __webpack_require__(67);
  var IteratorObservable_1 = __webpack_require__(313);
  var ArrayObservable_1 = __webpack_require__(12);
  var ArrayLikeObservable_1 = __webpack_require__(302);
  var iterator_1 = __webpack_require__(21);
  var Observable_1 = __webpack_require__(0);
  var observeOn_1 = __webpack_require__(30);
  var observable_1 = __webpack_require__(33);
  /**
   * 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 || 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 = (this && this.__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";
  
  var __extends = (this && this.__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__(16);
  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 () {
                  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 (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_1;
                  xhrProgress_1 = function (e) {
                      var progressSubscriber = xhrProgress_1.progressSubscriber;
                      progressSubscriber.next(e);
                  };
                  if (root_1.root.XDomainRequest) {
                      xhr.onprogress = xhrProgress_1;
                  }
                  else {
                      xhr.upload.onprogress = xhrProgress_1;
                  }
                  xhrProgress_1.progressSubscriber = progressSubscriber;
              }
              var xhrError_1;
              xhrError_1 = function (e) {
                  var _a = xhrError_1, 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_1;
              xhrError_1.request = request;
              xhrError_1.subscriber = this;
              xhrError_1.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
  
  /***/ }),
  /* 69 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var FromObservable_1 = __webpack_require__(66);
  exports.from = FromObservable_1.FromObservable.create;
  //# sourceMappingURL=from.js.map
  
  /***/ }),
  /* 70 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ArrayObservable_1 = __webpack_require__(12);
  exports.of = ArrayObservable_1.ArrayObservable.of;
  //# sourceMappingURL=of.js.map
  
  /***/ }),
  /* 71 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var TimerObservable_1 = __webpack_require__(318);
  exports.timer = TimerObservable_1.TimerObservable.create;
  //# sourceMappingURL=timer.js.map
  
  /***/ }),
  /* 72 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var merge_1 = __webpack_require__(50);
  var merge_2 = __webpack_require__(50);
  exports.mergeStatic = merge_2.mergeStatic;
  /* 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
  
  /***/ }),
  /* 73 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var timeInterval_1 = __webpack_require__(140);
  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
  
  /***/ }),
  /* 74 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var audit_1 = __webpack_require__(43);
  var timer_1 = __webpack_require__(71);
  /**
   * 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
  
  /***/ }),
  /* 75 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 76 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 77 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 78 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 79 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 80 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 81 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var combineLatest_1 = __webpack_require__(28);
  function combineAll(project) {
      return function (source) { return source.lift(new combineLatest_1.CombineLatestOperator(project)); };
  }
  exports.combineAll = combineAll;
  //# sourceMappingURL=combineAll.js.map
  
  /***/ }),
  /* 82 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concat_1 = __webpack_require__(41);
  /* 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
  
  /***/ }),
  /* 83 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concatMap_1 = __webpack_require__(45);
  /* 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
  
  /***/ }),
  /* 84 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 85 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 86 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 87 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(37);
  var Subscriber_1 = __webpack_require__(1);
  var Notification_1 = __webpack_require__(15);
  /**
   * 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
  
  /***/ }),
  /* 88 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 89 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 90 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(460);
  /**
   * 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
  
  /***/ }),
  /* 91 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var distinctUntilChanged_1 = __webpack_require__(47);
  /* 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
  
  /***/ }),
  /* 92 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(22);
  /**
   * 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
  
  /***/ }),
  /* 93 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 94 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 95 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 96 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 97 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 98 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var find_1 = __webpack_require__(49);
  /**
   * 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
  
  /***/ }),
  /* 99 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(35);
  /**
   * 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
  
  /***/ }),
  /* 100 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(458);
  var FastMap_1 = __webpack_require__(456);
  /* 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
  
  /***/ }),
  /* 101 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(57);
  /**
   * 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
  
  /***/ }),
  /* 102 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 103 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(35);
  /* 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
  
  /***/ }),
  /* 104 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 105 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(15);
  /**
   * 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
  
  /***/ }),
  /* 106 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var reduce_1 = __webpack_require__(18);
  /**
   * 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
  
  /***/ }),
  /* 107 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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 = (this && this.__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__(18);
  /**
   * 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 = (this && this.__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
  
  /***/ }),
  /* 111 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var not_1 = __webpack_require__(462);
  var filter_1 = __webpack_require__(48);
  /**
   * 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
  
  /***/ }),
  /* 112 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var map_1 = __webpack_require__(16);
  /**
   * 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 (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
  
  /***/ }),
  /* 113 */
  /***/ (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
  
  /***/ }),
  /* 114 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var BehaviorSubject_1 = __webpack_require__(62);
  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
  
  /***/ }),
  /* 115 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var AsyncSubject_1 = __webpack_require__(26);
  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
  
  /***/ }),
  /* 116 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ReplaySubject_1 = __webpack_require__(27);
  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
  
  /***/ }),
  /* 117 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var isArray_1 = __webpack_require__(11);
  var race_1 = __webpack_require__(42);
  /* 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
  
  /***/ }),
  /* 118 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 119 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 120 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 121 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 122 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 123 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 124 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 125 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var multicast_1 = __webpack_require__(14);
  var refCount_1 = __webpack_require__(52);
  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
  
  /***/ }),
  /* 126 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ReplaySubject_1 = __webpack_require__(27);
  /**
   * @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 (value) { subject.next(value); },
                  error: function (err) {
                      hasError = true;
                      subject.error(err);
                  },
                  complete: function () {
                      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
  
  /***/ }),
  /* 127 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(35);
  /**
   * 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
  
  /***/ }),
  /* 128 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 129 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(22);
  /**
   * 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
  
  /***/ }),
  /* 130 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 131 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 132 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ArrayObservable_1 = __webpack_require__(12);
  var ScalarObservable_1 = __webpack_require__(40);
  var EmptyObservable_1 = __webpack_require__(13);
  var concat_1 = __webpack_require__(41);
  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
  
  /***/ }),
  /* 133 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var switchMap_1 = __webpack_require__(54);
  var identity_1 = __webpack_require__(159);
  function switchAll() {
      return switchMap_1.switchMap(identity_1.identity);
  }
  exports.switchAll = switchAll;
  //# sourceMappingURL=switchAll.js.map
  
  /***/ }),
  /* 134 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 135 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(22);
  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
  
  /***/ }),
  /* 136 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 137 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 138 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 139 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(31);
  /**
   * 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
  
  /***/ }),
  /* 140 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 141 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(37);
  var Subscriber_1 = __webpack_require__(1);
  var TimeoutError_1 = __webpack_require__(156);
  /**
   *
   * 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
  
  /***/ }),
  /* 142 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(37);
  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
  
  /***/ }),
  /* 143 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var reduce_1 = __webpack_require__(18);
  function toArrayReducer(arr, item, index) {
      arr.push(item);
      return arr;
  }
  function toArray() {
      return reduce_1.reduce(toArrayReducer, []);
  }
  exports.toArray = toArray;
  //# sourceMappingURL=toArray.js.map
  
  /***/ }),
  /* 144 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 145 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 146 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(23);
  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 () {
              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
  
  /***/ }),
  /* 147 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 148 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 149 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 150 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var zip_1 = __webpack_require__(32);
  function zipAll(project) {
      return function (source) { return source.lift(new zip_1.ZipOperator(project)); };
  }
  exports.zipAll = zipAll;
  //# sourceMappingURL=zipAll.js.map
  
  /***/ }),
  /* 151 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(19);
  var AsyncScheduler_1 = __webpack_require__(20);
  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
  
  /***/ }),
  /* 152 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var AsapAction_1 = __webpack_require__(447);
  var AsapScheduler_1 = __webpack_require__(448);
  /**
   *
   * 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
  
  /***/ }),
  /* 153 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var QueueAction_1 = __webpack_require__(449);
  var QueueScheduler_1 = __webpack_require__(450);
  /**
   *
   * 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
  
  /***/ }),
  /* 154 */
  /***/ (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
  
  /***/ }),
  /* 155 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var SubscriptionLog_1 = __webpack_require__(154);
  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
  
  /***/ }),
  /* 156 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 157 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 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";
  
  function identity(x) {
      return x;
  }
  exports.identity = identity;
  //# sourceMappingURL=identity.js.map
  
  /***/ }),
  /* 160 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  exports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });
  //# sourceMappingURL=isArrayLike.js.map
  
  /***/ }),
  /* 161 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  function isObject(x) {
      return x != null && typeof x === 'object';
  }
  exports.isObject = isObject;
  //# sourceMappingURL=isObject.js.map
  
  /***/ }),
  /* 162 */
  /***/ (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
  
  /***/ }),
  /* 163 */
  /***/ (function(module, exports, __webpack_require__) {
  
  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__(464);
  exports.setImmediate = setImmediate;
  exports.clearImmediate = clearImmediate;
  
  
  /***/ }),
  /* 164 */
  /***/ (function(module, exports) {
  
  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 === "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;
  
  
  /***/ }),
  /* 165 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  var MyException = /** @class */ (function () {
      function MyException(status, body) {
          this.status = status;
          this.body = body;
      }
      return MyException;
  }());
  exports.MyException = MyException;
  
  
  /***/ }),
  /* 166 */
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(167)(undefined);
  // imports
  
  
  // module
  exports.push([module.i, ".cuppa-dropdown {\n  position: relative; }\n\n.c-btn {\n  display: inline-block;\n  background: #fff;\n  border: 1px solid #ccc;\n  border-radius: 3px;\n  font-size: 14px;\n  color: #333; }\n\n.c-btn.disabled {\n  background: #ccc; }\n\n.selected-list .c-list {\n  float: left;\n  padding: 0px;\n  margin: 0px;\n  width: calc(100% - 20px); }\n  .selected-list .c-list .c-token {\n    list-style: none;\n    padding: 2px 8px;\n    background: #0079FE;\n    color: #fff;\n    border-radius: 2px;\n    margin-right: 4px;\n    margin-top: 2px;\n    float: left;\n    position: relative;\n    padding-right: 25px; }\n    .selected-list .c-list .c-token .c-label {\n      display: block;\n      float: left; }\n    .selected-list .c-list .c-token .c-remove {\n      position: absolute;\n      right: 8px;\n      top: 50%;\n      transform: translateY(-50%);\n      width: 10px; }\n      .selected-list .c-list .c-token .c-remove svg {\n        fill: #fff; }\n\n.selected-list .fa-angle-down, .selected-list .fa-angle-up {\n  font-size: 15pt;\n  position: absolute;\n  right: 10px;\n  top: 50%;\n  transform: translateY(-50%); }\n\n.selected-list .c-angle-down, .selected-list .c-angle-up {\n  width: 15px;\n  height: 15px;\n  position: absolute;\n  right: 10px;\n  top: 50%;\n  transform: translateY(-50%);\n  pointer-events: none; }\n  .selected-list .c-angle-down svg, .selected-list .c-angle-up svg {\n    fill: #333; }\n\n.selected-list .countplaceholder {\n  position: absolute;\n  right: 30px;\n  top: 50%;\n  transform: translateY(-50%); }\n\n.selected-list .c-btn {\n  width: 100%;\n  /*        box-shadow: 0px 1px 5px $box-shadow-color;\r\n*/\n  padding: 10px;\n  cursor: pointer;\n  display: flex;\n  position: relative; }\n  .selected-list .c-btn .c-icon {\n    position: absolute;\n    right: 5px;\n    top: 50%;\n    transform: translateY(-50%); }\n\n.dropdown-list {\n  position: absolute;\n  padding-top: 14px;\n  width: 100%;\n  z-index: 9999; }\n  .dropdown-list ul {\n    padding: 0px;\n    list-style: none;\n    overflow: auto;\n    margin: 0px; }\n    .dropdown-list ul li {\n      padding: 10px 10px;\n      cursor: pointer;\n      text-align: left; }\n    .dropdown-list ul li:first-child {\n      padding-top: 10px; }\n    .dropdown-list ul li:last-child {\n      padding-bottom: 10px; }\n    .dropdown-list ul li:hover {\n      background: #f5f5f5; }\n  .dropdown-list ::-webkit-scrollbar {\n    width: 8px; }\n  .dropdown-list ::-webkit-scrollbar-thumb {\n    background: #cccccc;\n    border-radius: 5px; }\n  .dropdown-list ::-webkit-scrollbar-track {\n    background: #f2f2f2; }\n\n.arrow-up, .arrow-down {\n  width: 0;\n  height: 0;\n  border-left: 13px solid transparent;\n  border-right: 13px solid transparent;\n  border-bottom: 15px solid #fff;\n  margin-left: 15px;\n  position: absolute;\n  top: 0; }\n\n.arrow-down {\n  bottom: -14px;\n  top: unset;\n  transform: rotate(180deg); }\n\n.arrow-2 {\n  border-bottom: 15px solid #ccc;\n  top: -1px; }\n\n.arrow-down.arrow-2 {\n  top: unset;\n  bottom: -16px; }\n\n.list-area {\n  border: 1px solid #ccc;\n  border-radius: 3px;\n  background: #fff;\n  margin: 0px;\n  box-shadow: 0px 1px 5px #959595; }\n\n.select-all {\n  padding: 10px;\n  border-bottom: 1px solid #ccc;\n  text-align: left; }\n\n.list-filter {\n  border-bottom: 1px solid #ccc;\n  position: relative;\n  padding-left: 35px;\n  height: 35px; }\n  .list-filter input {\n    border: 0px;\n    width: 100%;\n    height: 100%;\n    padding: 0px; }\n  .list-filter input:focus {\n    outline: none; }\n  .list-filter .c-search {\n    position: absolute;\n    top: 9px;\n    left: 10px;\n    width: 15px;\n    height: 15px; }\n    .list-filter .c-search svg {\n      fill: #888; }\n  .list-filter .c-clear {\n    position: absolute;\n    top: 10px;\n    right: 10px;\n    width: 15px;\n    height: 15px; }\n    .list-filter .c-clear svg {\n      fill: #888; }\n\n.pure-checkbox input[type=\"checkbox\"] {\n  border: 0;\n  clip: rect(0 0 0 0);\n  height: 1px;\n  margin: -1px;\n  overflow: hidden;\n  padding: 0;\n  position: absolute;\n  width: 1px; }\n\n.pure-checkbox input[type=\"checkbox\"]:focus + label:before,\n.pure-checkbox input[type=\"checkbox\"]:hover + label:before {\n  border-color: #0079FE;\n  background-color: #f2f2f2; }\n\n.pure-checkbox input[type=\"checkbox\"]:active + label:before {\n  transition-duration: 0s; }\n\n.pure-checkbox input[type=\"checkbox\"] + label {\n  position: relative;\n  padding-left: 2em;\n  vertical-align: middle;\n  user-select: none;\n  cursor: pointer;\n  margin: 0px;\n  color: #000;\n  font-weight: 300; }\n\n.pure-checkbox input[type=\"checkbox\"] + label:before {\n  box-sizing: content-box;\n  content: '';\n  color: #0079FE;\n  position: absolute;\n  top: 50%;\n  left: 0;\n  width: 14px;\n  height: 14px;\n  margin-top: -9px;\n  border: 2px solid #0079FE;\n  text-align: center;\n  transition: all 0.4s ease; }\n\n.pure-checkbox input[type=\"checkbox\"] + label:after {\n  box-sizing: content-box;\n  content: '';\n  background-color: #0079FE;\n  position: absolute;\n  top: 50%;\n  left: 4px;\n  width: 10px;\n  height: 10px;\n  margin-top: -5px;\n  transform: scale(0);\n  transform-origin: 50%;\n  transition: transform 200ms ease-out; }\n\n.pure-checkbox input[type=\"checkbox\"]:disabled + label:before {\n  border-color: #cccccc; }\n\n.pure-checkbox input[type=\"checkbox\"]:disabled:focus + label:before\n.pure-checkbox input[type=\"checkbox\"]:disabled:hover + label:before {\n  background-color: inherit; }\n\n.pure-checkbox input[type=\"checkbox\"]:disabled:checked + label:before {\n  background-color: #cccccc; }\n\n.pure-checkbox input[type=\"checkbox\"] + label:after {\n  background-color: transparent;\n  top: 50%;\n  left: 4px;\n  width: 8px;\n  height: 3px;\n  margin-top: -4px;\n  border-style: solid;\n  border-color: #ffffff;\n  border-width: 0 0 3px 3px;\n  border-image: none;\n  transform: rotate(-45deg) scale(0); }\n\n.pure-checkbox input[type=\"checkbox\"]:checked + label:after {\n  content: '';\n  transform: rotate(-45deg) scale(1);\n  transition: transform 200ms ease-out; }\n\n.pure-checkbox input[type=\"radio\"]:checked + label:before {\n  background-color: white; }\n\n.pure-checkbox input[type=\"radio\"]:checked + label:after {\n  transform: scale(1); }\n\n.pure-checkbox input[type=\"radio\"] + label:before {\n  border-radius: 50%; }\n\n.pure-checkbox input[type=\"checkbox\"]:checked + label:before {\n  background: #0079FE; }\n\n.pure-checkbox input[type=\"checkbox\"]:checked + label:after {\n  transform: rotate(-45deg) scale(1); }\n\n.list-message {\n  text-align: center;\n  margin: 0px;\n  padding: 15px 0px;\n  font-size: initial; }\n\n.list-grp {\n  padding: 0 15px !important; }\n\n.list-grp h4 {\n  text-transform: capitalize;\n  margin: 15px 0px 0px 0px;\n  font-size: 14px;\n  font-weight: 700; }\n\n.list-grp > li {\n  padding-left: 15px !important; }\n", ""]);
  
  // exports
  
  
  /***/ }),
  /* 167 */
  /***/ (function(module, exports) {
  
  /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  // css base code, injected by the css-loader
  module.exports = function(useSourceMap) {
  	var list = [];
  
  	// return the list of modules as css string
  	list.toString = function toString() {
  		return this.map(function (item) {
  			var content = cssWithMappingToString(item, useSourceMap);
  			if(item[2]) {
  				return "@media " + item[2] + "{" + content + "}";
  			} else {
  				return content;
  			}
  		}).join("");
  	};
  
  	// import a list of modules into the list
  	list.i = function(modules, mediaQuery) {
  		if(typeof modules === "string")
  			modules = [[null, modules, ""]];
  		var alreadyImportedModules = {};
  		for(var i = 0; i < this.length; i++) {
  			var id = this[i][0];
  			if(typeof id === "number")
  				alreadyImportedModules[id] = true;
  		}
  		for(i = 0; i < modules.length; i++) {
  			var item = modules[i];
  			// skip already imported module
  			// this implementation is not 100% perfect for weird media query combinations
  			//  when a module is imported multiple times with different media queries.
  			//  I hope this will never occur (Hey this way we have smaller bundles)
  			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
  				if(mediaQuery && !item[2]) {
  					item[2] = mediaQuery;
  				} else if(mediaQuery) {
  					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
  				}
  				list.push(item);
  			}
  		}
  	};
  	return list;
  };
  
  function cssWithMappingToString(item, useSourceMap) {
  	var content = item[1] || '';
  	var cssMapping = item[3];
  	if (!cssMapping) {
  		return content;
  	}
  
  	if (useSourceMap && typeof btoa === 'function') {
  		var sourceMapping = toComment(cssMapping);
  		var sourceURLs = cssMapping.sources.map(function (source) {
  			return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
  		});
  
  		return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
  	}
  
  	return [content].join('\n');
  }
  
  // Adapted from convert-source-map (MIT)
  function toComment(sourceMap) {
  	// eslint-disable-next-line no-undef
  	var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
  	var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
  
  	return '/*# ' + data + ' */';
  }
  
  
  /***/ }),
  /* 168 */
  /***/ (function(module, exports) {
  
  // 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; };
  
  
  /***/ }),
  /* 169 */
  /***/ (function(module, exports) {
  
  module.exports = "<div class=\"cuppa-dropdown\" (clickOutside)=\"closeDropdown()\">\r\n    <div class=\"selected-list\" #selectedList>\r\n        <div class=\"c-btn form-control\" (click)=\"toggleDropdown($event)\" [ngClass]=\"{'disabled': settings.disabled}\" [attr.tabindex]=\"0\">\r\n            <span *ngIf=\"selectedItems?.length == 0\">{{settings.text}}</span>\r\n            <span *ngIf=\"settings.singleSelection && !badgeTempl\">\r\n                <span *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);\">\r\n                    {{item[settings.labelKey]}}\r\n                </span>\r\n            </span>\r\n            <span class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && settings.singleSelection && badgeTempl \">\r\n                <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\r\n                <span *ngIf=\"!badgeTempl\" class=\"c-label\">{{item[settings.labelKey]}}</span>\r\n            <span *ngIf=\"badgeTempl\" class=\"c-label\">\r\n                            <c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer>\r\n                        </span>\r\n            <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event)\">\r\n                            <svg width=\"100%\" height=\"100%\" version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n        viewBox=\"0 0 47.971 47.971\" style=\"enable-background:new 0 0 47.971 47.971;\" xml:space=\"preserve\">\r\n    <g>\r\n        <path d=\"M28.228,23.986L47.092,5.122c1.172-1.171,1.172-3.071,0-4.242c-1.172-1.172-3.07-1.172-4.242,0L23.986,19.744L5.121,0.88\r\n            c-1.172-1.172-3.07-1.172-4.242,0c-1.172,1.171-1.172,3.071,0,4.242l18.865,18.864L0.879,42.85c-1.172,1.171-1.172,3.071,0,4.242\r\n            C1.465,47.677,2.233,47.97,3,47.97s1.535-0.293,2.121-0.879l18.865-18.864L42.85,47.091c0.586,0.586,1.354,0.879,2.121,0.879\r\n            s1.535-0.293,2.121-0.879c1.172-1.171,1.172-3.071,0-4.242L28.228,23.986z\"/>\r\n    </g>\r\n    </svg>\r\n\r\n                        </span>\r\n\r\n\r\n\r\n        </div>\r\n        </span>\r\n        <div class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && !settings.singleSelection\">\r\n            <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\" [hidden]=\"k > settings.badgeShowLimit-1\">\r\n                <span *ngIf=\"!badgeTempl\" class=\"c-label\">{{item[settings.labelKey]}}</span>\r\n                <span *ngIf=\"badgeTempl\" class=\"c-label\">\r\n                            <c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer>\r\n                        </span>\r\n                <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event)\">\r\n                            <svg width=\"100%\" height=\"100%\" version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n        viewBox=\"0 0 47.971 47.971\" style=\"enable-background:new 0 0 47.971 47.971;\" xml:space=\"preserve\">\r\n    <g>\r\n        <path d=\"M28.228,23.986L47.092,5.122c1.172-1.171,1.172-3.071,0-4.242c-1.172-1.172-3.07-1.172-4.242,0L23.986,19.744L5.121,0.88\r\n            c-1.172-1.172-3.07-1.172-4.242,0c-1.172,1.171-1.172,3.071,0,4.242l18.865,18.864L0.879,42.85c-1.172,1.171-1.172,3.071,0,4.242\r\n            C1.465,47.677,2.233,47.97,3,47.97s1.535-0.293,2.121-0.879l18.865-18.864L42.85,47.091c0.586,0.586,1.354,0.879,2.121,0.879\r\n            s1.535-0.293,2.121-0.879c1.172-1.171,1.172-3.071,0-4.242L28.228,23.986z\"/>\r\n    </g>\r\n    </svg>\r\n\r\n                        </span>\r\n            </div>\r\n        </div>\r\n        <span class=\"countplaceholder\" *ngIf=\"selectedItems?.length > settings.badgeShowLimit\">+{{selectedItems?.length - settings.badgeShowLimit }}</span>\r\n        <!--            <span class=\"fa\" [ngClass]=\"{'c-angle-down': !isActive,'fa-angle-up':isActive}\"></span>\r\n--><span *ngIf=\"!isActive\" class=\"c-angle-down\">\r\n                <svg version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n\t width=\"100%\" height=\"100%\" viewBox=\"0 0 612 612\" style=\"enable-background:new 0 0 612 612;\" xml:space=\"preserve\">\r\n<g>\r\n\t<g id=\"_x31_0_34_\">\r\n\t\t<g>\r\n\t\t\t<path d=\"M604.501,134.782c-9.999-10.05-26.222-10.05-36.221,0L306.014,422.558L43.721,134.782\r\n\t\t\t\tc-9.999-10.05-26.223-10.05-36.222,0s-9.999,26.35,0,36.399l279.103,306.241c5.331,5.357,12.422,7.652,19.386,7.296\r\n\t\t\t\tc6.988,0.356,14.055-1.939,19.386-7.296l279.128-306.268C614.5,161.106,614.5,144.832,604.501,134.782z\"/>\r\n\t\t</g>\r\n\t</g>\r\n</g>\r\n</svg>\r\n\r\n            </span>\r\n        <span *ngIf=\"isActive\" class=\"c-angle-up\">\r\n                <svg version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n\t width=\"100%\" height=\"100%\" viewBox=\"0 0 612 612\" style=\"enable-background:new 0 0 612 612;\" xml:space=\"preserve\">\r\n<g>\r\n\t<g id=\"_x39__30_\">\r\n\t\t<g>\r\n\t\t\t<path d=\"M604.501,440.509L325.398,134.956c-5.331-5.357-12.423-7.627-19.386-7.27c-6.989-0.357-14.056,1.913-19.387,7.27\r\n\t\t\t\tL7.499,440.509c-9.999,10.024-9.999,26.298,0,36.323s26.223,10.024,36.222,0l262.293-287.164L568.28,476.832\r\n\t\t\t\tc9.999,10.024,26.222,10.024,36.221,0C614.5,466.809,614.5,450.534,604.501,440.509z\"/>\r\n\t\t</g>\r\n\t</g>\r\n</g>\r\n\r\n</svg>\r\n\r\n            </span>\r\n    </div>\r\n</div>\r\n<div [setPosition]=\"selectedListHeight?.val\" class=\"dropdown-list\" [ngClass]=\"{'dropdown-list-top': settings.position == 'top'}\"\r\n    [hidden]=\"!isActive\">\r\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\" class=\"arrow-2\"></div>\r\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"></div>\r\n    <div class=\"list-area\">\r\n        <div class=\"pure-checkbox select-all\" *ngIf=\"settings.enableCheckAll && !settings.singleSelection && !settings.limitSelection && data?.length > 0\"\r\n            (click)=\"toggleSelectAll()\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelectAll\" [disabled]=\"settings.limitSelection == selectedItems?.length\"\r\n            />\r\n            <label>\r\n                <span [hidden]=\"isSelectAll\">{{settings.selectAllText}}</span>\r\n                <span [hidden]=\"!isSelectAll\">{{settings.unSelectAllText}}</span>\r\n            </label>\r\n        </div>\r\n        <div class=\"list-filter\" *ngIf=\"settings.enableSearchFilter\">\r\n            <span class=\"c-search\">\r\n                    <svg version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n\t width=\"100%\" height=\"100%\" viewBox=\"0 0 615.52 615.52\" style=\"enable-background:new 0 0 615.52 615.52;\"\r\n\t xml:space=\"preserve\">\r\n<g>\r\n\t<g>\r\n\t\t<g id=\"Search__x28_and_thou_shall_find_x29_\">\r\n\t\t\t<g>\r\n\t\t\t\t<path d=\"M602.531,549.736l-184.31-185.368c26.679-37.72,42.528-83.729,42.528-133.548C460.75,103.35,357.997,0,231.258,0\r\n\t\t\t\t\tC104.518,0,1.765,103.35,1.765,230.82c0,127.47,102.753,230.82,229.493,230.82c49.53,0,95.271-15.944,132.78-42.777\r\n\t\t\t\t\tl184.31,185.366c7.482,7.521,17.292,11.291,27.102,11.291c9.812,0,19.62-3.77,27.083-11.291\r\n\t\t\t\t\tC617.496,589.188,617.496,564.777,602.531,549.736z M355.9,319.763l-15.042,21.273L319.7,356.174\r\n\t\t\t\t\tc-26.083,18.658-56.667,28.526-88.442,28.526c-84.365,0-152.995-69.035-152.995-153.88c0-84.846,68.63-153.88,152.995-153.88\r\n\t\t\t\t\ts152.996,69.034,152.996,153.88C384.271,262.769,374.462,293.526,355.9,319.763z\"/>\r\n\t\t\t</g>\r\n\t\t</g>\r\n\t</g>\r\n</g>\r\n\r\n</svg>\r\n                </span>\r\n            <span *ngIf=\"!settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\" (click)=\"clearSearch()\">\r\n<svg version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n\t viewBox=\"0 0 51.976 51.976\" style=\"enable-background:new 0 0 51.976 51.976;\" xml:space=\"preserve\">\r\n<g>\r\n\t<path d=\"M44.373,7.603c-10.137-10.137-26.632-10.138-36.77,0c-10.138,10.138-10.137,26.632,0,36.77s26.632,10.138,36.77,0\r\n\t\tC54.51,34.235,54.51,17.74,44.373,7.603z M36.241,36.241c-0.781,0.781-2.047,0.781-2.828,0l-7.425-7.425l-7.778,7.778\r\n\t\tc-0.781,0.781-2.047,0.781-2.828,0c-0.781-0.781-0.781-2.047,0-2.828l7.778-7.778l-7.425-7.425c-0.781-0.781-0.781-2.048,0-2.828\r\n\t\tc0.781-0.781,2.047-0.781,2.828,0l7.425,7.425l7.071-7.071c0.781-0.781,2.047-0.781,2.828,0c0.781,0.781,0.781,2.047,0,2.828\r\n\t\tl-7.071,7.071l7.425,7.425C37.022,34.194,37.022,35.46,36.241,36.241z\"/>\r\n</g>\r\n</svg>\r\n                </span>\r\n            <span *ngIf=\"settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\" (click)=\"resetInfiniteSearch()\">\r\n<svg version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\r\n\t viewBox=\"0 0 51.976 51.976\" style=\"enable-background:new 0 0 51.976 51.976;\" xml:space=\"preserve\">\r\n<g>\r\n\t<path d=\"M44.373,7.603c-10.137-10.137-26.632-10.138-36.77,0c-10.138,10.138-10.137,26.632,0,36.77s26.632,10.138,36.77,0\r\n\t\tC54.51,34.235,54.51,17.74,44.373,7.603z M36.241,36.241c-0.781,0.781-2.047,0.781-2.828,0l-7.425-7.425l-7.778,7.778\r\n\t\tc-0.781,0.781-2.047,0.781-2.828,0c-0.781-0.781-0.781-2.047,0-2.828l7.778-7.778l-7.425-7.425c-0.781-0.781-0.781-2.048,0-2.828\r\n\t\tc0.781-0.781,2.047-0.781,2.828,0l7.425,7.425l7.071-7.071c0.781-0.781,2.047-0.781,2.828,0c0.781,0.781,0.781,2.047,0,2.828\r\n\t\tl-7.071,7.071l7.425,7.425C37.022,34.194,37.022,35.46,36.241,36.241z\"/>\r\n</g>\r\n</svg>\r\n                </span>\r\n\r\n            <input class=\"c-input\" *ngIf=\"!settings.lazyLoading && !searchTempl\" #searchInput type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\r\n                [(ngModel)]=\"filter\">\r\n            <input class=\"c-input\" *ngIf=\"settings.lazyLoading && !searchTempl\" #searchInput type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\r\n                [(ngModel)]=\"filter\" (keyup)=\"filterInfiniteList($event)\">\r\n            <c-templateRenderer *ngIf=\"searchTempl\" [data]=\"searchTempl\" [item]=\"item\"></c-templateRenderer>\r\n        </div>\r\n        <div class=\"filter-select-all\" *ngIf=\"!settings.lazyLoading && settings.enableFilterSelectAll\">\r\n            <div class=\"pure-checkbox select-all\" *ngIf=\"filter?.length > 0 && filterLength > 0\" (click)=\"toggleFilterSelectAll()\">\r\n                <input type=\"checkbox\" [checked]=\"isFilterSelectAll\" [disabled]=\"settings.limitSelection == selectedItems?.length\" />\r\n                <label>\r\n                <span [hidden]=\"isFilterSelectAll\">{{settings.filterSelectAllText}}</span>\r\n                <span [hidden]=\"!isFilterSelectAll\">{{settings.filterUnSelectAllText}}</span>\r\n            </label>\r\n            </div>\r\n            <label *ngIf=\"filterLength == 0\" [hidden]=\"filter == undefined || filter?.length == 0\">{{settings.noDataLabel}}</label>\r\n        </div>\r\n        <div class=\"filter-select-all\" *ngIf=\"settings.lazyLoading && settings.enableFilterSelectAll\">\r\n            <div class=\"pure-checkbox select-all\" *ngIf=\"filter?.length > 0 && infiniteFilterLength > 0\" (click)=\"toggleInfiniteFilterSelectAll()\">\r\n                <input type=\"checkbox\" [checked]=\"isInfiniteFilterSelectAll\" [disabled]=\"settings.limitSelection == selectedItems?.length\"\r\n                />\r\n                <label>\r\n                <span [hidden]=\"isInfiniteFilterSelectAll\">{{settings.filterSelectAllText}}</span>\r\n                <span [hidden]=\"!isInfiniteFilterSelectAll\">{{settings.filterUnSelectAllText}}</span>\r\n            </label>\r\n            </div>\r\n        </div>\r\n        <ul *ngIf=\"!settings.groupBy\" [style.maxHeight]=\"settings.maxHeight+'px'\" class=\"lazyContainer\">\r\n            <span *ngIf=\"itemTempl\">\r\n            <li *ngFor=\"let item of data | listFilter: filter : settings.searchBy; let i = index;\" (click)=\"onItemClick(item,i,$event)\" class=\"pure-checkbox\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\" [disabled]=\"settings.limitSelection == selectedItems?.length && !isSelected(item)\"/>\r\n            <label></label>\r\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\r\n        </li>\r\n        </span>\r\n            <span *ngIf=\"!itemTempl && !settings.lazyLoading\">\r\n        <li *ngFor=\"let item of data | listFilter:filter : settings.searchBy; let i = index;\" (click)=\"onItemClick(item,i,$event)\" class=\"pure-checkbox\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\" [disabled]=\"settings.limitSelection == selectedItems?.length && !isSelected(item)\"/>\r\n            <label>{{item[settings.labelKey]}}</label>\r\n        </li>\r\n        </span>\r\n            <span *ngIf=\"!itemTempl && settings.lazyLoading\">\r\n            <div [ngStyle]=\"{'height':totalHeight+'px'}\" style=\"position: relative;\">\r\n\r\n            \r\n        <li *ngFor=\"let item of chunkArray ; let i = index;\" (click)=\"onItemClick(item,i,$event)\" style=\"position: absolute;width: 100%;\" class=\"pure-checkbox\" [styleProp]=\"chunkIndex[i]\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\" [disabled]=\"settings.limitSelection == selectedItems?.length && !isSelected(item)\"/>\r\n            <label>{{item[settings.labelKey]}}</label>\r\n        </li>\r\n        </div>\r\n        </span>\r\n        </ul>\r\n        <div *ngIf=\"settings.groupBy\" [style.maxHeight]=\"settings.maxHeight+'px'\" style=\"overflow: auto;\">\r\n            <ul *ngFor=\"let obj of groupedData ; let i = index;\" class=\"list-grp\">\r\n                <h4 *ngIf=\"(obj.value | listFilter:filter : settings.searchBy )?.length > 0\">{{obj.key}}</h4>\r\n                <span *ngIf=\"itemTempl\">\r\n        <li *ngFor=\"let item of obj.value | listFilter:filter : settings.searchBy; let i = index;\" (click)=\"onItemClick(item,i,$event)\" class=\"pure-checkbox\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\" [disabled]=\"settings.limitSelection == selectedItems?.length && !isSelected(item)\"/>\r\n            <label></label>\r\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\r\n        </li>\r\n        </span>\r\n                <span *ngIf=\"!itemTempl\">\r\n        <li *ngFor=\"let item of obj.value | listFilter:filter : settings.searchBy; let i = index;\" (click)=\"onItemClick(item,i,$event)\" class=\"pure-checkbox\">\r\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\" [disabled]=\"settings.limitSelection == selectedItems?.length && !isSelected(item)\"/>\r\n            <label>{{item[settings.labelKey]}}</label>\r\n        </li>\r\n        </span>\r\n            </ul>\r\n        </div>\r\n        <h5 class=\"list-message\" *ngIf=\"data?.length == 0\">{{settings.noDataLabel}}</h5>\r\n    </div>\r\n</div>\r\n</div>"
  
  /***/ }),
  /* 170 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 171 */
  /***/ (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__(173);
  __webpack_require__(174);
  __webpack_require__(175);
  __webpack_require__(176);
  __webpack_require__(177);
  __webpack_require__(180);
  __webpack_require__(181);
  __webpack_require__(182);
  __webpack_require__(183);
  __webpack_require__(184);
  __webpack_require__(185);
  __webpack_require__(186);
  __webpack_require__(187);
  __webpack_require__(188);
  __webpack_require__(189);
  __webpack_require__(194);
  __webpack_require__(190);
  __webpack_require__(191);
  __webpack_require__(192);
  __webpack_require__(193);
  __webpack_require__(195);
  __webpack_require__(198);
  __webpack_require__(196);
  __webpack_require__(197);
  __webpack_require__(199);
  //dom
  __webpack_require__(178);
  __webpack_require__(179);
  //operators
  __webpack_require__(202);
  __webpack_require__(203);
  __webpack_require__(204);
  __webpack_require__(205);
  __webpack_require__(206);
  __webpack_require__(207);
  __webpack_require__(208);
  __webpack_require__(209);
  __webpack_require__(210);
  __webpack_require__(211);
  __webpack_require__(212);
  __webpack_require__(213);
  __webpack_require__(214);
  __webpack_require__(220);
  __webpack_require__(215);
  __webpack_require__(216);
  __webpack_require__(217);
  __webpack_require__(218);
  __webpack_require__(219);
  __webpack_require__(221);
  __webpack_require__(222);
  __webpack_require__(223);
  __webpack_require__(224);
  __webpack_require__(227);
  __webpack_require__(228);
  __webpack_require__(229);
  __webpack_require__(225);
  __webpack_require__(230);
  __webpack_require__(231);
  __webpack_require__(232);
  __webpack_require__(233);
  __webpack_require__(234);
  __webpack_require__(235);
  __webpack_require__(236);
  __webpack_require__(237);
  __webpack_require__(200);
  __webpack_require__(201);
  __webpack_require__(238);
  __webpack_require__(239);
  __webpack_require__(226);
  __webpack_require__(240);
  __webpack_require__(241);
  __webpack_require__(242);
  __webpack_require__(243);
  __webpack_require__(244);
  __webpack_require__(245);
  __webpack_require__(246);
  __webpack_require__(247);
  __webpack_require__(248);
  __webpack_require__(249);
  __webpack_require__(250);
  __webpack_require__(251);
  __webpack_require__(252);
  __webpack_require__(253);
  __webpack_require__(254);
  __webpack_require__(255);
  __webpack_require__(256);
  __webpack_require__(257);
  __webpack_require__(259);
  __webpack_require__(258);
  __webpack_require__(260);
  __webpack_require__(261);
  __webpack_require__(262);
  __webpack_require__(263);
  __webpack_require__(264);
  __webpack_require__(265);
  __webpack_require__(266);
  __webpack_require__(267);
  __webpack_require__(268);
  __webpack_require__(269);
  __webpack_require__(270);
  __webpack_require__(271);
  __webpack_require__(272);
  __webpack_require__(273);
  __webpack_require__(274);
  __webpack_require__(275);
  __webpack_require__(276);
  __webpack_require__(277);
  __webpack_require__(278);
  __webpack_require__(279);
  __webpack_require__(280);
  __webpack_require__(281);
  __webpack_require__(282);
  __webpack_require__(283);
  __webpack_require__(284);
  __webpack_require__(285);
  __webpack_require__(286);
  __webpack_require__(287);
  __webpack_require__(288);
  __webpack_require__(289);
  __webpack_require__(290);
  __webpack_require__(291);
  __webpack_require__(292);
  __webpack_require__(293);
  __webpack_require__(294);
  __webpack_require__(295);
  __webpack_require__(296);
  __webpack_require__(297);
  __webpack_require__(298);
  __webpack_require__(299);
  __webpack_require__(300);
  __webpack_require__(301);
  /* 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__(26);
  exports.AsyncSubject = AsyncSubject_1.AsyncSubject;
  var ReplaySubject_1 = __webpack_require__(27);
  exports.ReplaySubject = ReplaySubject_1.ReplaySubject;
  var BehaviorSubject_1 = __webpack_require__(62);
  exports.BehaviorSubject = BehaviorSubject_1.BehaviorSubject;
  var ConnectableObservable_1 = __webpack_require__(65);
  exports.ConnectableObservable = ConnectableObservable_1.ConnectableObservable;
  var Notification_1 = __webpack_require__(15);
  exports.Notification = Notification_1.Notification;
  var EmptyError_1 = __webpack_require__(35);
  exports.EmptyError = EmptyError_1.EmptyError;
  var ArgumentOutOfRangeError_1 = __webpack_require__(22);
  exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;
  var ObjectUnsubscribedError_1 = __webpack_require__(36);
  exports.ObjectUnsubscribedError = ObjectUnsubscribedError_1.ObjectUnsubscribedError;
  var TimeoutError_1 = __webpack_require__(156);
  exports.TimeoutError = TimeoutError_1.TimeoutError;
  var UnsubscriptionError_1 = __webpack_require__(157);
  exports.UnsubscriptionError = UnsubscriptionError_1.UnsubscriptionError;
  var timeInterval_1 = __webpack_require__(73);
  exports.TimeInterval = timeInterval_1.TimeInterval;
  var timestamp_1 = __webpack_require__(56);
  exports.Timestamp = timestamp_1.Timestamp;
  var TestScheduler_1 = __webpack_require__(454);
  exports.TestScheduler = TestScheduler_1.TestScheduler;
  var VirtualTimeScheduler_1 = __webpack_require__(151);
  exports.VirtualTimeScheduler = VirtualTimeScheduler_1.VirtualTimeScheduler;
  var AjaxObservable_1 = __webpack_require__(68);
  exports.AjaxResponse = AjaxObservable_1.AjaxResponse;
  exports.AjaxError = AjaxObservable_1.AjaxError;
  exports.AjaxTimeoutError = AjaxObservable_1.AjaxTimeoutError;
  var pipe_1 = __webpack_require__(58);
  exports.pipe = pipe_1.pipe;
  var asap_1 = __webpack_require__(152);
  var async_1 = __webpack_require__(4);
  var queue_1 = __webpack_require__(153);
  var animationFrame_1 = __webpack_require__(451);
  var rxSubscriber_1 = __webpack_require__(34);
  var iterator_1 = __webpack_require__(21);
  var observable_1 = __webpack_require__(33);
  var _operators = __webpack_require__(442);
  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
  
  /***/ }),
  /* 172 */
  /***/ (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
  
  /***/ }),
  /* 173 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bindCallback_1 = __webpack_require__(320);
  Observable_1.Observable.bindCallback = bindCallback_1.bindCallback;
  //# sourceMappingURL=bindCallback.js.map
  
  /***/ }),
  /* 174 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bindNodeCallback_1 = __webpack_require__(321);
  Observable_1.Observable.bindNodeCallback = bindNodeCallback_1.bindNodeCallback;
  //# sourceMappingURL=bindNodeCallback.js.map
  
  /***/ }),
  /* 175 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var combineLatest_1 = __webpack_require__(322);
  Observable_1.Observable.combineLatest = combineLatest_1.combineLatest;
  //# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 176 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var concat_1 = __webpack_require__(41);
  Observable_1.Observable.concat = concat_1.concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 177 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var defer_1 = __webpack_require__(323);
  Observable_1.Observable.defer = defer_1.defer;
  //# sourceMappingURL=defer.js.map
  
  /***/ }),
  /* 178 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var ajax_1 = __webpack_require__(325);
  Observable_1.Observable.ajax = ajax_1.ajax;
  //# sourceMappingURL=ajax.js.map
  
  /***/ }),
  /* 179 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var webSocket_1 = __webpack_require__(326);
  Observable_1.Observable.webSocket = webSocket_1.webSocket;
  //# sourceMappingURL=webSocket.js.map
  
  /***/ }),
  /* 180 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var empty_1 = __webpack_require__(327);
  Observable_1.Observable.empty = empty_1.empty;
  //# sourceMappingURL=empty.js.map
  
  /***/ }),
  /* 181 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var forkJoin_1 = __webpack_require__(328);
  Observable_1.Observable.forkJoin = forkJoin_1.forkJoin;
  //# sourceMappingURL=forkJoin.js.map
  
  /***/ }),
  /* 182 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var from_1 = __webpack_require__(69);
  Observable_1.Observable.from = from_1.from;
  //# sourceMappingURL=from.js.map
  
  /***/ }),
  /* 183 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var fromEvent_1 = __webpack_require__(329);
  Observable_1.Observable.fromEvent = fromEvent_1.fromEvent;
  //# sourceMappingURL=fromEvent.js.map
  
  /***/ }),
  /* 184 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var fromEventPattern_1 = __webpack_require__(330);
  Observable_1.Observable.fromEventPattern = fromEventPattern_1.fromEventPattern;
  //# sourceMappingURL=fromEventPattern.js.map
  
  /***/ }),
  /* 185 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var fromPromise_1 = __webpack_require__(331);
  Observable_1.Observable.fromPromise = fromPromise_1.fromPromise;
  //# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  /* 186 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var generate_1 = __webpack_require__(332);
  Observable_1.Observable.generate = generate_1.generate;
  //# sourceMappingURL=generate.js.map
  
  /***/ }),
  /* 187 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var if_1 = __webpack_require__(333);
  Observable_1.Observable.if = if_1._if;
  //# sourceMappingURL=if.js.map
  
  /***/ }),
  /* 188 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var interval_1 = __webpack_require__(334);
  Observable_1.Observable.interval = interval_1.interval;
  //# sourceMappingURL=interval.js.map
  
  /***/ }),
  /* 189 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var merge_1 = __webpack_require__(335);
  Observable_1.Observable.merge = merge_1.merge;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 190 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var never_1 = __webpack_require__(336);
  Observable_1.Observable.never = never_1.never;
  //# sourceMappingURL=never.js.map
  
  /***/ }),
  /* 191 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var of_1 = __webpack_require__(70);
  Observable_1.Observable.of = of_1.of;
  //# sourceMappingURL=of.js.map
  
  /***/ }),
  /* 192 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var onErrorResumeNext_1 = __webpack_require__(337);
  Observable_1.Observable.onErrorResumeNext = onErrorResumeNext_1.onErrorResumeNext;
  //# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 193 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var pairs_1 = __webpack_require__(338);
  Observable_1.Observable.pairs = pairs_1.pairs;
  //# sourceMappingURL=pairs.js.map
  
  /***/ }),
  /* 194 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var race_1 = __webpack_require__(42);
  Observable_1.Observable.race = race_1.race;
  //# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 195 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var range_1 = __webpack_require__(339);
  Observable_1.Observable.range = range_1.range;
  //# sourceMappingURL=range.js.map
  
  /***/ }),
  /* 196 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var throw_1 = __webpack_require__(340);
  Observable_1.Observable.throw = throw_1._throw;
  //# sourceMappingURL=throw.js.map
  
  /***/ }),
  /* 197 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var timer_1 = __webpack_require__(71);
  Observable_1.Observable.timer = timer_1.timer;
  //# sourceMappingURL=timer.js.map
  
  /***/ }),
  /* 198 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var using_1 = __webpack_require__(341);
  Observable_1.Observable.using = using_1.using;
  //# sourceMappingURL=using.js.map
  
  /***/ }),
  /* 199 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var zip_1 = __webpack_require__(342);
  Observable_1.Observable.zip = zip_1.zip;
  //# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 200 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var audit_1 = __webpack_require__(343);
  Observable_1.Observable.prototype.audit = audit_1.audit;
  //# sourceMappingURL=audit.js.map
  
  /***/ }),
  /* 201 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var auditTime_1 = __webpack_require__(344);
  Observable_1.Observable.prototype.auditTime = auditTime_1.auditTime;
  //# sourceMappingURL=auditTime.js.map
  
  /***/ }),
  /* 202 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var buffer_1 = __webpack_require__(345);
  Observable_1.Observable.prototype.buffer = buffer_1.buffer;
  //# sourceMappingURL=buffer.js.map
  
  /***/ }),
  /* 203 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bufferCount_1 = __webpack_require__(346);
  Observable_1.Observable.prototype.bufferCount = bufferCount_1.bufferCount;
  //# sourceMappingURL=bufferCount.js.map
  
  /***/ }),
  /* 204 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bufferTime_1 = __webpack_require__(347);
  Observable_1.Observable.prototype.bufferTime = bufferTime_1.bufferTime;
  //# sourceMappingURL=bufferTime.js.map
  
  /***/ }),
  /* 205 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bufferToggle_1 = __webpack_require__(348);
  Observable_1.Observable.prototype.bufferToggle = bufferToggle_1.bufferToggle;
  //# sourceMappingURL=bufferToggle.js.map
  
  /***/ }),
  /* 206 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var bufferWhen_1 = __webpack_require__(349);
  Observable_1.Observable.prototype.bufferWhen = bufferWhen_1.bufferWhen;
  //# sourceMappingURL=bufferWhen.js.map
  
  /***/ }),
  /* 207 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var catch_1 = __webpack_require__(350);
  Observable_1.Observable.prototype.catch = catch_1._catch;
  Observable_1.Observable.prototype._catch = catch_1._catch;
  //# sourceMappingURL=catch.js.map
  
  /***/ }),
  /* 208 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var combineAll_1 = __webpack_require__(351);
  Observable_1.Observable.prototype.combineAll = combineAll_1.combineAll;
  //# sourceMappingURL=combineAll.js.map
  
  /***/ }),
  /* 209 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var combineLatest_1 = __webpack_require__(352);
  Observable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest;
  //# sourceMappingURL=combineLatest.js.map
  
  /***/ }),
  /* 210 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var concat_1 = __webpack_require__(353);
  Observable_1.Observable.prototype.concat = concat_1.concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  /* 211 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var concatAll_1 = __webpack_require__(354);
  Observable_1.Observable.prototype.concatAll = concatAll_1.concatAll;
  //# sourceMappingURL=concatAll.js.map
  
  /***/ }),
  /* 212 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var concatMap_1 = __webpack_require__(355);
  Observable_1.Observable.prototype.concatMap = concatMap_1.concatMap;
  //# sourceMappingURL=concatMap.js.map
  
  /***/ }),
  /* 213 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var concatMapTo_1 = __webpack_require__(356);
  Observable_1.Observable.prototype.concatMapTo = concatMapTo_1.concatMapTo;
  //# sourceMappingURL=concatMapTo.js.map
  
  /***/ }),
  /* 214 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var count_1 = __webpack_require__(357);
  Observable_1.Observable.prototype.count = count_1.count;
  //# sourceMappingURL=count.js.map
  
  /***/ }),
  /* 215 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var debounce_1 = __webpack_require__(358);
  Observable_1.Observable.prototype.debounce = debounce_1.debounce;
  //# sourceMappingURL=debounce.js.map
  
  /***/ }),
  /* 216 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var debounceTime_1 = __webpack_require__(359);
  Observable_1.Observable.prototype.debounceTime = debounceTime_1.debounceTime;
  //# sourceMappingURL=debounceTime.js.map
  
  /***/ }),
  /* 217 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var defaultIfEmpty_1 = __webpack_require__(360);
  Observable_1.Observable.prototype.defaultIfEmpty = defaultIfEmpty_1.defaultIfEmpty;
  //# sourceMappingURL=defaultIfEmpty.js.map
  
  /***/ }),
  /* 218 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var delay_1 = __webpack_require__(361);
  Observable_1.Observable.prototype.delay = delay_1.delay;
  //# sourceMappingURL=delay.js.map
  
  /***/ }),
  /* 219 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var delayWhen_1 = __webpack_require__(362);
  Observable_1.Observable.prototype.delayWhen = delayWhen_1.delayWhen;
  //# sourceMappingURL=delayWhen.js.map
  
  /***/ }),
  /* 220 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var dematerialize_1 = __webpack_require__(363);
  Observable_1.Observable.prototype.dematerialize = dematerialize_1.dematerialize;
  //# sourceMappingURL=dematerialize.js.map
  
  /***/ }),
  /* 221 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var distinct_1 = __webpack_require__(364);
  Observable_1.Observable.prototype.distinct = distinct_1.distinct;
  //# sourceMappingURL=distinct.js.map
  
  /***/ }),
  /* 222 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var distinctUntilChanged_1 = __webpack_require__(365);
  Observable_1.Observable.prototype.distinctUntilChanged = distinctUntilChanged_1.distinctUntilChanged;
  //# sourceMappingURL=distinctUntilChanged.js.map
  
  /***/ }),
  /* 223 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var distinctUntilKeyChanged_1 = __webpack_require__(366);
  Observable_1.Observable.prototype.distinctUntilKeyChanged = distinctUntilKeyChanged_1.distinctUntilKeyChanged;
  //# sourceMappingURL=distinctUntilKeyChanged.js.map
  
  /***/ }),
  /* 224 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var do_1 = __webpack_require__(367);
  Observable_1.Observable.prototype.do = do_1._do;
  Observable_1.Observable.prototype._do = do_1._do;
  //# sourceMappingURL=do.js.map
  
  /***/ }),
  /* 225 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var elementAt_1 = __webpack_require__(368);
  Observable_1.Observable.prototype.elementAt = elementAt_1.elementAt;
  //# sourceMappingURL=elementAt.js.map
  
  /***/ }),
  /* 226 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var every_1 = __webpack_require__(369);
  Observable_1.Observable.prototype.every = every_1.every;
  //# sourceMappingURL=every.js.map
  
  /***/ }),
  /* 227 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var exhaust_1 = __webpack_require__(370);
  Observable_1.Observable.prototype.exhaust = exhaust_1.exhaust;
  //# sourceMappingURL=exhaust.js.map
  
  /***/ }),
  /* 228 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var exhaustMap_1 = __webpack_require__(371);
  Observable_1.Observable.prototype.exhaustMap = exhaustMap_1.exhaustMap;
  //# sourceMappingURL=exhaustMap.js.map
  
  /***/ }),
  /* 229 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var expand_1 = __webpack_require__(372);
  Observable_1.Observable.prototype.expand = expand_1.expand;
  //# sourceMappingURL=expand.js.map
  
  /***/ }),
  /* 230 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var filter_1 = __webpack_require__(373);
  Observable_1.Observable.prototype.filter = filter_1.filter;
  //# sourceMappingURL=filter.js.map
  
  /***/ }),
  /* 231 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var finally_1 = __webpack_require__(374);
  Observable_1.Observable.prototype.finally = finally_1._finally;
  Observable_1.Observable.prototype._finally = finally_1._finally;
  //# sourceMappingURL=finally.js.map
  
  /***/ }),
  /* 232 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var find_1 = __webpack_require__(375);
  Observable_1.Observable.prototype.find = find_1.find;
  //# sourceMappingURL=find.js.map
  
  /***/ }),
  /* 233 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var findIndex_1 = __webpack_require__(376);
  Observable_1.Observable.prototype.findIndex = findIndex_1.findIndex;
  //# sourceMappingURL=findIndex.js.map
  
  /***/ }),
  /* 234 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var first_1 = __webpack_require__(377);
  Observable_1.Observable.prototype.first = first_1.first;
  //# sourceMappingURL=first.js.map
  
  /***/ }),
  /* 235 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var groupBy_1 = __webpack_require__(378);
  Observable_1.Observable.prototype.groupBy = groupBy_1.groupBy;
  //# sourceMappingURL=groupBy.js.map
  
  /***/ }),
  /* 236 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var ignoreElements_1 = __webpack_require__(379);
  Observable_1.Observable.prototype.ignoreElements = ignoreElements_1.ignoreElements;
  //# sourceMappingURL=ignoreElements.js.map
  
  /***/ }),
  /* 237 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var isEmpty_1 = __webpack_require__(380);
  Observable_1.Observable.prototype.isEmpty = isEmpty_1.isEmpty;
  //# sourceMappingURL=isEmpty.js.map
  
  /***/ }),
  /* 238 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var last_1 = __webpack_require__(381);
  Observable_1.Observable.prototype.last = last_1.last;
  //# sourceMappingURL=last.js.map
  
  /***/ }),
  /* 239 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var let_1 = __webpack_require__(382);
  Observable_1.Observable.prototype.let = let_1.letProto;
  Observable_1.Observable.prototype.letBind = let_1.letProto;
  //# sourceMappingURL=let.js.map
  
  /***/ }),
  /* 240 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var map_1 = __webpack_require__(383);
  Observable_1.Observable.prototype.map = map_1.map;
  //# sourceMappingURL=map.js.map
  
  /***/ }),
  /* 241 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var mapTo_1 = __webpack_require__(384);
  Observable_1.Observable.prototype.mapTo = mapTo_1.mapTo;
  //# sourceMappingURL=mapTo.js.map
  
  /***/ }),
  /* 242 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var materialize_1 = __webpack_require__(385);
  Observable_1.Observable.prototype.materialize = materialize_1.materialize;
  //# sourceMappingURL=materialize.js.map
  
  /***/ }),
  /* 243 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var max_1 = __webpack_require__(386);
  Observable_1.Observable.prototype.max = max_1.max;
  //# sourceMappingURL=max.js.map
  
  /***/ }),
  /* 244 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var merge_1 = __webpack_require__(72);
  Observable_1.Observable.prototype.merge = merge_1.merge;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 245 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var mergeAll_1 = __webpack_require__(387);
  Observable_1.Observable.prototype.mergeAll = mergeAll_1.mergeAll;
  //# sourceMappingURL=mergeAll.js.map
  
  /***/ }),
  /* 246 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var mergeMap_1 = __webpack_require__(388);
  Observable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap;
  Observable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap;
  //# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  /* 247 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var mergeMapTo_1 = __webpack_require__(389);
  Observable_1.Observable.prototype.flatMapTo = mergeMapTo_1.mergeMapTo;
  Observable_1.Observable.prototype.mergeMapTo = mergeMapTo_1.mergeMapTo;
  //# sourceMappingURL=mergeMapTo.js.map
  
  /***/ }),
  /* 248 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var mergeScan_1 = __webpack_require__(390);
  Observable_1.Observable.prototype.mergeScan = mergeScan_1.mergeScan;
  //# sourceMappingURL=mergeScan.js.map
  
  /***/ }),
  /* 249 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var min_1 = __webpack_require__(391);
  Observable_1.Observable.prototype.min = min_1.min;
  //# sourceMappingURL=min.js.map
  
  /***/ }),
  /* 250 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var multicast_1 = __webpack_require__(392);
  Observable_1.Observable.prototype.multicast = multicast_1.multicast;
  //# sourceMappingURL=multicast.js.map
  
  /***/ }),
  /* 251 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var observeOn_1 = __webpack_require__(393);
  Observable_1.Observable.prototype.observeOn = observeOn_1.observeOn;
  //# sourceMappingURL=observeOn.js.map
  
  /***/ }),
  /* 252 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var onErrorResumeNext_1 = __webpack_require__(394);
  Observable_1.Observable.prototype.onErrorResumeNext = onErrorResumeNext_1.onErrorResumeNext;
  //# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 253 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var pairwise_1 = __webpack_require__(395);
  Observable_1.Observable.prototype.pairwise = pairwise_1.pairwise;
  //# sourceMappingURL=pairwise.js.map
  
  /***/ }),
  /* 254 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var partition_1 = __webpack_require__(396);
  Observable_1.Observable.prototype.partition = partition_1.partition;
  //# sourceMappingURL=partition.js.map
  
  /***/ }),
  /* 255 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var pluck_1 = __webpack_require__(397);
  Observable_1.Observable.prototype.pluck = pluck_1.pluck;
  //# sourceMappingURL=pluck.js.map
  
  /***/ }),
  /* 256 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var publish_1 = __webpack_require__(398);
  Observable_1.Observable.prototype.publish = publish_1.publish;
  //# sourceMappingURL=publish.js.map
  
  /***/ }),
  /* 257 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var publishBehavior_1 = __webpack_require__(399);
  Observable_1.Observable.prototype.publishBehavior = publishBehavior_1.publishBehavior;
  //# sourceMappingURL=publishBehavior.js.map
  
  /***/ }),
  /* 258 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var publishLast_1 = __webpack_require__(400);
  Observable_1.Observable.prototype.publishLast = publishLast_1.publishLast;
  //# sourceMappingURL=publishLast.js.map
  
  /***/ }),
  /* 259 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var publishReplay_1 = __webpack_require__(401);
  Observable_1.Observable.prototype.publishReplay = publishReplay_1.publishReplay;
  //# sourceMappingURL=publishReplay.js.map
  
  /***/ }),
  /* 260 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var race_1 = __webpack_require__(402);
  Observable_1.Observable.prototype.race = race_1.race;
  //# sourceMappingURL=race.js.map
  
  /***/ }),
  /* 261 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var reduce_1 = __webpack_require__(403);
  Observable_1.Observable.prototype.reduce = reduce_1.reduce;
  //# sourceMappingURL=reduce.js.map
  
  /***/ }),
  /* 262 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var repeat_1 = __webpack_require__(404);
  Observable_1.Observable.prototype.repeat = repeat_1.repeat;
  //# sourceMappingURL=repeat.js.map
  
  /***/ }),
  /* 263 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var repeatWhen_1 = __webpack_require__(405);
  Observable_1.Observable.prototype.repeatWhen = repeatWhen_1.repeatWhen;
  //# sourceMappingURL=repeatWhen.js.map
  
  /***/ }),
  /* 264 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var retry_1 = __webpack_require__(406);
  Observable_1.Observable.prototype.retry = retry_1.retry;
  //# sourceMappingURL=retry.js.map
  
  /***/ }),
  /* 265 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var retryWhen_1 = __webpack_require__(407);
  Observable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen;
  //# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  /* 266 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var sample_1 = __webpack_require__(408);
  Observable_1.Observable.prototype.sample = sample_1.sample;
  //# sourceMappingURL=sample.js.map
  
  /***/ }),
  /* 267 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var sampleTime_1 = __webpack_require__(409);
  Observable_1.Observable.prototype.sampleTime = sampleTime_1.sampleTime;
  //# sourceMappingURL=sampleTime.js.map
  
  /***/ }),
  /* 268 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var scan_1 = __webpack_require__(410);
  Observable_1.Observable.prototype.scan = scan_1.scan;
  //# sourceMappingURL=scan.js.map
  
  /***/ }),
  /* 269 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var sequenceEqual_1 = __webpack_require__(411);
  Observable_1.Observable.prototype.sequenceEqual = sequenceEqual_1.sequenceEqual;
  //# sourceMappingURL=sequenceEqual.js.map
  
  /***/ }),
  /* 270 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var share_1 = __webpack_require__(412);
  Observable_1.Observable.prototype.share = share_1.share;
  //# sourceMappingURL=share.js.map
  
  /***/ }),
  /* 271 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var shareReplay_1 = __webpack_require__(413);
  Observable_1.Observable.prototype.shareReplay = shareReplay_1.shareReplay;
  //# sourceMappingURL=shareReplay.js.map
  
  /***/ }),
  /* 272 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var single_1 = __webpack_require__(414);
  Observable_1.Observable.prototype.single = single_1.single;
  //# sourceMappingURL=single.js.map
  
  /***/ }),
  /* 273 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var skip_1 = __webpack_require__(415);
  Observable_1.Observable.prototype.skip = skip_1.skip;
  //# sourceMappingURL=skip.js.map
  
  /***/ }),
  /* 274 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var skipLast_1 = __webpack_require__(416);
  Observable_1.Observable.prototype.skipLast = skipLast_1.skipLast;
  //# sourceMappingURL=skipLast.js.map
  
  /***/ }),
  /* 275 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var skipUntil_1 = __webpack_require__(417);
  Observable_1.Observable.prototype.skipUntil = skipUntil_1.skipUntil;
  //# sourceMappingURL=skipUntil.js.map
  
  /***/ }),
  /* 276 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var skipWhile_1 = __webpack_require__(418);
  Observable_1.Observable.prototype.skipWhile = skipWhile_1.skipWhile;
  //# sourceMappingURL=skipWhile.js.map
  
  /***/ }),
  /* 277 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var startWith_1 = __webpack_require__(419);
  Observable_1.Observable.prototype.startWith = startWith_1.startWith;
  //# sourceMappingURL=startWith.js.map
  
  /***/ }),
  /* 278 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var subscribeOn_1 = __webpack_require__(420);
  Observable_1.Observable.prototype.subscribeOn = subscribeOn_1.subscribeOn;
  //# sourceMappingURL=subscribeOn.js.map
  
  /***/ }),
  /* 279 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var switch_1 = __webpack_require__(421);
  Observable_1.Observable.prototype.switch = switch_1._switch;
  Observable_1.Observable.prototype._switch = switch_1._switch;
  //# sourceMappingURL=switch.js.map
  
  /***/ }),
  /* 280 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var switchMap_1 = __webpack_require__(422);
  Observable_1.Observable.prototype.switchMap = switchMap_1.switchMap;
  //# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  /* 281 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var switchMapTo_1 = __webpack_require__(423);
  Observable_1.Observable.prototype.switchMapTo = switchMapTo_1.switchMapTo;
  //# sourceMappingURL=switchMapTo.js.map
  
  /***/ }),
  /* 282 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var take_1 = __webpack_require__(424);
  Observable_1.Observable.prototype.take = take_1.take;
  //# sourceMappingURL=take.js.map
  
  /***/ }),
  /* 283 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var takeLast_1 = __webpack_require__(425);
  Observable_1.Observable.prototype.takeLast = takeLast_1.takeLast;
  //# sourceMappingURL=takeLast.js.map
  
  /***/ }),
  /* 284 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var takeUntil_1 = __webpack_require__(426);
  Observable_1.Observable.prototype.takeUntil = takeUntil_1.takeUntil;
  //# sourceMappingURL=takeUntil.js.map
  
  /***/ }),
  /* 285 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var takeWhile_1 = __webpack_require__(427);
  Observable_1.Observable.prototype.takeWhile = takeWhile_1.takeWhile;
  //# sourceMappingURL=takeWhile.js.map
  
  /***/ }),
  /* 286 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var throttle_1 = __webpack_require__(428);
  Observable_1.Observable.prototype.throttle = throttle_1.throttle;
  //# sourceMappingURL=throttle.js.map
  
  /***/ }),
  /* 287 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var throttleTime_1 = __webpack_require__(429);
  Observable_1.Observable.prototype.throttleTime = throttleTime_1.throttleTime;
  //# sourceMappingURL=throttleTime.js.map
  
  /***/ }),
  /* 288 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var timeInterval_1 = __webpack_require__(73);
  Observable_1.Observable.prototype.timeInterval = timeInterval_1.timeInterval;
  //# sourceMappingURL=timeInterval.js.map
  
  /***/ }),
  /* 289 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var timeout_1 = __webpack_require__(430);
  Observable_1.Observable.prototype.timeout = timeout_1.timeout;
  //# sourceMappingURL=timeout.js.map
  
  /***/ }),
  /* 290 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var timeoutWith_1 = __webpack_require__(431);
  Observable_1.Observable.prototype.timeoutWith = timeoutWith_1.timeoutWith;
  //# sourceMappingURL=timeoutWith.js.map
  
  /***/ }),
  /* 291 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var timestamp_1 = __webpack_require__(432);
  Observable_1.Observable.prototype.timestamp = timestamp_1.timestamp;
  //# sourceMappingURL=timestamp.js.map
  
  /***/ }),
  /* 292 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var toArray_1 = __webpack_require__(433);
  Observable_1.Observable.prototype.toArray = toArray_1.toArray;
  //# sourceMappingURL=toArray.js.map
  
  /***/ }),
  /* 293 */
  /***/ (function(module, exports) {
  
  // HACK: does nothing, because `toPromise` now lives on the `Observable` itself.
  // leaving this module here to prevent breakage.
  //# sourceMappingURL=toPromise.js.map
  
  /***/ }),
  /* 294 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var window_1 = __webpack_require__(434);
  Observable_1.Observable.prototype.window = window_1.window;
  //# sourceMappingURL=window.js.map
  
  /***/ }),
  /* 295 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var windowCount_1 = __webpack_require__(435);
  Observable_1.Observable.prototype.windowCount = windowCount_1.windowCount;
  //# sourceMappingURL=windowCount.js.map
  
  /***/ }),
  /* 296 */
  /***/ (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
  
  /***/ }),
  /* 297 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var windowToggle_1 = __webpack_require__(437);
  Observable_1.Observable.prototype.windowToggle = windowToggle_1.windowToggle;
  //# sourceMappingURL=windowToggle.js.map
  
  /***/ }),
  /* 298 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var windowWhen_1 = __webpack_require__(438);
  Observable_1.Observable.prototype.windowWhen = windowWhen_1.windowWhen;
  //# sourceMappingURL=windowWhen.js.map
  
  /***/ }),
  /* 299 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var withLatestFrom_1 = __webpack_require__(439);
  Observable_1.Observable.prototype.withLatestFrom = withLatestFrom_1.withLatestFrom;
  //# sourceMappingURL=withLatestFrom.js.map
  
  /***/ }),
  /* 300 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var zip_1 = __webpack_require__(440);
  Observable_1.Observable.prototype.zip = zip_1.zipProto;
  //# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 301 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(0);
  var zipAll_1 = __webpack_require__(441);
  Observable_1.Observable.prototype.zipAll = zipAll_1.zipAll;
  //# sourceMappingURL=zipAll.js.map
  
  /***/ }),
  /* 302 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(40);
  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
  
  /***/ }),
  /* 303 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(26);
  /**
   * 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, but 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 `func` function
       * calls its callback with one argument, the Observable will emit that value.
       * If on the other hand callback is called with multiple values, resulting
       * Observable will emit an array with these arguments.
       *
       * It is very important to remember, that input function `func` is not called
       * when output function is, but rather when Observable returned by output
       * function is subscribed. This means if `func` makes AJAX request, that request
       * will be made every time someone subscribes to resulting Observable, but not before.
       *
       * Optionally, selector function can be passed to `bindObservable`. That function
       * takes the same arguments as callback, and returns value
       * that will be emitted by Observable instead of callback parameters themselves.
       * Even though by default multiple arguments passed to callback appear in the stream as array,
       * selector function will be called with arguments directly, just as callback would.
       * This means you can imagine default selector (when one is not provided explicitly)
       * as function that aggregates all its arguments into array, or simply returns first argument,
       * if there is only one.
       *
       * Last optional parameter - {@link Scheduler} - can be used to control when call
       * to `func` happens after someone subscribes to Observable, as well as when results
       * passed to callback will be emitted. By default subscription to Observable calls `func`
       * synchronously, but using `Scheduler.async` as last parameter will defer call to input function,
       * just like wrapping that call in `setTimeout` with time `0` would. So if you use async Scheduler
       * and call `subscribe` on output Observable, all function calls that are currently executing,
       * will end before `func` is invoked.
       *
       * When it comes to emitting results passed to callback, by default they are emitted
       * immediately after `func` invokes callback. In particular, if callback is called synchronously,
       * then subscription to resulting Observable will call `next` function synchronously as well.
       * If you want to defer that call, using `Scheduler.async` will, again, do the job.
       * This means that by using `Scheduler.async` you can, in a sense, ensure that `func`
       * always calls its callback asynchronously, thus avoiding terrifying Zalgo.
       *
       * Note that Observable created by output function will always emit only one value
       * and then complete right after. Even if `func` calls callback multiple times, values from
       * second and following calls will never 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), that context will be set
       * to the same context that output function has at call time. In particular, if `func`
       * is called as method of some object, in order to preserve proper behaviour,
       * it is recommended to set context of output function to that object as well,
       * provided `func` is not already bound.
       *
       * If input function calls its callback in "node style" (i.e. first argument to callback is
       * optional error parameter signaling whether call failed or not), {@link bindNodeCallback}
       * provides convenient error handling and probably is a better choice.
       * `bindCallback` will treat such functions without any difference and error parameter
       * (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 array of arguments passed to 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 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 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 Function with a 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 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
  
  /***/ }),
  /* 304 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(26);
  /**
   * 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
  
  /***/ }),
  /* 305 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 306 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 307 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 308 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(38);
  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 () { return source_1.removeEventListener(eventName, handler); };
          }
          else if (isJQueryStyleEventEmitter(sourceObj)) {
              var source_2 = sourceObj;
              sourceObj.on(eventName, handler);
              unsubscribe = function () { return source_2.off(eventName, handler); };
          }
          else if (isNodeStyleEventEmitter(sourceObj)) {
              var source_3 = sourceObj;
              sourceObj.addListener(eventName, handler);
              unsubscribe = function () { 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
  
  /***/ }),
  /* 309 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(38);
  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
  
  /***/ }),
  /* 310 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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 (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
  
  /***/ }),
  /* 311 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 312 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(23);
  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
  
  /***/ }),
  /* 313 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(21);
  /**
   * 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
  
  /***/ }),
  /* 314 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(57);
  /**
   * 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
  
  /***/ }),
  /* 315 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 316 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 317 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(152);
  var isNumeric_1 = __webpack_require__(23);
  /**
   * 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
  
  /***/ }),
  /* 318 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(23);
  var Observable_1 = __webpack_require__(0);
  var async_1 = __webpack_require__(4);
  var isScheduler_1 = __webpack_require__(10);
  var isDate_1 = __webpack_require__(37);
  /**
   * 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
  
  /***/ }),
  /* 319 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 320 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var BoundCallbackObservable_1 = __webpack_require__(303);
  exports.bindCallback = BoundCallbackObservable_1.BoundCallbackObservable.create;
  //# sourceMappingURL=bindCallback.js.map
  
  /***/ }),
  /* 321 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var BoundNodeCallbackObservable_1 = __webpack_require__(304);
  exports.bindNodeCallback = BoundNodeCallbackObservable_1.BoundNodeCallbackObservable.create;
  //# sourceMappingURL=bindNodeCallback.js.map
  
  /***/ }),
  /* 322 */
  /***/ (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__(28);
  /* 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
  
  /***/ }),
  /* 323 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var DeferObservable_1 = __webpack_require__(305);
  exports.defer = DeferObservable_1.DeferObservable.create;
  //# sourceMappingURL=defer.js.map
  
  /***/ }),
  /* 324 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(27);
  var tryCatch_1 = __webpack_require__(8);
  var errorObject_1 = __webpack_require__(7);
  var assign_1 = __webpack_require__(461);
  /**
   * 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
  
  /***/ }),
  /* 325 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var AjaxObservable_1 = __webpack_require__(68);
  exports.ajax = AjaxObservable_1.AjaxObservable.create;
  //# sourceMappingURL=ajax.js.map
  
  /***/ }),
  /* 326 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var WebSocketSubject_1 = __webpack_require__(324);
  exports.webSocket = WebSocketSubject_1.WebSocketSubject.create;
  //# sourceMappingURL=webSocket.js.map
  
  /***/ }),
  /* 327 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var EmptyObservable_1 = __webpack_require__(13);
  exports.empty = EmptyObservable_1.EmptyObservable.create;
  //# sourceMappingURL=empty.js.map
  
  /***/ }),
  /* 328 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ForkJoinObservable_1 = __webpack_require__(307);
  exports.forkJoin = ForkJoinObservable_1.ForkJoinObservable.create;
  //# sourceMappingURL=forkJoin.js.map
  
  /***/ }),
  /* 329 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var FromEventObservable_1 = __webpack_require__(308);
  exports.fromEvent = FromEventObservable_1.FromEventObservable.create;
  //# sourceMappingURL=fromEvent.js.map
  
  /***/ }),
  /* 330 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var FromEventPatternObservable_1 = __webpack_require__(309);
  exports.fromEventPattern = FromEventPatternObservable_1.FromEventPatternObservable.create;
  //# sourceMappingURL=fromEventPattern.js.map
  
  /***/ }),
  /* 331 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var PromiseObservable_1 = __webpack_require__(67);
  exports.fromPromise = PromiseObservable_1.PromiseObservable.create;
  //# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  /* 332 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var GenerateObservable_1 = __webpack_require__(310);
  exports.generate = GenerateObservable_1.GenerateObservable.create;
  //# sourceMappingURL=generate.js.map
  
  /***/ }),
  /* 333 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var IfObservable_1 = __webpack_require__(311);
  exports._if = IfObservable_1.IfObservable.create;
  //# sourceMappingURL=if.js.map
  
  /***/ }),
  /* 334 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var IntervalObservable_1 = __webpack_require__(312);
  exports.interval = IntervalObservable_1.IntervalObservable.create;
  //# sourceMappingURL=interval.js.map
  
  /***/ }),
  /* 335 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var merge_1 = __webpack_require__(72);
  exports.merge = merge_1.mergeStatic;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  /* 336 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var NeverObservable_1 = __webpack_require__(314);
  exports.never = NeverObservable_1.NeverObservable.create;
  //# sourceMappingURL=never.js.map
  
  /***/ }),
  /* 337 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var onErrorResumeNext_1 = __webpack_require__(51);
  exports.onErrorResumeNext = onErrorResumeNext_1.onErrorResumeNextStatic;
  //# sourceMappingURL=onErrorResumeNext.js.map
  
  /***/ }),
  /* 338 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var PairsObservable_1 = __webpack_require__(315);
  exports.pairs = PairsObservable_1.PairsObservable.create;
  //# sourceMappingURL=pairs.js.map
  
  /***/ }),
  /* 339 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var RangeObservable_1 = __webpack_require__(316);
  exports.range = RangeObservable_1.RangeObservable.create;
  //# sourceMappingURL=range.js.map
  
  /***/ }),
  /* 340 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ErrorObservable_1 = __webpack_require__(306);
  exports._throw = ErrorObservable_1.ErrorObservable.create;
  //# sourceMappingURL=throw.js.map
  
  /***/ }),
  /* 341 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var UsingObservable_1 = __webpack_require__(319);
  exports.using = UsingObservable_1.UsingObservable.create;
  //# sourceMappingURL=using.js.map
  
  /***/ }),
  /* 342 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var zip_1 = __webpack_require__(32);
  exports.zip = zip_1.zipStatic;
  //# sourceMappingURL=zip.js.map
  
  /***/ }),
  /* 343 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var audit_1 = __webpack_require__(43);
  /**
   * 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
  
  /***/ }),
  /* 344 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var auditTime_1 = __webpack_require__(74);
  /**
   * 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
  
  /***/ }),
  /* 345 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var buffer_1 = __webpack_require__(75);
  /**
   * 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
  
  /***/ }),
  /* 346 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var bufferCount_1 = __webpack_require__(76);
  /**
   * 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
  
  /***/ }),
  /* 347 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var isScheduler_1 = __webpack_require__(10);
  var bufferTime_1 = __webpack_require__(77);
  /* 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
  
  /***/ }),
  /* 348 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var bufferToggle_1 = __webpack_require__(78);
  /**
   * 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
  
  /***/ }),
  /* 349 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var bufferWhen_1 = __webpack_require__(79);
  /**
   * 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
  
  /***/ }),
  /* 350 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var catchError_1 = __webpack_require__(80);
  /**
   * 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
  
  /***/ }),
  /* 351 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var combineAll_1 = __webpack_require__(81);
  /**
   * 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
  
  /***/ }),
  /* 352 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var combineLatest_1 = __webpack_require__(28);
  /* 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
  
  /***/ }),
  /* 353 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concat_1 = __webpack_require__(82);
  /* 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
  
  /***/ }),
  /* 354 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concatAll_1 = __webpack_require__(44);
  /* 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
  
  /***/ }),
  /* 355 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concatMap_1 = __webpack_require__(45);
  /* 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
  
  /***/ }),
  /* 356 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concatMapTo_1 = __webpack_require__(83);
  /* 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
  
  /***/ }),
  /* 357 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var count_1 = __webpack_require__(84);
  /**
   * 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
  
  /***/ }),
  /* 358 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var debounce_1 = __webpack_require__(85);
  /**
   * 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
  
  /***/ }),
  /* 359 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var debounceTime_1 = __webpack_require__(86);
  /**
   * 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
  
  /***/ }),
  /* 360 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var defaultIfEmpty_1 = __webpack_require__(46);
  /* 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
  
  /***/ }),
  /* 361 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var delay_1 = __webpack_require__(87);
  /**
   * 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
  
  /***/ }),
  /* 362 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var delayWhen_1 = __webpack_require__(88);
  /**
   * 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
  
  /***/ }),
  /* 363 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var dematerialize_1 = __webpack_require__(89);
  /**
   * 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
  
  /***/ }),
  /* 364 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var distinct_1 = __webpack_require__(90);
  /**
   * 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
  
  /***/ }),
  /* 365 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var distinctUntilChanged_1 = __webpack_require__(47);
  /* 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
  
  /***/ }),
  /* 366 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var distinctUntilKeyChanged_1 = __webpack_require__(91);
  /* 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
  
  /***/ }),
  /* 367 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var tap_1 = __webpack_require__(138);
  /* 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
  
  /***/ }),
  /* 368 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var elementAt_1 = __webpack_require__(92);
  /**
   * 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
  
  /***/ }),
  /* 369 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var every_1 = __webpack_require__(93);
  /**
   * 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
  
  /***/ }),
  /* 370 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var exhaust_1 = __webpack_require__(94);
  /**
   * 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
  
  /***/ }),
  /* 371 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var exhaustMap_1 = __webpack_require__(95);
  /* 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
  
  /***/ }),
  /* 372 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var expand_1 = __webpack_require__(96);
  /* 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
  
  /***/ }),
  /* 373 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var filter_1 = __webpack_require__(48);
  /* 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
  
  /***/ }),
  /* 374 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var finalize_1 = __webpack_require__(97);
  /**
   * 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
  
  /***/ }),
  /* 375 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var find_1 = __webpack_require__(49);
  /* 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
  
  /***/ }),
  /* 376 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var findIndex_1 = __webpack_require__(98);
  /**
   * 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
  
  /***/ }),
  /* 377 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var first_1 = __webpack_require__(99);
  /**
   * 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
  
  /***/ }),
  /* 378 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var groupBy_1 = __webpack_require__(100);
  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
  
  /***/ }),
  /* 379 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var ignoreElements_1 = __webpack_require__(101);
  /**
   * 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
  
  /***/ }),
  /* 380 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var isEmpty_1 = __webpack_require__(102);
  /**
   * 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
  
  /***/ }),
  /* 381 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var last_1 = __webpack_require__(103);
  /* 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
  
  /***/ }),
  /* 382 */
  /***/ (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
  
  /***/ }),
  /* 383 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var map_1 = __webpack_require__(16);
  /**
   * 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
  
  /***/ }),
  /* 384 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mapTo_1 = __webpack_require__(104);
  /**
   * 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
  
  /***/ }),
  /* 385 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var materialize_1 = __webpack_require__(105);
  /**
   * 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
  
  /***/ }),
  /* 386 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var max_1 = __webpack_require__(106);
  /**
   * 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
  
  /***/ }),
  /* 387 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeAll_1 = __webpack_require__(29);
  /**
   * 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
  
  /***/ }),
  /* 388 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeMap_1 = __webpack_require__(17);
  /* 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
  
  /***/ }),
  /* 389 */
  /***/ (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
  
  /***/ }),
  /* 390 */
  /***/ (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
  
  /***/ }),
  /* 391 */
  /***/ (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
  
  /***/ }),
  /* 392 */
  /***/ (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
  
  /***/ }),
  /* 393 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var observeOn_1 = __webpack_require__(30);
  /**
   *
   * 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
  
  /***/ }),
  /* 394 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var onErrorResumeNext_1 = __webpack_require__(51);
  /* 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
  
  /***/ }),
  /* 395 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var pairwise_1 = __webpack_require__(110);
  /**
   * 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
  
  /***/ }),
  /* 396 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var partition_1 = __webpack_require__(111);
  /**
   * 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
  
  /***/ }),
  /* 397 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var pluck_1 = __webpack_require__(112);
  /**
   * 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
  
  /***/ }),
  /* 398 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var publish_1 = __webpack_require__(113);
  /* 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
  
  /***/ }),
  /* 399 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var publishBehavior_1 = __webpack_require__(114);
  /**
   * @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
  
  /***/ }),
  /* 400 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var publishLast_1 = __webpack_require__(115);
  /**
   * @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
  
  /***/ }),
  /* 401 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var publishReplay_1 = __webpack_require__(116);
  /* 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
  
  /***/ }),
  /* 402 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var race_1 = __webpack_require__(117);
  // NOTE: to support backwards compatability with 5.4.* and lower
  var race_2 = __webpack_require__(42);
  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
  
  /***/ }),
  /* 403 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var reduce_1 = __webpack_require__(18);
  /* 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
  
  /***/ }),
  /* 404 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var repeat_1 = __webpack_require__(118);
  /**
   * 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
  
  /***/ }),
  /* 405 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var repeatWhen_1 = __webpack_require__(119);
  /**
   * 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
  
  /***/ }),
  /* 406 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var retry_1 = __webpack_require__(120);
  /**
   * 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
  
  /***/ }),
  /* 407 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var retryWhen_1 = __webpack_require__(121);
  /**
   * 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
  
  /***/ }),
  /* 408 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var sample_1 = __webpack_require__(122);
  /**
   * 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
  
  /***/ }),
  /* 409 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var sampleTime_1 = __webpack_require__(123);
  /**
   * 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
  
  /***/ }),
  /* 410 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var scan_1 = __webpack_require__(53);
  /* 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
  
  /***/ }),
  /* 411 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var sequenceEqual_1 = __webpack_require__(124);
  /**
   * 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
  
  /***/ }),
  /* 412 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var share_1 = __webpack_require__(125);
  /**
   * 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
  
  /***/ }),
  /* 413 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var shareReplay_1 = __webpack_require__(126);
  /**
   * @method shareReplay
   * @owner Observable
   */
  function shareReplay(bufferSize, windowTime, scheduler) {
      return shareReplay_1.shareReplay(bufferSize, windowTime, scheduler)(this);
  }
  exports.shareReplay = shareReplay;
  ;
  //# sourceMappingURL=shareReplay.js.map
  
  /***/ }),
  /* 414 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var single_1 = __webpack_require__(127);
  /**
   * 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
  
  /***/ }),
  /* 415 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var skip_1 = __webpack_require__(128);
  /**
   * 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
  
  /***/ }),
  /* 416 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var skipLast_1 = __webpack_require__(129);
  /**
   * 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
  
  /***/ }),
  /* 417 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var skipUntil_1 = __webpack_require__(130);
  /**
   * 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
  
  /***/ }),
  /* 418 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var skipWhile_1 = __webpack_require__(131);
  /**
   * 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
  
  /***/ }),
  /* 419 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var startWith_1 = __webpack_require__(132);
  /* 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
  
  /***/ }),
  /* 420 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var subscribeOn_1 = __webpack_require__(443);
  /**
   * 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
  
  /***/ }),
  /* 421 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var switchAll_1 = __webpack_require__(133);
  /**
   * 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
  
  /***/ }),
  /* 422 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var switchMap_1 = __webpack_require__(54);
  /* 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
  
  /***/ }),
  /* 423 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var switchMapTo_1 = __webpack_require__(134);
  /* 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
  
  /***/ }),
  /* 424 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var take_1 = __webpack_require__(135);
  /**
   * 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
  
  /***/ }),
  /* 425 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var takeLast_1 = __webpack_require__(55);
  /**
   * 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
  
  /***/ }),
  /* 426 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var takeUntil_1 = __webpack_require__(136);
  /**
   * 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
  
  /***/ }),
  /* 427 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var takeWhile_1 = __webpack_require__(137);
  /**
   * 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
  
  /***/ }),
  /* 428 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var throttle_1 = __webpack_require__(31);
  /**
   * 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
  
  /***/ }),
  /* 429 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var throttle_1 = __webpack_require__(31);
  var throttleTime_1 = __webpack_require__(139);
  /**
   * 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
  
  /***/ }),
  /* 430 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var timeout_1 = __webpack_require__(141);
  /**
   *
   * 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
  
  /***/ }),
  /* 431 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var timeoutWith_1 = __webpack_require__(142);
  /* 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
  
  /***/ }),
  /* 432 */
  /***/ (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
  
  /***/ }),
  /* 433 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var toArray_1 = __webpack_require__(143);
  /**
   * 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
  
  /***/ }),
  /* 434 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var window_1 = __webpack_require__(144);
  /**
   * 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
  
  /***/ }),
  /* 435 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var windowCount_1 = __webpack_require__(145);
  /**
   * 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
  
  /***/ }),
  /* 436 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var async_1 = __webpack_require__(4);
  var isNumeric_1 = __webpack_require__(23);
  var isScheduler_1 = __webpack_require__(10);
  var windowTime_1 = __webpack_require__(146);
  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 windowToggle_1 = __webpack_require__(147);
  /**
   * 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
  
  /***/ }),
  /* 438 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var windowWhen_1 = __webpack_require__(148);
  /**
   * 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
  
  /***/ }),
  /* 439 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var withLatestFrom_1 = __webpack_require__(149);
  /* 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
  
  /***/ }),
  /* 440 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var zip_1 = __webpack_require__(32);
  /* 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
  
  /***/ }),
  /* 441 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var zipAll_1 = __webpack_require__(150);
  /**
   * @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
  
  /***/ }),
  /* 442 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var audit_1 = __webpack_require__(43);
  exports.audit = audit_1.audit;
  var auditTime_1 = __webpack_require__(74);
  exports.auditTime = auditTime_1.auditTime;
  var buffer_1 = __webpack_require__(75);
  exports.buffer = buffer_1.buffer;
  var bufferCount_1 = __webpack_require__(76);
  exports.bufferCount = bufferCount_1.bufferCount;
  var bufferTime_1 = __webpack_require__(77);
  exports.bufferTime = bufferTime_1.bufferTime;
  var bufferToggle_1 = __webpack_require__(78);
  exports.bufferToggle = bufferToggle_1.bufferToggle;
  var bufferWhen_1 = __webpack_require__(79);
  exports.bufferWhen = bufferWhen_1.bufferWhen;
  var catchError_1 = __webpack_require__(80);
  exports.catchError = catchError_1.catchError;
  var combineAll_1 = __webpack_require__(81);
  exports.combineAll = combineAll_1.combineAll;
  var combineLatest_1 = __webpack_require__(28);
  exports.combineLatest = combineLatest_1.combineLatest;
  var concat_1 = __webpack_require__(82);
  exports.concat = concat_1.concat;
  var concatAll_1 = __webpack_require__(44);
  exports.concatAll = concatAll_1.concatAll;
  var concatMap_1 = __webpack_require__(45);
  exports.concatMap = concatMap_1.concatMap;
  var concatMapTo_1 = __webpack_require__(83);
  exports.concatMapTo = concatMapTo_1.concatMapTo;
  var count_1 = __webpack_require__(84);
  exports.count = count_1.count;
  var debounce_1 = __webpack_require__(85);
  exports.debounce = debounce_1.debounce;
  var debounceTime_1 = __webpack_require__(86);
  exports.debounceTime = debounceTime_1.debounceTime;
  var defaultIfEmpty_1 = __webpack_require__(46);
  exports.defaultIfEmpty = defaultIfEmpty_1.defaultIfEmpty;
  var delay_1 = __webpack_require__(87);
  exports.delay = delay_1.delay;
  var delayWhen_1 = __webpack_require__(88);
  exports.delayWhen = delayWhen_1.delayWhen;
  var dematerialize_1 = __webpack_require__(89);
  exports.dematerialize = dematerialize_1.dematerialize;
  var distinct_1 = __webpack_require__(90);
  exports.distinct = distinct_1.distinct;
  var distinctUntilChanged_1 = __webpack_require__(47);
  exports.distinctUntilChanged = distinctUntilChanged_1.distinctUntilChanged;
  var distinctUntilKeyChanged_1 = __webpack_require__(91);
  exports.distinctUntilKeyChanged = distinctUntilKeyChanged_1.distinctUntilKeyChanged;
  var elementAt_1 = __webpack_require__(92);
  exports.elementAt = elementAt_1.elementAt;
  var every_1 = __webpack_require__(93);
  exports.every = every_1.every;
  var exhaust_1 = __webpack_require__(94);
  exports.exhaust = exhaust_1.exhaust;
  var exhaustMap_1 = __webpack_require__(95);
  exports.exhaustMap = exhaustMap_1.exhaustMap;
  var expand_1 = __webpack_require__(96);
  exports.expand = expand_1.expand;
  var filter_1 = __webpack_require__(48);
  exports.filter = filter_1.filter;
  var finalize_1 = __webpack_require__(97);
  exports.finalize = finalize_1.finalize;
  var find_1 = __webpack_require__(49);
  exports.find = find_1.find;
  var findIndex_1 = __webpack_require__(98);
  exports.findIndex = findIndex_1.findIndex;
  var first_1 = __webpack_require__(99);
  exports.first = first_1.first;
  var groupBy_1 = __webpack_require__(100);
  exports.groupBy = groupBy_1.groupBy;
  var ignoreElements_1 = __webpack_require__(101);
  exports.ignoreElements = ignoreElements_1.ignoreElements;
  var isEmpty_1 = __webpack_require__(102);
  exports.isEmpty = isEmpty_1.isEmpty;
  var last_1 = __webpack_require__(103);
  exports.last = last_1.last;
  var map_1 = __webpack_require__(16);
  exports.map = map_1.map;
  var mapTo_1 = __webpack_require__(104);
  exports.mapTo = mapTo_1.mapTo;
  var materialize_1 = __webpack_require__(105);
  exports.materialize = materialize_1.materialize;
  var max_1 = __webpack_require__(106);
  exports.max = max_1.max;
  var merge_1 = __webpack_require__(50);
  exports.merge = merge_1.merge;
  var mergeAll_1 = __webpack_require__(29);
  exports.mergeAll = mergeAll_1.mergeAll;
  var mergeMap_1 = __webpack_require__(17);
  exports.mergeMap = mergeMap_1.mergeMap;
  var mergeMap_2 = __webpack_require__(17);
  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__(30);
  exports.observeOn = observeOn_1.observeOn;
  var onErrorResumeNext_1 = __webpack_require__(51);
  exports.onErrorResumeNext = onErrorResumeNext_1.onErrorResumeNext;
  var pairwise_1 = __webpack_require__(110);
  exports.pairwise = pairwise_1.pairwise;
  var partition_1 = __webpack_require__(111);
  exports.partition = partition_1.partition;
  var pluck_1 = __webpack_require__(112);
  exports.pluck = pluck_1.pluck;
  var publish_1 = __webpack_require__(113);
  exports.publish = publish_1.publish;
  var publishBehavior_1 = __webpack_require__(114);
  exports.publishBehavior = publishBehavior_1.publishBehavior;
  var publishLast_1 = __webpack_require__(115);
  exports.publishLast = publishLast_1.publishLast;
  var publishReplay_1 = __webpack_require__(116);
  exports.publishReplay = publishReplay_1.publishReplay;
  var race_1 = __webpack_require__(117);
  exports.race = race_1.race;
  var reduce_1 = __webpack_require__(18);
  exports.reduce = reduce_1.reduce;
  var repeat_1 = __webpack_require__(118);
  exports.repeat = repeat_1.repeat;
  var repeatWhen_1 = __webpack_require__(119);
  exports.repeatWhen = repeatWhen_1.repeatWhen;
  var retry_1 = __webpack_require__(120);
  exports.retry = retry_1.retry;
  var retryWhen_1 = __webpack_require__(121);
  exports.retryWhen = retryWhen_1.retryWhen;
  var refCount_1 = __webpack_require__(52);
  exports.refCount = refCount_1.refCount;
  var sample_1 = __webpack_require__(122);
  exports.sample = sample_1.sample;
  var sampleTime_1 = __webpack_require__(123);
  exports.sampleTime = sampleTime_1.sampleTime;
  var scan_1 = __webpack_require__(53);
  exports.scan = scan_1.scan;
  var sequenceEqual_1 = __webpack_require__(124);
  exports.sequenceEqual = sequenceEqual_1.sequenceEqual;
  var share_1 = __webpack_require__(125);
  exports.share = share_1.share;
  var shareReplay_1 = __webpack_require__(126);
  exports.shareReplay = shareReplay_1.shareReplay;
  var single_1 = __webpack_require__(127);
  exports.single = single_1.single;
  var skip_1 = __webpack_require__(128);
  exports.skip = skip_1.skip;
  var skipLast_1 = __webpack_require__(129);
  exports.skipLast = skipLast_1.skipLast;
  var skipUntil_1 = __webpack_require__(130);
  exports.skipUntil = skipUntil_1.skipUntil;
  var skipWhile_1 = __webpack_require__(131);
  exports.skipWhile = skipWhile_1.skipWhile;
  var startWith_1 = __webpack_require__(132);
  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 './subscribeOn';
  var switchAll_1 = __webpack_require__(133);
  exports.switchAll = switchAll_1.switchAll;
  var switchMap_1 = __webpack_require__(54);
  exports.switchMap = switchMap_1.switchMap;
  var switchMapTo_1 = __webpack_require__(134);
  exports.switchMapTo = switchMapTo_1.switchMapTo;
  var take_1 = __webpack_require__(135);
  exports.take = take_1.take;
  var takeLast_1 = __webpack_require__(55);
  exports.takeLast = takeLast_1.takeLast;
  var takeUntil_1 = __webpack_require__(136);
  exports.takeUntil = takeUntil_1.takeUntil;
  var takeWhile_1 = __webpack_require__(137);
  exports.takeWhile = takeWhile_1.takeWhile;
  var tap_1 = __webpack_require__(138);
  exports.tap = tap_1.tap;
  var throttle_1 = __webpack_require__(31);
  exports.throttle = throttle_1.throttle;
  var throttleTime_1 = __webpack_require__(139);
  exports.throttleTime = throttleTime_1.throttleTime;
  var timeInterval_1 = __webpack_require__(140);
  exports.timeInterval = timeInterval_1.timeInterval;
  var timeout_1 = __webpack_require__(141);
  exports.timeout = timeout_1.timeout;
  var timeoutWith_1 = __webpack_require__(142);
  exports.timeoutWith = timeoutWith_1.timeoutWith;
  var timestamp_1 = __webpack_require__(56);
  exports.timestamp = timestamp_1.timestamp;
  var toArray_1 = __webpack_require__(143);
  exports.toArray = toArray_1.toArray;
  var window_1 = __webpack_require__(144);
  exports.window = window_1.window;
  var windowCount_1 = __webpack_require__(145);
  exports.windowCount = windowCount_1.windowCount;
  var windowTime_1 = __webpack_require__(146);
  exports.windowTime = windowTime_1.windowTime;
  var windowToggle_1 = __webpack_require__(147);
  exports.windowToggle = windowToggle_1.windowToggle;
  var windowWhen_1 = __webpack_require__(148);
  exports.windowWhen = windowWhen_1.windowWhen;
  var withLatestFrom_1 = __webpack_require__(149);
  exports.withLatestFrom = withLatestFrom_1.withLatestFrom;
  var zip_1 = __webpack_require__(32);
  exports.zip = zip_1.zip;
  var zipAll_1 = __webpack_require__(150);
  exports.zipAll = zipAll_1.zipAll;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  /* 443 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var SubscribeOnObservable_1 = __webpack_require__(317);
  /**
   * 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
  
  /***/ }),
  /* 444 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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
  
  /***/ }),
  /* 445 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(19);
  var AnimationFrame_1 = __webpack_require__(455);
  /**
   * 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
  
  /***/ }),
  /* 446 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(20);
  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
  
  /***/ }),
  /* 447 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(457);
  var AsyncAction_1 = __webpack_require__(19);
  /**
   * 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
  
  /***/ }),
  /* 448 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(20);
  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
  
  /***/ }),
  /* 449 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(19);
  /**
   * 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
  
  /***/ }),
  /* 450 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(20);
  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
  
  /***/ }),
  /* 451 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var AnimationFrameAction_1 = __webpack_require__(445);
  var AnimationFrameScheduler_1 = __webpack_require__(446);
  /**
   *
   * 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
  
  /***/ }),
  /* 452 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(155);
  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
  
  /***/ }),
  /* 453 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(155);
  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
  
  /***/ }),
  /* 454 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __extends = (this && this.__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__(15);
  var ColdObservable_1 = __webpack_require__(452);
  var HotObservable_1 = __webpack_require__(453);
  var SubscriptionLog_1 = __webpack_require__(154);
  var VirtualTimeScheduler_1 = __webpack_require__(151);
  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 (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 (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 !== '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
  
  /***/ }),
  /* 455 */
  /***/ (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
  
  /***/ }),
  /* 456 */
  /***/ (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
  
  /***/ }),
  /* 457 */
  /***/ (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__(163).clearImmediate, __webpack_require__(163).setImmediate))
  
  /***/ }),
  /* 458 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var root_1 = __webpack_require__(9);
  var MapPolyfill_1 = __webpack_require__(459);
  exports.Map = root_1.root.Map || (function () { return MapPolyfill_1.MapPolyfill; })();
  //# sourceMappingURL=Map.js.map
  
  /***/ }),
  /* 459 */
  /***/ (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
  
  /***/ }),
  /* 460 */
  /***/ (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 () {
                  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
  
  /***/ }),
  /* 461 */
  /***/ (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
  
  /***/ }),
  /* 462 */
  /***/ (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
  
  /***/ }),
  /* 463 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Subscriber_1 = __webpack_require__(1);
  var rxSubscriber_1 = __webpack_require__(34);
  var Observer_1 = __webpack_require__(63);
  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
  
  /***/ }),
  /* 464 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* 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(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(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(handle) {
              global.postMessage(messagePrefix + handle, "*");
          };
      }
  
      function installMessageChannelImplementation() {
          var channel = new MessageChannel();
          channel.port1.onmessage = function(event) {
              var handle = event.data;
              runIfPresent(handle);
          };
  
          registerImmediate = function(handle) {
              channel.port2.postMessage(handle);
          };
      }
  
      function installReadyStateChangeImplementation() {
          var html = doc.documentElement;
          registerImmediate = function(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(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" ? this : global : self));
  
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(164), __webpack_require__(168)))
  
  /***/ }),
  /* 465 */
  /***/ (function(module, exports, __webpack_require__) {
  
  
          var result = __webpack_require__(166);
  
          if (typeof result === "string") {
              module.exports = result;
          } else {
              module.exports = result.toString();
          }
      
  
  /***/ }),
  /* 466 */
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE_466__;
  
  /***/ }),
  /* 467 */
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE_467__;
  
  /***/ }),
  /* 468 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  var multiselect_component_1 = __webpack_require__(39);
  exports.AngularMultiSelect = multiselect_component_1.AngularMultiSelect;
  var clickOutside_1 = __webpack_require__(59);
  exports.ClickOutsideDirective = clickOutside_1.ClickOutsideDirective;
  var list_filter_1 = __webpack_require__(60);
  exports.ListFilterPipe = list_filter_1.ListFilterPipe;
  var menu_item_1 = __webpack_require__(25);
  exports.Item = menu_item_1.Item;
  var menu_item_2 = __webpack_require__(25);
  exports.TemplateRenderer = menu_item_2.TemplateRenderer;
  var multiselect_component_2 = __webpack_require__(39);
  exports.AngularMultiSelectModule = multiselect_component_2.AngularMultiSelectModule;
  
  
  /***/ })
  /******/ ]);
  });
  //# sourceMappingURL=angular2-multiselect-dropdown.umd.js.map