docs: 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__(8);
  	/**
  	 * 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 distinctKey}
  	 * @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 this.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;
  	        this.predicate = predicate;
  	    }
  	    // 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
  
  /***/ }