rxjs-rails 2.2.20 → 2.2.26

data/vendor/assets/javascripts/rx.js

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
 ;(function (undefined) {
 
@@ -198,7 +198,7 @@
   }
 
   function isFunction(value) {
-    return typeof value == 'function';
+    return typeof value == 'function' || false;
   }
 
   // fallback for older versions of Chrome and Safari
@@ -392,100 +392,100 @@
         return a;
     }
 
-    // Collections
-    var IndexedItem = function (id, value) {
-        this.id = id;
-        this.value = value;
-    };
-
-    IndexedItem.prototype.compareTo = function (other) {
-        var c = this.value.compareTo(other.value);
-        if (c === 0) {
-            c = this.id - other.id;
-        }
-        return c;
-    };
-
-    // Priority Queue for Scheduling
-    var PriorityQueue = Rx.internals.PriorityQueue = function (capacity) {
-        this.items = new Array(capacity);
-        this.length = 0;
-    };
-
-    var priorityProto = PriorityQueue.prototype;
-    priorityProto.isHigherPriority = function (left, right) {
-        return this.items[left].compareTo(this.items[right]) < 0;
-    };
-
-    priorityProto.percolate = function (index) {
-        if (index >= this.length || index < 0) {
-            return;
-        }
-        var parent = index - 1 >> 1;
-        if (parent < 0 || parent === index) {
-            return;
-        }
-        if (this.isHigherPriority(index, parent)) {
-            var temp = this.items[index];
-            this.items[index] = this.items[parent];
-            this.items[parent] = temp;
-            this.percolate(parent);
-        }
-    };
-
-    priorityProto.heapify = function (index) {
-        if (index === undefined) {
-            index = 0;
-        }
-        if (index >= this.length || index < 0) {
-            return;
-        }
-        var left = 2 * index + 1,
-            right = 2 * index + 2,
-            first = index;
-        if (left < this.length && this.isHigherPriority(left, first)) {
-            first = left;
-        }
-        if (right < this.length && this.isHigherPriority(right, first)) {
-            first = right;
-        }
-        if (first !== index) {
-            var temp = this.items[index];
-            this.items[index] = this.items[first];
-            this.items[first] = temp;
-            this.heapify(first);
-        }
-    };
-    
-    priorityProto.peek = function () {  return this.items[0].value; };
-
-    priorityProto.removeAt = function (index) {
-        this.items[index] = this.items[--this.length];
-        delete this.items[this.length];
-        this.heapify();
-    };
-
-    priorityProto.dequeue = function () {
-        var result = this.peek();
-        this.removeAt(0);
-        return result;
-    };
-
-    priorityProto.enqueue = function (item) {
-        var index = this.length++;
-        this.items[index] = new IndexedItem(PriorityQueue.count++, item);
-        this.percolate(index);
-    };
-
-    priorityProto.remove = function (item) {
-        for (var i = 0; i < this.length; i++) {
-            if (this.items[i].value === item) {
-                this.removeAt(i);
-                return true;
-            }
-        }
-        return false;
-    };
+    // Collections
+    var IndexedItem = function (id, value) {
+        this.id = id;
+        this.value = value;
+    };
+
+    IndexedItem.prototype.compareTo = function (other) {
+        var c = this.value.compareTo(other.value);
+        if (c === 0) {
+            c = this.id - other.id;
+        }
+        return c;
+    };
+
+    // Priority Queue for Scheduling
+    var PriorityQueue = Rx.internals.PriorityQueue = function (capacity) {
+        this.items = new Array(capacity);
+        this.length = 0;
+    };
+
+    var priorityProto = PriorityQueue.prototype;
+    priorityProto.isHigherPriority = function (left, right) {
+        return this.items[left].compareTo(this.items[right]) < 0;
+    };
+
+    priorityProto.percolate = function (index) {
+        if (index >= this.length || index < 0) {
+            return;
+        }
+        var parent = index - 1 >> 1;
+        if (parent < 0 || parent === index) {
+            return;
+        }
+        if (this.isHigherPriority(index, parent)) {
+            var temp = this.items[index];
+            this.items[index] = this.items[parent];
+            this.items[parent] = temp;
+            this.percolate(parent);
+        }
+    };
+
+    priorityProto.heapify = function (index) {
+        if (index === undefined) {
+            index = 0;
+        }
+        if (index >= this.length || index < 0) {
+            return;
+        }
+        var left = 2 * index + 1,
+            right = 2 * index + 2,
+            first = index;
+        if (left < this.length && this.isHigherPriority(left, first)) {
+            first = left;
+        }
+        if (right < this.length && this.isHigherPriority(right, first)) {
+            first = right;
+        }
+        if (first !== index) {
+            var temp = this.items[index];
+            this.items[index] = this.items[first];
+            this.items[first] = temp;
+            this.heapify(first);
+        }
+    };
+    
+    priorityProto.peek = function () {  return this.items[0].value; };
+
+    priorityProto.removeAt = function (index) {
+        this.items[index] = this.items[--this.length];
+        delete this.items[this.length];
+        this.heapify();
+    };
+
+    priorityProto.dequeue = function () {
+        var result = this.peek();
+        this.removeAt(0);
+        return result;
+    };
+
+    priorityProto.enqueue = function (item) {
+        var index = this.length++;
+        this.items[index] = new IndexedItem(PriorityQueue.count++, item);
+        this.percolate(index);
+    };
+
+    priorityProto.remove = function (item) {
+        for (var i = 0; i < this.length; i++) {
+            if (this.items[i].value === item) {
+                this.removeAt(i);
+                return true;
+            }
+        }
+        return false;
+    };
     PriorityQueue.count = 0;
     /**
      * Represents a group of disposable resources that are disposed together.
@@ -754,46 +754,46 @@
         return RefCountDisposable;
     })();
 
-    function ScheduledDisposable(scheduler, disposable) {
-        this.scheduler = scheduler;
-        this.disposable = disposable;
-        this.isDisposed = false;
-    }
-
-    ScheduledDisposable.prototype.dispose = function () {
-        var parent = this;
-        this.scheduler.schedule(function () {
-            if (!parent.isDisposed) {
-                parent.isDisposed = true;
-                parent.disposable.dispose();
-            }
-        });
-    };
-
-    var ScheduledItem = Rx.internals.ScheduledItem = function (scheduler, state, action, dueTime, comparer) {
-        this.scheduler = scheduler;
-        this.state = state;
-        this.action = action;
-        this.dueTime = dueTime;
-        this.comparer = comparer || defaultSubComparer;
-        this.disposable = new SingleAssignmentDisposable();
-    }
-
-    ScheduledItem.prototype.invoke = function () {
-        this.disposable.setDisposable(this.invokeCore());
-    };
-
-    ScheduledItem.prototype.compareTo = function (other) {
-        return this.comparer(this.dueTime, other.dueTime);
-    };
-
-    ScheduledItem.prototype.isCancelled = function () {
-        return this.disposable.isDisposed;
-    };
-
-    ScheduledItem.prototype.invokeCore = function () {
-        return this.action(this.scheduler, this.state);
-    };
+    function ScheduledDisposable(scheduler, disposable) {
+        this.scheduler = scheduler;
+        this.disposable = disposable;
+        this.isDisposed = false;
+    }
+
+    ScheduledDisposable.prototype.dispose = function () {
+        var parent = this;
+        this.scheduler.schedule(function () {
+            if (!parent.isDisposed) {
+                parent.isDisposed = true;
+                parent.disposable.dispose();
+            }
+        });
+    };
+
+    var ScheduledItem = Rx.internals.ScheduledItem = function (scheduler, state, action, dueTime, comparer) {
+        this.scheduler = scheduler;
+        this.state = state;
+        this.action = action;
+        this.dueTime = dueTime;
+        this.comparer = comparer || defaultSubComparer;
+        this.disposable = new SingleAssignmentDisposable();
+    }
+
+    ScheduledItem.prototype.invoke = function () {
+        this.disposable.setDisposable(this.invokeCore());
+    };
+
+    ScheduledItem.prototype.compareTo = function (other) {
+        return this.comparer(this.dueTime, other.dueTime);
+    };
+
+    ScheduledItem.prototype.isCancelled = function () {
+        return this.disposable.isDisposed;
+    };
+
+    ScheduledItem.prototype.invokeCore = function () {
+        return this.action(this.scheduler, this.state);
+    };
 
     /** Provides a set of static properties to access commonly used schedulers. */
     var Scheduler = Rx.Scheduler = (function () {
@@ -1061,54 +1061,54 @@
 
     var normalizeTime = Scheduler.normalize;
     
-    var SchedulePeriodicRecursive = Rx.internals.SchedulePeriodicRecursive = (function () {
-        function tick(command, recurse) {
-            recurse(0, this._period);
-            try {
-                this._state = this._action(this._state);
-            } catch (e) {
-                this._cancel.dispose();
-                throw e;
-            }
-        }
-
-        function SchedulePeriodicRecursive(scheduler, state, period, action) {
-            this._scheduler = scheduler;
-            this._state = state;
-            this._period = period;
-            this._action = action;
-        }
-
-        SchedulePeriodicRecursive.prototype.start = function () {
-            var d = new SingleAssignmentDisposable();
-            this._cancel = d;
-            d.setDisposable(this._scheduler.scheduleRecursiveWithRelativeAndState(0, this._period, tick.bind(this)));
-
-            return d;
-        };
-
-        return SchedulePeriodicRecursive;
-    }());
-
-  /**
-   * Gets a scheduler that schedules work immediately on the current thread.
-   */    
-  var immediateScheduler = Scheduler.immediate = (function () {
-
-    function scheduleNow(state, action) { return action(this, state); }
-
-    function scheduleRelative(state, dueTime, action) {
-      var dt = normalizeTime(dt);
-      while (dt - this.now() > 0) { }
-      return action(this, state);
-    }
-
-    function scheduleAbsolute(state, dueTime, action) {
-      return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
-    }
-
-    return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
-  }());
+    var SchedulePeriodicRecursive = Rx.internals.SchedulePeriodicRecursive = (function () {
+        function tick(command, recurse) {
+            recurse(0, this._period);
+            try {
+                this._state = this._action(this._state);
+            } catch (e) {
+                this._cancel.dispose();
+                throw e;
+            }
+        }
+
+        function SchedulePeriodicRecursive(scheduler, state, period, action) {
+            this._scheduler = scheduler;
+            this._state = state;
+            this._period = period;
+            this._action = action;
+        }
+
+        SchedulePeriodicRecursive.prototype.start = function () {
+            var d = new SingleAssignmentDisposable();
+            this._cancel = d;
+            d.setDisposable(this._scheduler.scheduleRecursiveWithRelativeAndState(0, this._period, tick.bind(this)));
+
+            return d;
+        };
+
+        return SchedulePeriodicRecursive;
+    }());
+
+  /**
+   * Gets a scheduler that schedules work immediately on the current thread.
+   */    
+  var immediateScheduler = Scheduler.immediate = (function () {
+
+    function scheduleNow(state, action) { return action(this, state); }
+
+    function scheduleRelative(state, dueTime, action) {
+      var dt = normalizeTime(dt);
+      while (dt - this.now() > 0) { }
+      return action(this, state);
+    }
+
+    function scheduleAbsolute(state, dueTime, action) {
+      return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+    }
+
+    return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+  }());
 
     /** 
      * Gets a scheduler that schedules work as soon as possible on the current thread.
@@ -1527,231 +1527,230 @@
         };
     }());
 
-  var Enumerator = Rx.internals.Enumerator = function (next) {
-    this._next = next;
-  };
-
-  Enumerator.prototype.next = function () {
-    return this._next();
-  };
-
-  Enumerator.prototype[$iterator$] = function () { return this; }
-
-  var Enumerable = Rx.internals.Enumerable = function (iterator) {
-      this._iterator = iterator;
-  };
-
-  Enumerable.prototype[$iterator$] = function () {
-      return this._iterator();
-  };
-
-  Enumerable.prototype.concat = function () {
-      var sources = this;
-      return new AnonymousObservable(function (observer) {
-        var e;
-        try {
-          e = sources[$iterator$]();
-        } catch(err) {
-          observer.onError();
-          return;
-        }
-
-        var isDisposed, 
-          subscription = new SerialDisposable();
-        var cancelable = immediateScheduler.scheduleRecursive(function (self) {
-          var currentItem;
-          if (isDisposed) { return; }
-
-          try {
-            currentItem = e.next();
-          } catch (ex) {
-            observer.onError(ex);
-            return;
-          }
-
-          if (currentItem.done) {
-            observer.onCompleted();
-            return;
-          }
-
-          // Check if promise
-          var currentValue = currentItem.value;
-          isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
-
-          var d = new SingleAssignmentDisposable();
-          subscription.setDisposable(d);
-          d.setDisposable(currentValue.subscribe(
-            observer.onNext.bind(observer),
-            observer.onError.bind(observer),
-            function () { self(); })
-          );
-        });
-
-        return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
-          isDisposed = true;
-        }));
-      });
-  };
-
-  Enumerable.prototype.catchException = function () {
-    var sources = this;
-    return new AnonymousObservable(function (observer) {
-      var e;
-      try {
-        e = sources[$iterator$]();
-      } catch(err) {
-        observer.onError();
-        return;
-      }
-
-      var isDisposed, 
-        lastException,
-        subscription = new SerialDisposable();
-      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
-        if (isDisposed) { return; }
-
-        var currentItem;
-        try {
-          currentItem = e.next();
-        } catch (ex) {
-          observer.onError(ex);
-          return;
-        }
-
-        if (currentItem.done) {
-          if (lastException) {
-            observer.onError(lastException);
-          } else {
-            observer.onCompleted();
-          }
-          return;
-        }
-
-        // Check if promise
-        var currentValue = currentItem.value;
-        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));        
-
-        var d = new SingleAssignmentDisposable();
-        subscription.setDisposable(d);
-        d.setDisposable(currentValue.subscribe(
-          observer.onNext.bind(observer),
-          function (exn) {
-            lastException = exn;
-            self();
-          },
-          observer.onCompleted.bind(observer)));
-      });
-      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
-        isDisposed = true;
-      }));
-    });
-  };
-
-
-  var enumerableRepeat = Enumerable.repeat = function (value, repeatCount) {
-    if (repeatCount == null) { repeatCount = -1; }
-    return new Enumerable(function () {
-      var left = repeatCount;
-      return new Enumerator(function () {
-        if (left === 0) { return doneEnumerator; }
-        if (left > 0) { left--; }
-        return { done: false, value: value };
-      });
-    });
-  };
-
-  var enumerableFor = Enumerable.forEach = function (source, selector, thisArg) {
-    selector || (selector = identity);
-    return new Enumerable(function () {
-      var index = -1;
-      return new Enumerator(
-        function () {
-          return ++index < source.length ?
-            { done: false, value: selector.call(thisArg, source[index], index, source) } :
-            doneEnumerator;
-        });
-    });
-  };
+  var Enumerator = Rx.internals.Enumerator = function (next) {
+    this._next = next;
+  };
 
-    /**
-     * Supports push-style iteration over an observable sequence.
-     */
-    var Observer = Rx.Observer = function () { };
+  Enumerator.prototype.next = function () {
+    return this._next();
+  };
 
-    /**
-     *  Creates a notification callback from an observer.
-     *  
-     * @param observer Observer object.
-     * @returns The action that forwards its input notification to the underlying observer.
-     */
-    Observer.prototype.toNotifier = function () {
-        var observer = this;
-        return function (n) {
-            return n.accept(observer);
-        };
-    };
+  Enumerator.prototype[$iterator$] = function () { return this; }
 
-    /**
-     *  Hides the identity of an observer.
+  var Enumerable = Rx.internals.Enumerable = function (iterator) {
+    this._iterator = iterator;
+  };
 
-     * @returns An observer that hides the identity of the specified observer. 
-     */   
-    Observer.prototype.asObserver = function () {
-        return new AnonymousObserver(this.onNext.bind(this), this.onError.bind(this), this.onCompleted.bind(this));
-    };
+  Enumerable.prototype[$iterator$] = function () {
+    return this._iterator();
+  };
 
-    /**
-     *  Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods.
-     *  If a violation is detected, an Error is thrown from the offending observer method call.
-     *  
-     * @returns An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer.
-     */    
-    Observer.prototype.checked = function () { return new CheckedObserver(this); };
+  Enumerable.prototype.concat = function () {
+    var sources = this;
+    return new AnonymousObservable(function (observer) {
+      var e;
+      try {
+        e = sources[$iterator$]();
+      } catch(err) {
+        observer.onError();
+        return;
+      }
 
-    /**
-     *  Creates an observer from the specified OnNext, along with optional OnError, and OnCompleted actions.
-     *  
-     * @static
-     * @memberOf Observer
-     * @param {Function} [onNext] Observer's OnNext action implementation.
-     * @param {Function} [onError] Observer's OnError action implementation.
-     * @param {Function} [onCompleted] Observer's OnCompleted action implementation.
-     * @returns {Observer} The observer object implemented using the given actions.
-     */
-    var observerCreate = Observer.create = function (onNext, onError, onCompleted) {
-        onNext || (onNext = noop);
-        onError || (onError = defaultError);
-        onCompleted || (onCompleted = noop);
-        return new AnonymousObserver(onNext, onError, onCompleted);
-    };
+      var isDisposed, 
+        subscription = new SerialDisposable();
+      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
+        var currentItem;
+        if (isDisposed) { return; }
 
-    /**
-     *  Creates an observer from a notification callback.
-     *  
-     * @static
-     * @memberOf Observer
-     * @param {Function} handler Action that handles a notification.
-     * @returns The observer object that invokes the specified handler using a notification corresponding to each message it receives.
-     */
-    Observer.fromNotifier = function (handler) {
-        return new AnonymousObserver(function (x) {
-            return handler(notificationCreateOnNext(x));
-        }, function (exception) {
-            return handler(notificationCreateOnError(exception));
-        }, function () {
-            return handler(notificationCreateOnCompleted());
+        try {
+          currentItem = e.next();
+        } catch (ex) {
+          observer.onError(ex);
+          return;
+        }
+
+        if (currentItem.done) {
+          observer.onCompleted();
+          return;
+        }
+
+        // Check if promise
+        var currentValue = currentItem.value;
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
+
+        var d = new SingleAssignmentDisposable();
+        subscription.setDisposable(d);
+        d.setDisposable(currentValue.subscribe(
+          observer.onNext.bind(observer),
+          observer.onError.bind(observer),
+          function () { self(); })
+        );
+      });
+
+      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    });
+  };
+
+  Enumerable.prototype.catchException = function () {
+    var sources = this;
+    return new AnonymousObservable(function (observer) {
+      var e;
+      try {
+        e = sources[$iterator$]();
+      } catch(err) {
+        observer.onError();
+        return;
+      }
+
+      var isDisposed, 
+        lastException,
+        subscription = new SerialDisposable();
+      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
+        if (isDisposed) { return; }
+
+        var currentItem;
+        try {
+          currentItem = e.next();
+        } catch (ex) {
+          observer.onError(ex);
+          return;
+        }
+
+        if (currentItem.done) {
+          if (lastException) {
+            observer.onError(lastException);
+          } else {
+            observer.onCompleted();
+          }
+          return;
+        }
+
+        // Check if promise
+        var currentValue = currentItem.value;
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));        
+
+        var d = new SingleAssignmentDisposable();
+        subscription.setDisposable(d);
+        d.setDisposable(currentValue.subscribe(
+          observer.onNext.bind(observer),
+          function (exn) {
+            lastException = exn;
+            self();
+          },
+          observer.onCompleted.bind(observer)));
+      });
+      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    });
+  };
+
+  var enumerableRepeat = Enumerable.repeat = function (value, repeatCount) {
+    if (repeatCount == null) { repeatCount = -1; }
+    return new Enumerable(function () {
+      var left = repeatCount;
+      return new Enumerator(function () {
+        if (left === 0) { return doneEnumerator; }
+        if (left > 0) { left--; }
+        return { done: false, value: value };
+      });
+    });
+  };
+
+  var enumerableFor = Enumerable.forEach = function (source, selector, thisArg) {
+    selector || (selector = identity);
+    return new Enumerable(function () {
+      var index = -1;
+      return new Enumerator(
+        function () {
+          return ++index < source.length ?
+            { done: false, value: selector.call(thisArg, source[index], index, source) } :
+            doneEnumerator;
         });
-    };
+    });
+  };
 
