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 async_1 = __webpack_require__(349);
  	/**
  	 * 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 Scheduler} 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 Scheduler} to use for
  	 * managing the timers that handle the sampling.
  	 * @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) {
  	    if (scheduler === void 0) { scheduler = async_1.async; }
  	    return this.lift(new ThrottleTimeOperator(duration, scheduler));
  	}
  	exports.throttleTime = throttleTime;
  	var ThrottleTimeOperator = (function () {
  	    function ThrottleTimeOperator(duration, scheduler) {
  	        this.duration = duration;
  	        this.scheduler = scheduler;
  	    }
  	    ThrottleTimeOperator.prototype.call = function (subscriber, source) {
  	        return source._subscribe(new ThrottleTimeSubscriber(subscriber, this.duration, this.scheduler));
  	    };
  	    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) {
  	        _super.call(this, destination);
  	        this.duration = duration;
  	        this.scheduler = scheduler;
  	    }
  	    ThrottleTimeSubscriber.prototype._next = function (value) {
  	        if (!this.throttled) {
  	            this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this }));
  	            this.destination.next(value);
  	        }
  	    };
  	    ThrottleTimeSubscriber.prototype.clearThrottle = function () {
  	        var throttled = this.throttled;
  	        if (throttled) {
  	            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
  
  /***/ }