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);
  	var Observable_1 = __webpack_require__(5);
  	var OuterSubscriber_1 = __webpack_require__(309);
  	var subscribeToResult_1 = __webpack_require__(310);
  	/**
  	 * 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 new SubscriptionDelayObservable(this, subscriptionDelay)
  	            .lift(new DelayWhenOperator(delayDurationSelector));
  	    }
  	    return this.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);
  	        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
  
  /***/ }