-    /**
-     * Schedules the invocation of observer methods on the given scheduler.
-     * @param {Scheduler} scheduler Scheduler to schedule observer messages on.
-     * @returns {Observer} Observer whose messages are scheduled on the given scheduler.
-     */
-    Observer.notifyOn = function (scheduler) {
-        return new ObserveOnObserver(scheduler, this);
+  /**
+   * Supports push-style iteration over an observable sequence.
+   */
+  var Observer = Rx.Observer = function () { };
+
+  /**
+   *  Creates a notification callback from an observer.
+   *  
+   * @param observer Observer object.
+   * @returns The action that forwards its input notification to the underlying observer.
+   */
+  Observer.prototype.toNotifier = function () {
+    var observer = this;
+    return function (n) {
+      return n.accept(observer);
     };
-    
+  };
+
+  /**
+   *  Hides the identity of an observer.
+
+   * @returns An observer that hides the identity of the specified observer. 
+   */   
+  Observer.prototype.asObserver = function () {
+    return new AnonymousObserver(this.onNext.bind(this), this.onError.bind(this), this.onCompleted.bind(this));
+  };
+
+  /**
+   *  Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods.
+   *  If a violation is detected, an Error is thrown from the offending observer method call.
+   *  
+   * @returns An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer.
+   */    
+  Observer.prototype.checked = function () { return new CheckedObserver(this); };
+
+  /**
+   *  Creates an observer from the specified OnNext, along with optional OnError, and OnCompleted actions.
+   *  
+   * @static
+   * @memberOf Observer
+   * @param {Function} [onNext] Observer's OnNext action implementation.
+   * @param {Function} [onError] Observer's OnError action implementation.
+   * @param {Function} [onCompleted] Observer's OnCompleted action implementation.
+   * @returns {Observer} The observer object implemented using the given actions.
+   */
+  var observerCreate = Observer.create = function (onNext, onError, onCompleted) {
+    onNext || (onNext = noop);
+    onError || (onError = defaultError);
+    onCompleted || (onCompleted = noop);
+    return new AnonymousObserver(onNext, onError, onCompleted);
+  };
+
+  /**
+   *  Creates an observer from a notification callback.
+   *  
+   * @static
+   * @memberOf Observer
+   * @param {Function} handler Action that handles a notification.
+   * @returns The observer object that invokes the specified handler using a notification corresponding to each message it receives.
+   */
+  Observer.fromNotifier = function (handler) {
+    return new AnonymousObserver(function (x) {
+      return handler(notificationCreateOnNext(x));
+    }, function (exception) {
+      return handler(notificationCreateOnError(exception));
+    }, function () {
+      return handler(notificationCreateOnCompleted());
+    });
+  };
+
+  /**
+   * Schedules the invocation of observer methods on the given scheduler.
+   * @param {Scheduler} scheduler Scheduler to schedule observer messages on.
+   * @returns {Observer} Observer whose messages are scheduled on the given scheduler.
+   */
+  Observer.notifyOn = function (scheduler) {
+    return new ObserveOnObserver(scheduler, this);
+  };
+  
     /**
      * Abstract base class for implementations of the Observer class.
      * This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. 
@@ -2021,83 +2020,43 @@
         return ObserveOnObserver;
     })(ScheduledObserver);
 
-    var observableProto;
-
-    /**
-     * Represents a push-style collection.
-     */
-    var Observable = Rx.Observable = (function () {
-
-        /**
-         * @constructor
-         * @private
-         */
-        function Observable(subscribe) {
-            this._subscribe = subscribe;
-        }
+  var observableProto;
 
-        observableProto = Observable.prototype;
+  /**
+   * Represents a push-style collection.
+   */
+  var Observable = Rx.Observable = (function () {
 
-        observableProto.finalValue = function () {
-            var source = this;
-            return new AnonymousObservable(function (observer) {
-                var hasValue = false, value;
-                return source.subscribe(function (x) {
-                    hasValue = true;
-                    value = x;
-                }, observer.onError.bind(observer), function () {
-                    if (!hasValue) {
-                        observer.onError(new Error(sequenceContainsNoElements));
-                    } else {
-                        observer.onNext(value);
-                        observer.onCompleted();
-                    }
-                });
-            });
-        };
+    function Observable(subscribe) {
+      this._subscribe = subscribe;
+    }
 
-        /**
-         *  Subscribes an observer to the observable sequence.
-         *  
-         * @example
-         *  1 - source.subscribe();
-         *  2 - source.subscribe(observer);
-         *  3 - source.subscribe(function (x) { console.log(x); });
-         *  4 - source.subscribe(function (x) { console.log(x); }, function (err) { console.log(err); });
-         *  5 - source.subscribe(function (x) { console.log(x); }, function (err) { console.log(err); }, function () { console.log('done'); });
-         *  @param {Mixed} [observerOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
-         *  @param {Function} [onError] Action to invoke upon exceptional termination of the observable sequence.
-         *  @param {Function} [onCompleted] Action to invoke upon graceful termination of the observable sequence.
-         *  @returns {Diposable} The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. 
-         */
-        observableProto.subscribe = observableProto.forEach = function (observerOrOnNext, onError, onCompleted) {
-            var subscriber;
-            if (typeof observerOrOnNext === 'object') {
-                subscriber = observerOrOnNext;
-            } else {
-                subscriber = observerCreate(observerOrOnNext, onError, onCompleted);
-            }
+    observableProto = Observable.prototype;
 
-            return this._subscribe(subscriber);
-        };
+    /**
+     *  Subscribes an observer to the observable sequence.
+     *  
+     * @example
+     *  1 - source.subscribe();
+     *  2 - source.subscribe(observer);
+     *  3 - source.subscribe(function (x) { console.log(x); });
+     *  4 - source.subscribe(function (x) { console.log(x); }, function (err) { console.log(err); });
+     *  5 - source.subscribe(function (x) { console.log(x); }, function (err) { console.log(err); }, function () { console.log('done'); });
+     *  @param {Mixed} [observerOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
+     *  @param {Function} [onError] Action to invoke upon exceptional termination of the observable sequence.
+     *  @param {Function} [onCompleted] Action to invoke upon graceful termination of the observable sequence.
+     *  @returns {Diposable} The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. 
+     */
+    observableProto.subscribe = observableProto.forEach = function (observerOrOnNext, onError, onCompleted) {
+      var subscriber = typeof observerOrOnNext === 'object' ?
+        observerOrOnNext :
+        observerCreate(observerOrOnNext, onError, onCompleted);
 
-        /**
-         *  Creates a list from an observable sequence.
-         *  
-         * @memberOf Observable
-         * @returns An observable sequence containing a single element with a list containing all the elements of the source sequence.  
-         */
-        observableProto.toArray = function () {
-            function accumulator(list, i) {
-                var newList = list.slice(0);
-                newList.push(i);
-                return newList;
-            }
-            return this.scan([], accumulator).startWith([]).finalValue();
-        };
+      return this._subscribe(subscriber);
+    };
 
-        return Observable;
-    })();
+    return Observable;
+  })();
 
      /**
      *  Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
@@ -2192,6 +2151,24 @@
             });
         });
     };
+  /**
+   * Creates a list from an observable sequence.
+   * @returns An observable sequence containing a single element with a list containing all the elements of the source sequence.  
+   */
+  observableProto.toArray = function () {
+    var self = this;
+    return new AnonymousObservable(function(observer) {
+      var arr = [];
+      return self.subscribe(
+        arr.push.bind(arr),
+        observer.onError.bind(observer),
+        function () {
+          observer.onNext(arr);
+          observer.onCompleted();
+        });
+    });
+  };
+
     /**
      *  Creates an observable sequence from a specified subscribe method implementation.
      *  
@@ -2449,30 +2426,30 @@
         });
     };
 
-    /**
-     *  Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.
-     *  
-     * @example
-     *  var res = Rx.Observable.using(function () { return new AsyncSubject(); }, function (s) { return s; });
-     * @param {Function} resourceFactory Factory function to obtain a resource object.
-     * @param {Function} observableFactory Factory function to obtain an observable sequence that depends on the obtained resource.
-     * @returns {Observable} An observable sequence whose lifetime controls the lifetime of the dependent resource object.
-     */
-    Observable.using = function (resourceFactory, observableFactory) {
-        return new AnonymousObservable(function (observer) {
-            var disposable = disposableEmpty, resource, source;
-            try {
-                resource = resourceFactory();
-                if (resource) {
-                    disposable = resource;
-                }
-                source = observableFactory(resource);
-            } catch (exception) {
-                return new CompositeDisposable(observableThrow(exception).subscribe(observer), disposable);
-            }
-            return new CompositeDisposable(source.subscribe(observer), disposable);
-        });
-    };
+  /**
+   *  Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.
+   *  
+   * @example
+   *  var res = Rx.Observable.using(function () { return new AsyncSubject(); }, function (s) { return s; });
+   * @param {Function} resourceFactory Factory function to obtain a resource object.
+   * @param {Function} observableFactory Factory function to obtain an observable sequence that depends on the obtained resource.
+   * @returns {Observable} An observable sequence whose lifetime controls the lifetime of the dependent resource object.
+   */
+  Observable.using = function (resourceFactory, observableFactory) {
+    return new AnonymousObservable(function (observer) {
+      var disposable = disposableEmpty, resource, source;
+      try {
+        resource = resourceFactory();
+        if (resource) {
+          disposable = resource;
+        }
+        source = observableFactory(resource);
+      } catch (exception) {
+        return new CompositeDisposable(observableThrow(exception).subscribe(observer), disposable);
+      }
+      return new CompositeDisposable(source.subscribe(observer), disposable);
+    });
+  };
 
   /**
    * Propagates the observable sequence or Promise that reacts first.
@@ -2895,37 +2872,35 @@
     });
   };
 
-    /**
-     * Returns the values from the source observable sequence only after the other observable sequence produces a value.
-     * @param {Observable} other The observable sequence that triggers propagation of elements of the source sequence.
-     * @returns {Observable} An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.    
-     */
-    observableProto.skipUntil = function (other) {
-        var source = this;
-        return new AnonymousObservable(function (observer) {
-            var isOpen = false;
-            var disposables = new CompositeDisposable(source.subscribe(function (left) {
-                if (isOpen) {
-                    observer.onNext(left);
-                }
-            }, observer.onError.bind(observer), function () {
-                if (isOpen) {
-                    observer.onCompleted();
-                }
-            }));
+  /**
+   * Returns the values from the source observable sequence only after the other observable sequence produces a value.
+   * @param {Observable | Promise} other The observable sequence or Promise that triggers propagation of elements of the source sequence.
+   * @returns {Observable} An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.    
+   */
+  observableProto.skipUntil = function (other) {
+    var source = this;
+    return new AnonymousObservable(function (observer) {
+      var isOpen = false;
+      var disposables = new CompositeDisposable(source.subscribe(function (left) {
+        isOpen && observer.onNext(left);
+      }, observer.onError.bind(observer), function () {
+        isOpen && observer.onCompleted();
+      }));
 
-            var rightSubscription = new SingleAssignmentDisposable();
-            disposables.add(rightSubscription);
-            rightSubscription.setDisposable(other.subscribe(function () {
-                isOpen = true;
-                rightSubscription.dispose();
-            }, observer.onError.bind(observer), function () {
-                rightSubscription.dispose();
-            }));
+      isPromise(other) && (other = observableFromPromise(other));
 
-            return disposables;
-        });
-    };
+      var rightSubscription = new SingleAssignmentDisposable();
+      disposables.add(rightSubscription);
+      rightSubscription.setDisposable(other.subscribe(function () {
+        isOpen = true;
+        rightSubscription.dispose();
+      }, observer.onError.bind(observer), function () {
+        rightSubscription.dispose();
+      }));
+
+      return disposables;
+    });
+  };
 
     /**
      * Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
@@ -2974,20 +2949,21 @@
         });
     };
 
-    /**
-     * Returns the values from the source observable sequence until the other observable sequence produces a value.
-     * @param {Observable} other Observable sequence that terminates propagation of elements of the source sequence.
-     * @returns {Observable} An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.   
-     */
-    observableProto.takeUntil = function (other) {
-        var source = this;
-        return new AnonymousObservable(function (observer) {
-            return new CompositeDisposable(
-                source.subscribe(observer),
-                other.subscribe(observer.onCompleted.bind(observer), observer.onError.bind(observer), noop)
-            );
-        });
-    };
+  /**
+   * Returns the values from the source observable sequence until the other observable sequence produces a value.
+   * @param {Observable | Promise} other Observable sequence or Promise that terminates propagation of elements of the source sequence.
+   * @returns {Observable} An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.   
+   */
+  observableProto.takeUntil = function (other) {
+    var source = this;
+    return new AnonymousObservable(function (observer) {
+      isPromise(other) && (other = observableFromPromise(other));
+      return new CompositeDisposable(
+        source.subscribe(observer),
+        other.subscribe(observer.onCompleted.bind(observer), observer.onError.bind(observer), noop)
+      );
+    });
+  };
 
   function zipArray(second, resultSelector) {
     var first = this;
@@ -3147,26 +3123,26 @@
         });
     };
 
