docs: function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(6);
  	var toSubscriber_1 = __webpack_require__(7);
  	var observable_1 = __webpack_require__(18);
  	/**
  	 * A representation of any set of values over any amount of time. This the most basic building block
  	 * of RxJS.
  	 *
  	 * @class Observable<T>
  	 */
  	var Observable = (function () {
  	    /**
  	     * @constructor
  	     * @param {Function} subscribe the function that is  called when the Observable is
  	     * initially subscribed to. This function is given a Subscriber, to which new values
  	     * can be `next`ed, or an `error` method can be called to raise an error, or
  	     * `complete` can be called to notify of a successful completion.
  	     */
  	    function Observable(subscribe) {
  	        this._isScalar = false;
  	        if (subscribe) {
  	            this._subscribe = subscribe;
  	        }
  	    }
  	    /**
  	     * Creates a new Observable, with this Observable as the source, and the passed
  	     * operator defined as the new observable's operator.
  	     * @method lift
  	     * @param {Operator} operator the operator defining the operation to take on the observable
  	     * @return {Observable} a new observable with the Operator applied
  	     */
  	    Observable.prototype.lift = function (operator) {
  	        var observable = new Observable();
  	        observable.source = this;
  	        observable.operator = operator;
  	        return observable;
  	    };
  	    /**
  	     * Registers handlers for handling emitted values, error and completions from the observable, and
  	     *  executes the observable's subscriber function, which will take action to set up the underlying data stream
  	     * @method subscribe
  	     * @param {PartialObserver|Function} observerOrNext (optional) either an observer defining all functions to be called,
  	     *  or the first of three possible handlers, which is the handler for each value emitted from the observable.
  	     * @param {Function} error (optional) a handler for a terminal event resulting from an error. If no error handler is provided,
  	     *  the error will be thrown as unhandled
  	     * @param {Function} complete (optional) a handler for a terminal event resulting from successful completion.
  	     * @return {ISubscription} a subscription reference to the registered handlers
  	     */
  	    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
  	        var operator = this.operator;
  	        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
  	        if (operator) {
  	            operator.call(sink, this);
  	        }
  	        else {
  	            sink.add(this._subscribe(sink));
  	        }
  	        if (sink.syncErrorThrowable) {
  	            sink.syncErrorThrowable = false;
  	            if (sink.syncErrorThrown) {
  	                throw sink.syncErrorValue;
  	            }
  	        }
  	        return sink;
  	    };
  	    /**
  	     * @method forEach
  	     * @param {Function} next a handler for each value emitted by the observable
  	     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
  	     * @return {Promise} a promise that either resolves on observable completion or
  	     *  rejects with the handled error
  	     */
  	    Observable.prototype.forEach = function (next, PromiseCtor) {
  	        var _this = this;
  	        if (!PromiseCtor) {
  	            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
  	                PromiseCtor = root_1.root.Rx.config.Promise;
  	            }
  	            else if (root_1.root.Promise) {
  	                PromiseCtor = root_1.root.Promise;
  	            }
  	        }
  	        if (!PromiseCtor) {
  	            throw new Error('no Promise impl found');
  	        }
  	        return new PromiseCtor(function (resolve, reject) {
  	            var subscription = _this.subscribe(function (value) {
  	                if (subscription) {
  	                    // if there is a subscription, then we can surmise
  	                    // the next handling is asynchronous. Any errors thrown
  	                    // need to be rejected explicitly and unsubscribe must be
  	                    // called manually
  	                    try {
  	                        next(value);
  	                    }
  	                    catch (err) {
  	                        reject(err);
  	                        subscription.unsubscribe();
  	                    }
  	                }
  	                else {
  	                    // if there is NO subscription, then we're getting a nexted
  	                    // value synchronously during subscription. We can just call it.
  	                    // If it errors, Observable's `subscribe` will ensure the
  	                    // unsubscription logic is called, then synchronously rethrow the error.
  	                    // After that, Promise will trap the error and send it
  	                    // down the rejection path.
  	                    next(value);
  	                }
  	            }, reject, resolve);
  	        });
  	    };
  	    Observable.prototype._subscribe = function (subscriber) {
  	        return this.source.subscribe(subscriber);
  	    };
  	    /**
  	     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
  	     * @method Symbol.observable
  	     * @return {Observable} this instance of the observable
  	     */
  	    Observable.prototype[observable_1.$$observable] = function () {
  	        return this;
  	    };
  	    // HACK: Since TypeScript inherits static properties too, we have to
  	    // fight against TypeScript here so Subject can have a different static create signature
  	    /**
  	     * Creates a new cold Observable by calling the Observable constructor
  	     * @static true
  	     * @owner Observable
  	     * @method create
  	     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
  	     * @return {Observable} a new cold observable
  	     */
  	    Observable.create = function (subscribe) {
  	        return new Observable(subscribe);
  	    };
  	    return Observable;
  	}());
  	exports.Observable = Observable;
  	//# sourceMappingURL=Observable.js.map
  
  /***/ }