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);
  	/**
  	 * 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.</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 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 this.lift(new DoOperator(nextOrObserver, error, complete));
  	}
  	exports._do = _do;
  	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=do.js.map
  
  /***/ }