-    /**
-     *  Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.
-     *  
-     * @example
-     *  var res = xs.bufferWithCount(10);
-     *  var res = xs.bufferWithCount(10, 1);
-     * @param {Number} count Length of each buffer.
-     * @param {Number} [skip] Number of elements to skip between creation of consecutive buffers. If not provided, defaults to the count.
-     * @returns {Observable} An observable sequence of buffers.    
-     */
-    observableProto.bufferWithCount = function (count, skip) {
-        if (arguments.length === 1) {
-            skip = count;
-        }
-        return this.windowWithCount(count, skip).selectMany(function (x) {
-            return x.toArray();
-        }).where(function (x) {
-            return x.length > 0;
-        });
-    };
+  /**
+   *  Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.
+   *  
+   * @example
+   *  var res = xs.bufferWithCount(10);
+   *  var res = xs.bufferWithCount(10, 1);
+   * @param {Number} count Length of each buffer.
+   * @param {Number} [skip] Number of elements to skip between creation of consecutive buffers. If not provided, defaults to the count.
+   * @returns {Observable} An observable sequence of buffers.    
+   */
+  observableProto.bufferWithCount = function (count, skip) {
+    if (typeof skip !== 'number') {
+      skip = count;
+    }
+    return this.windowWithCount(count, skip).selectMany(function (x) {
+      return x.toArray();
+    }).where(function (x) {
+      return x.length > 0;
+    });
+  };
 
     /**
      * Dematerializes the explicit notification values of an observable sequence as implicit notifications.
@@ -3280,29 +3256,35 @@
         });
     };
 
-    /**
-     *  Invokes a specified action after the source observable sequence terminates gracefully or exceptionally.
-     *  
-     * @example
-     *  var res = observable.finallyAction(function () { console.log('sequence ended'; });
-     * @param {Function} finallyAction Action to invoke after the source observable sequence terminates.
-     * @returns {Observable} Source sequence with the action-invoking termination behavior applied. 
-     */  
-    observableProto['finally'] = observableProto.finallyAction = function (action) {
-        var source = this;
-        return new AnonymousObservable(function (observer) {
-            var subscription = source.subscribe(observer);
-            return disposableCreate(function () {
-                try {
-                    subscription.dispose();
-                } catch (e) { 
-                    throw e;                    
-                } finally {
-                    action();
-                }
-            });
-        });
-    };
+  /**
+   *  Invokes a specified action after the source observable sequence terminates gracefully or exceptionally.
+   *  
+   * @example
+   *  var res = observable.finallyAction(function () { console.log('sequence ended'; });
+   * @param {Function} finallyAction Action to invoke after the source observable sequence terminates.
+   * @returns {Observable} Source sequence with the action-invoking termination behavior applied. 
+   */  
+  observableProto['finally'] = observableProto.finallyAction = function (action) {
+    var source = this;
+    return new AnonymousObservable(function (observer) {
+      var subscription;
+      try {
+        subscription = source.subscribe(observer);
+      } catch (e) {
+        action();
+        throw e;
+      }
+      return disposableCreate(function () {
+        try {
+          subscription.dispose();
+        } catch (e) { 
+          throw e;                    
+        } finally {
+          action();
+        }
+      });
+    });
+  };
 
     /**
      *  Ignores all elements in an observable sequence leaving only the termination messages.
@@ -3557,6 +3539,71 @@
         });
     };
 
+    function concatMap(selector) {
+      return this.map(function (x, i) {
+        var result = selector(x, i);
+        return isPromise(result) ? observableFromPromise(result) : result;
+      }).concatAll();
+    }
+
+    function concatMapObserver(onNext, onError, onCompleted) {
+      var source = this;
+      return new AnonymousObservable(function (observer) {
+        var index = 0;
+
+        return source.subscribe(
+          function (x) {
+            observer.onNext(onNext(x, index++));
+          },
+          function (err) {
+            observer.onNext(onError(err));
+            observer.completed();
+          }, 
+          function () {
+            observer.onNext(onCompleted());
+            observer.onCompleted();
+          });
+      }).concatAll();
+    }
+
+    /**
+     *  One of the Following:
+     *  Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
+     *  
+     * @example
+     *  var res = source.selectMany(function (x) { return Rx.Observable.range(0, x); });
+     *  Or:
+     *  Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.
+     *  
+     *  var res = source.selectMany(function (x) { return Rx.Observable.range(0, x); }, function (x, y) { return x + y; });
+     *  Or:
+     *  Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
+     *  
+     *  var res = source.selectMany(Rx.Observable.fromArray([1,2,3]));
+     * @param selector A transform function to apply to each element or an observable sequence to project each element from the 
+     * source sequence onto which could be either an observable or Promise.
+     * @param {Function} [resultSelector]  A transform function to apply to each element of the intermediate sequence.
+     * @returns {Observable} An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.   
+     */
+    observableProto.selectConcat = observableProto.concatMap = function (selector, resultSelector) {
+      if (resultSelector) {
+          return this.concatMap(function (x, i) {
+            var selectorResult = selector(x, i),
+              result = isPromise(selectorResult) ? observableFromPromise(selectorResult) : selectorResult;
+
+            return result.map(function (y) {
+              return resultSelector(x, y, i);
+            });
+          });
+      }
+      if (typeof selector === 'function') {
+        return concatMap.call(this, selector);
+      }
+      return concatMap.call(this, function () {
+        return selector;
+      });
+    };
+
     /**
      *  Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty.
      *  
@@ -3792,6 +3839,26 @@
       }).mergeObservable();
     }
 
+    function selectManyObserver(onNext, onError, onCompleted) {
+      var source = this;
+      return new AnonymousObservable(function (observer) {
+        var index = 0;
+
+        return source.subscribe(
+          function (x) {
+            observer.onNext(onNext(x, index++));
+          },
+          function (err) {
+            observer.onNext(onError(err));
+            observer.completed();
+          }, 
+          function () {
+            observer.onNext(onCompleted());
+            observer.onCompleted();
+          });
+      }).mergeAll();
+    }
+
     /**
      *  One of the Following:
      *  Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
@@ -3987,56 +4054,56 @@
         });
     };
 
-    var AnonymousObservable = Rx.AnonymousObservable = (function (_super) {
-        inherits(AnonymousObservable, _super);
-
-        // Fix subscriber to check for undefined or function returned to decorate as Disposable
-        function fixSubscriber(subscriber) {
-            if (typeof subscriber === 'undefined') {
-                subscriber = disposableEmpty;
-            } else if (typeof subscriber === 'function') {
-                subscriber = disposableCreate(subscriber);
-            }
+  var AnonymousObservable = Rx.AnonymousObservable = (function (__super__) {
+    inherits(AnonymousObservable, __super__);
 
-            return subscriber;
-        }
+    // Fix subscriber to check for undefined or function returned to decorate as Disposable
+    function fixSubscriber(subscriber) {
+      if (typeof subscriber === 'undefined') {
+        subscriber = disposableEmpty;
+      } else if (typeof subscriber === 'function') {
+        subscriber = disposableCreate(subscriber);
+      }
 
-        function AnonymousObservable(subscribe) {
-            if (!(this instanceof AnonymousObservable)) {
-                return new AnonymousObservable(subscribe);
-            }
+      return subscriber;
+    }
 
-            function s(observer) {
-                var autoDetachObserver = new AutoDetachObserver(observer);
-                if (currentThreadScheduler.scheduleRequired()) {
-                    currentThreadScheduler.schedule(function () {
-                        try {
-                            autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
-                        } catch (e) {
-                            if (!autoDetachObserver.fail(e)) {
-                                throw e;
-                            } 
-                        }
-                    });
-                } else {
-                    try {
-                        autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
-                    } catch (e) {
-                        if (!autoDetachObserver.fail(e)) {
-                            throw e;
-                        }
-                    }
-                }
+    function AnonymousObservable(subscribe) {
+      if (!(this instanceof AnonymousObservable)) {
+        return new AnonymousObservable(subscribe);
+      }
 
-                return autoDetachObserver;
+      function s(observer) {
+        var autoDetachObserver = new AutoDetachObserver(observer);
+        if (currentThreadScheduler.scheduleRequired()) {
+          currentThreadScheduler.schedule(function () {
+            try {
+              autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
+            } catch (e) {
+              if (!autoDetachObserver.fail(e)) {
+                throw e;
+              } 
             }
-
-            _super.call(this, s);
+          });
+        } else {
+          try {
+            autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
+          } catch (e) {
+            if (!autoDetachObserver.fail(e)) {
+              throw e;
+            }
+          }
         }
 
-        return AnonymousObservable;
+        return autoDetachObserver;
+      }
 
-    }(Observable));
+      __super__.call(this, s);
+    }
+
+    return AnonymousObservable;
+
+  }(Observable));
 
     /** @private */
     var AutoDetachObserver = (function (_super) {
@@ -4099,48 +4166,48 @@
         return AutoDetachObserver;
     }(AbstractObserver));
 
