docs: function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var mergeMap_1 = __webpack_require__(420);
  	/**
  	 * 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));
  	 *
  	 * @see {@link concat}
  	 * @see {@link concatAll}
  	 * @see {@link concatMapTo}
  	 * @see {@link exhaustMap}
  	 * @see {@link mergeMap}
  	 * @see {@link switchMap}
  	 *
  	 * @param {function(value: T, ?index: number): Observable} 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 of values merged from the projected
  	 * Observables as they were subscribed to, one at a time. Optionally, these
  	 * values may have been projected from a passed `projectResult` argument.
  	 * @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 this.lift(new mergeMap_1.MergeMapOperator(project, resultSelector, 1));
  	}
  	exports.concatMap = concatMap;
  	//# sourceMappingURL=concatMap.js.map
  
  /***/ }