-    /** @private */
-    var GroupedObservable = (function (_super) {
-        inherits(GroupedObservable, _super);
-
-        function subscribe(observer) {
-            return this.underlyingObservable.subscribe(observer);
-        }
-
-        /** 
-         * @constructor
-         * @private
-         */
-        function GroupedObservable(key, underlyingObservable, mergedDisposable) {
-            _super.call(this, subscribe);
-            this.key = key;
-            this.underlyingObservable = !mergedDisposable ?
-                underlyingObservable :
-                new AnonymousObservable(function (observer) {
-                    return new CompositeDisposable(mergedDisposable.getDisposable(), underlyingObservable.subscribe(observer));
-                });
-        }
-
-        return GroupedObservable;
-    }(Observable));
-
-    /** @private */
-    var InnerSubscription = function (subject, observer) {
-        this.subject = subject;
-        this.observer = observer;
-    };
-
-    /**
-     * @private
-     * @memberOf InnerSubscription
-     */
-    InnerSubscription.prototype.dispose = function () {
-        if (!this.subject.isDisposed && this.observer !== null) {
-            var idx = this.subject.observers.indexOf(this.observer);
-            this.subject.observers.splice(idx, 1);
-            this.observer = null;
-        }
-    };
+    /** @private */
+    var GroupedObservable = (function (_super) {
+        inherits(GroupedObservable, _super);
+
+        function subscribe(observer) {
+            return this.underlyingObservable.subscribe(observer);
+        }
+
+        /** 
+         * @constructor
+         * @private
+         */
+        function GroupedObservable(key, underlyingObservable, mergedDisposable) {
+            _super.call(this, subscribe);
+            this.key = key;
+            this.underlyingObservable = !mergedDisposable ?
+                underlyingObservable :
+                new AnonymousObservable(function (observer) {
+                    return new CompositeDisposable(mergedDisposable.getDisposable(), underlyingObservable.subscribe(observer));
+                });
+        }
+
+        return GroupedObservable;
+    }(Observable));
+
+    /** @private */
+    var InnerSubscription = function (subject, observer) {
+        this.subject = subject;
+        this.observer = observer;
+    };
+
+    /**
+     * @private
+     * @memberOf InnerSubscription
+     */
+    InnerSubscription.prototype.dispose = function () {
+        if (!this.subject.isDisposed && this.observer !== null) {
+            var idx = this.subject.observers.indexOf(this.observer);
+            this.subject.observers.splice(idx, 1);
+            this.observer = null;
+        }
+    };
 
     /**
      *  Represents an object that is both an observable sequence as well as an observer.
@@ -4375,66 +4442,66 @@
         return AsyncSubject;
     }(Observable));
 
-    /** @private */
-    var AnonymousSubject = (function (_super) {
-        inherits(AnonymousSubject, _super);
-
-        function subscribe(observer) {
-            return this.observable.subscribe(observer);
-        }
-
-        /**
-         * @private
-         * @constructor
-         */
-        function AnonymousSubject(observer, observable) {
-            _super.call(this, subscribe);
-            this.observer = observer;
-            this.observable = observable;
-        }
-
-        addProperties(AnonymousSubject.prototype, Observer, {
-            /**
-             * @private
-             * @memberOf AnonymousSubject#
-            */
-            onCompleted: function () {
-                this.observer.onCompleted();
-            },
-            /**
-             * @private
-             * @memberOf AnonymousSubject#
-            */            
-            onError: function (exception) {
-                this.observer.onError(exception);
-            },
-            /**
-             * @private
-             * @memberOf AnonymousSubject#
-            */            
-            onNext: function (value) {
-                this.observer.onNext(value);
-            }
-        });
-
-        return AnonymousSubject;
-    }(Observable));
-
-    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
-        root.Rx = Rx;
-
-        define(function() {
-            return Rx;
-        });
-    } else if (freeExports && freeModule) {
-        // in Node.js or RingoJS
-        if (moduleExports) {
-            (freeModule.exports = Rx).Rx = Rx;
-        } else {
-          freeExports.Rx = Rx;
-        }
-    } else {
-        // in a browser or Rhino
-        root.Rx = Rx;
+    /** @private */
+    var AnonymousSubject = (function (_super) {
+        inherits(AnonymousSubject, _super);
+
+        function subscribe(observer) {
+            return this.observable.subscribe(observer);
+        }
+
+        /**
+         * @private
+         * @constructor
+         */
+        function AnonymousSubject(observer, observable) {
+            _super.call(this, subscribe);
+            this.observer = observer;
+            this.observable = observable;
+        }
+
+        addProperties(AnonymousSubject.prototype, Observer, {
+            /**
+             * @private
+             * @memberOf AnonymousSubject#
+            */
+            onCompleted: function () {
+                this.observer.onCompleted();
+            },
+            /**
+             * @private
+             * @memberOf AnonymousSubject#
+            */            
+            onError: function (exception) {
+                this.observer.onError(exception);
+            },
+            /**
+             * @private
+             * @memberOf AnonymousSubject#
+            */            
+            onNext: function (value) {
+                this.observer.onNext(value);
+            }
+        });
+
+        return AnonymousSubject;
+    }(Observable));
+
+    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+        root.Rx = Rx;
+
+        define(function() {
+            return Rx;
+        });
+    } else if (freeExports && freeModule) {
+        // in Node.js or RingoJS
+        if (moduleExports) {
+            (freeModule.exports = Rx).Rx = Rx;
+        } else {
+          freeExports.Rx = Rx;
+        }
+    } else {
+        // in a browser or Rhino
+        root.Rx = Rx;
     }
 }.call(this));