rxjs-rails 2.2.20 → 2.2.26

data/vendor/assets/javascripts/rx.core.js

@@ -0,0 +1,2511 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (undefined) {
+
+  var objectTypes = {
+    'boolean': false,
+    'function': true,
+    'object': true,
+    'number': false,
+    'string': false,
+    'undefined': false
+  };
+
+  var root = (objectTypes[typeof window] && window) || this,
+    freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports,
+    freeModule = objectTypes[typeof module] && module && !module.nodeType && module,
+    moduleExports = freeModule && freeModule.exports === freeExports && freeExports,
+    freeGlobal = objectTypes[typeof global] && global;
+  
+  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+    root = freeGlobal;
+  }
+
+  var Rx = { 
+      internals: {}, 
+      config: {
+        Promise: root.Promise // Detect if promise exists
+      },
+      helpers: { }
+  };
+    
+  // Defaults
+  var noop = Rx.helpers.noop = function () { },
+    identity = Rx.helpers.identity = function (x) { return x; },
+    defaultNow = Rx.helpers.defaultNow = Date.now,
+    defaultComparer = Rx.helpers.defaultComparer = function (x, y) { return isEqual(x, y); },
+    defaultSubComparer = Rx.helpers.defaultSubComparer = function (x, y) { return x > y ? 1 : (x < y ? -1 : 0); },
+    defaultKeySerializer = Rx.helpers.defaultKeySerializer = function (x) { return x.toString(); },
+    defaultError = Rx.helpers.defaultError = function (err) { throw err; },
+    isPromise = Rx.helpers.isPromise = function (p) { return !!p && typeof p.then === 'function' && p.then !== Rx.Observable.prototype.then; },
+    asArray = Rx.helpers.asArray = function () { return Array.prototype.slice.call(arguments); },
+    not = Rx.helpers.not = function (a) { return !a; };
+
+  // Errors
+  var sequenceContainsNoElements = 'Sequence contains no elements.';
+  var argumentOutOfRange = 'Argument out of range';
+  var objectDisposed = 'Object has been disposed';
+  function checkDisposed() { if (this.isDisposed) { throw new Error(objectDisposed); } }  
+  
+  // Shim in iterator support
+  var $iterator$ = (typeof Symbol === 'object' && Symbol.iterator) ||
+    '_es6shim_iterator_';
+  // Firefox ships a partial implementation using the name @@iterator.
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14
+  // So use that name if we detect it.
+  if (root.Set && typeof new root.Set()['@@iterator'] === 'function') {
+    $iterator$ = '@@iterator';
+  }
+  var doneEnumerator = { done: true, value: undefined };
+
+  /** `Object#toString` result shortcuts */
+  var argsClass = '[object Arguments]',
+    arrayClass = '[object Array]',
+    boolClass = '[object Boolean]',
+    dateClass = '[object Date]',
+    errorClass = '[object Error]',
+    funcClass = '[object Function]',
+    numberClass = '[object Number]',
+    objectClass = '[object Object]',
+    regexpClass = '[object RegExp]',
+    stringClass = '[object String]';
+
+  var toString = Object.prototype.toString,
+    hasOwnProperty = Object.prototype.hasOwnProperty,  
+    supportsArgsClass = toString.call(arguments) == argsClass, // For less <IE9 && FF<4
+    suportNodeClass,
+    errorProto = Error.prototype,
+    objectProto = Object.prototype,
+    propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+  try {
+      suportNodeClass = !(toString.call(document) == objectClass && !({ 'toString': 0 } + ''));
+  } catch(e) {
+      suportNodeClass = true;
+  }
+
+  var shadowedProps = [
+    'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'
+  ];
+
+  var nonEnumProps = {};
+  nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };
+  nonEnumProps[boolClass] = nonEnumProps[stringClass] = { 'constructor': true, 'toString': true, 'valueOf': true };
+  nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { 'constructor': true, 'toString': true };
+  nonEnumProps[objectClass] = { 'constructor': true };
+
+  var support = {};
+  (function () {
+    var ctor = function() { this.x = 1; },
+      props = [];
+
+    ctor.prototype = { 'valueOf': 1, 'y': 1 };
+    for (var key in new ctor) { props.push(key); }      
+    for (key in arguments) { }
+
+    // Detect if `name` or `message` properties of `Error.prototype` are enumerable by default.
+    support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name');
+
+    // Detect if `prototype` properties are enumerable by default.
+    support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype');
+
+    // Detect if `arguments` object indexes are non-enumerable
+    support.nonEnumArgs = key != 0;
+
+    // Detect if properties shadowing those on `Object.prototype` are non-enumerable.
+    support.nonEnumShadows = !/valueOf/.test(props);
+  }(1));
+
+  function isObject(value) {
+    // check if the value is the ECMAScript language type of Object
+    // http://es5.github.io/#x8
+    // and avoid a V8 bug
+    // https://code.google.com/p/v8/issues/detail?id=2291
+    var type = typeof value;
+    return value && (type == 'function' || type == 'object') || false;
+  }
+
+  function keysIn(object) {
+    var result = [];
+    if (!isObject(object)) {
+      return result;
+    }
+    if (support.nonEnumArgs && object.length && isArguments(object)) {
+      object = slice.call(object);
+    }
+    var skipProto = support.enumPrototypes && typeof object == 'function',
+        skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error);
+
+    for (var key in object) {
+      if (!(skipProto && key == 'prototype') &&
+          !(skipErrorProps && (key == 'message' || key == 'name'))) {
+        result.push(key);
+      }
+    }
+
+    if (support.nonEnumShadows && object !== objectProto) {
+      var ctor = object.constructor,
+          index = -1,
+          length = shadowedProps.length;
+
+      if (object === (ctor && ctor.prototype)) {
+        var className = object === stringProto ? stringClass : object === errorProto ? errorClass : toString.call(object),
+            nonEnum = nonEnumProps[className];
+      }
+      while (++index < length) {
+        key = shadowedProps[index];
+        if (!(nonEnum && nonEnum[key]) && hasOwnProperty.call(object, key)) {
+          result.push(key);
+        }
+      }
+    }
+    return result;
+  }
+
+  function internalFor(object, callback, keysFunc) {
+    var index = -1,
+      props = keysFunc(object),
+      length = props.length;
+
+    while (++index < length) {
+      var key = props[index];
+      if (callback(object[key], key, object) === false) {
+        break;
+      }
+    }
+    return object;
+  }   
+
+  function internalForIn(object, callback) {
+    return internalFor(object, callback, keysIn);
+  }
+
+  function isNode(value) {
+    // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
+    // methods that are `typeof` "string" and still can coerce nodes to strings
+    return typeof value.toString != 'function' && typeof (value + '') == 'string';
+  }
+
+  function isArguments(value) {
+    return (value && typeof value == 'object') ? toString.call(value) == argsClass : false;
+  }
+
+  // fallback for browsers that can't detect `arguments` objects by [[Class]]
+  if (!supportsArgsClass) {
+    isArguments = function(value) {
+      return (value && typeof value == 'object') ? hasOwnProperty.call(value, 'callee') : false;
+    };
+  }
+
+  function isFunction(value) {
+    return typeof value == 'function' || false;
+  }
+
+  // fallback for older versions of Chrome and Safari
+  if (isFunction(/x/)) {
+    isFunction = function(value) {
+      return typeof value == 'function' && toString.call(value) == funcClass;
+    };
+  }        
+
+  var isEqual = Rx.internals.isEqual = function (x, y) {
+    return deepEquals(x, y, [], []); 
+  };
+
+  /** @private
+   * Used for deep comparison
+   **/
+  function deepEquals(a, b, stackA, stackB) {
+    // exit early for identical values
+    if (a === b) {
+      // treat `+0` vs. `-0` as not equal
+      return a !== 0 || (1 / a == 1 / b);
+    }
+
+    var type = typeof a,
+        otherType = typeof b;
+
+    // exit early for unlike primitive values
+    if (a === a && (a == null || b == null ||
+        (type != 'function' && type != 'object' && otherType != 'function' && otherType != 'object'))) {
+      return false;
+    }
+
+    // compare [[Class]] names
+    var className = toString.call(a),
+        otherClass = toString.call(b);
+
+    if (className == argsClass) {
+      className = objectClass;
+    }
+    if (otherClass == argsClass) {
+      otherClass = objectClass;
+    }
+    if (className != otherClass) {
+      return false;
+    }
+    switch (className) {
+      case boolClass:
+      case dateClass:
+        // coerce dates and booleans to numbers, dates to milliseconds and booleans
+        // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+        return +a == +b;
+
+      case numberClass:
+        // treat `NaN` vs. `NaN` as equal
+        return (a != +a)
+          ? b != +b
+          // but treat `-0` vs. `+0` as not equal
+          : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+      case regexpClass:
+      case stringClass:
+        // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
+        // treat string primitives and their corresponding object instances as equal
+        return a == String(b);
+    }
+    var isArr = className == arrayClass;
+    if (!isArr) {
+
+      // exit for functions and DOM nodes
+      if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) {
+        return false;
+      }
+      // in older versions of Opera, `arguments` objects have `Array` constructors
+      var ctorA = !support.argsObject && isArguments(a) ? Object : a.constructor,
+          ctorB = !support.argsObject && isArguments(b) ? Object : b.constructor;
+
+      // non `Object` object instances with different constructors are not equal
+      if (ctorA != ctorB &&
+            !(hasOwnProperty.call(a, 'constructor') && hasOwnProperty.call(b, 'constructor')) &&
+            !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
+            ('constructor' in a && 'constructor' in b)
+          ) {
+        return false;
+      }
+    }
+    // assume cyclic structures are equal
+    // the algorithm for detecting cyclic structures is adapted from ES 5.1
+    // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
+    var initedStack = !stackA;
+    stackA || (stackA = []);
+    stackB || (stackB = []);
+
+    var length = stackA.length;
+    while (length--) {
+      if (stackA[length] == a) {
+        return stackB[length] == b;
+      }
+    }
+    var size = 0;
+    result = true;
+
+    // add `a` and `b` to the stack of traversed objects
+    stackA.push(a);
+    stackB.push(b);
+
+    // recursively compare objects and arrays (susceptible to call stack limits)
+    if (isArr) {
+      // compare lengths to determine if a deep comparison is necessary
+      length = a.length;
+      size = b.length;
+      result = size == length;
+
+      if (result) {
+        // deep compare the contents, ignoring non-numeric properties
+        while (size--) {
+          var index = length,
+              value = b[size];
+
+          if (!(result = deepEquals(a[size], value, stackA, stackB))) {
+            break;
+          }
+        }
+      }
+    }
+    else {
+      // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+      // which, in this case, is more costly
+      internalForIn(b, function(value, key, b) {
+        if (hasOwnProperty.call(b, key)) {
+          // count the number of properties.
+          size++;
+          // deep compare each property value.
+          return (result = hasOwnProperty.call(a, key) && deepEquals(a[key], value, stackA, stackB));
+        }
+      });
+
+      if (result) {
+        // ensure both objects have the same number of properties
+        internalForIn(a, function(value, key, a) {
+          if (hasOwnProperty.call(a, key)) {
+            // `size` will be `-1` if `a` has more properties than `b`
+            return (result = --size > -1);
+          }
+        });
+      }
+    }
+    stackA.pop();
+    stackB.pop();
+
+    return result;
+  }
+    var slice = Array.prototype.slice;
+    function argsOrArray(args, idx) {
+        return args.length === 1 && Array.isArray(args[idx]) ?
+            args[idx] :
+            slice.call(args);
+    }
+    var hasProp = {}.hasOwnProperty;
+
+    /** @private */
+    var inherits = this.inherits = Rx.internals.inherits = function (child, parent) {
+        function __() { this.constructor = child; }
+        __.prototype = parent.prototype;
+        child.prototype = new __();
+    };
+
+    /** @private */    
+    var addProperties = Rx.internals.addProperties = function (obj) {
+        var sources = slice.call(arguments, 1);
+        for (var i = 0, len = sources.length; i < len; i++) {
+            var source = sources[i];
+            for (var prop in source) {
+                obj[prop] = source[prop];
+            }
+        }
+    };
+
+    // Rx Utils
+    var addRef = Rx.internals.addRef = function (xs, r) {
+        return new AnonymousObservable(function (observer) {
+            return new CompositeDisposable(r.getDisposable(), xs.subscribe(observer));
+        });
+    };
+
+    // Collection polyfills
+    function arrayInitialize(count, factory) {
+        var a = new Array(count);
+        for (var i = 0; i < count; i++) {
+            a[i] = factory();
+        }
+        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;
+    };
+    PriorityQueue.count = 0;
+    /**
+     * Represents a group of disposable resources that are disposed together.
+     * @constructor
+     */
+    var CompositeDisposable = Rx.CompositeDisposable = function () {
+        this.disposables = argsOrArray(arguments, 0);
+        this.isDisposed = false;
+        this.length = this.disposables.length;
+    };
+
+    var CompositeDisposablePrototype = CompositeDisposable.prototype;
+
+    /**
+     * Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
+     * @param {Mixed} item Disposable to add.
+     */    
+    CompositeDisposablePrototype.add = function (item) {
+        if (this.isDisposed) {
+            item.dispose();
+        } else {
+            this.disposables.push(item);
+            this.length++;
+        }
+    };
+
+    /**
+     * Removes and disposes the first occurrence of a disposable from the CompositeDisposable.
+     * @param {Mixed} item Disposable to remove.
+     * @returns {Boolean} true if found; false otherwise.
+     */
+    CompositeDisposablePrototype.remove = function (item) {
+        var shouldDispose = false;
+        if (!this.isDisposed) {
+            var idx = this.disposables.indexOf(item);
+            if (idx !== -1) {
+                shouldDispose = true;
+                this.disposables.splice(idx, 1);
+                this.length--;
+                item.dispose();
+            }
+
+        }
+        return shouldDispose;
+    };
+
+    /**
+     *  Disposes all disposables in the group and removes them from the group.  
+     */
+    CompositeDisposablePrototype.dispose = function () {
+        if (!this.isDisposed) {
+            this.isDisposed = true;
+            var currentDisposables = this.disposables.slice(0);
+            this.disposables = [];
+            this.length = 0;
+
+            for (var i = 0, len = currentDisposables.length; i < len; i++) {
+                currentDisposables[i].dispose();
+            }
+        }
+    };
+
+    /**
+     * Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable.
+     */   
+    CompositeDisposablePrototype.clear = function () {
+        var currentDisposables = this.disposables.slice(0);
+        this.disposables = [];
+        this.length = 0;
+        for (var i = 0, len = currentDisposables.length; i < len; i++) {
+            currentDisposables[i].dispose();
+        }
+    };
+
+    /**
+     * Determines whether the CompositeDisposable contains a specific disposable.    
+     * @param {Mixed} item Disposable to search for.
+     * @returns {Boolean} true if the disposable was found; otherwise, false.
+     */    
+    CompositeDisposablePrototype.contains = function (item) {
+        return this.disposables.indexOf(item) !== -1;
+    };
+
+    /**
+     * Converts the existing CompositeDisposable to an array of disposables
+     * @returns {Array} An array of disposable objects.
+     */  
+    CompositeDisposablePrototype.toArray = function () {
+        return this.disposables.slice(0);
+    };
+    
+    /**
+     * Provides a set of static methods for creating Disposables.
+     *
+     * @constructor 
+     * @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.
+     */
+    var Disposable = Rx.Disposable = function (action) {
+        this.isDisposed = false;
+        this.action = action || noop;
+    };
+
+    /** Performs the task of cleaning up resources. */     
+    Disposable.prototype.dispose = function () {
+        if (!this.isDisposed) {
+            this.action();
+            this.isDisposed = true;
+        }
+    };
+
+    /**
+     * Creates a disposable object that invokes the specified action when disposed.
+     * @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.
+     * @return {Disposable} The disposable object that runs the given action upon disposal.
+     */
+    var disposableCreate = Disposable.create = function (action) { return new Disposable(action); };
+
+    /** 
+     * Gets the disposable that does nothing when disposed. 
+     */
+    var disposableEmpty = Disposable.empty = { dispose: noop };
+
+    var BooleanDisposable = (function () {
+        function BooleanDisposable (isSingle) {
+            this.isSingle = isSingle;
+            this.isDisposed = false;
+            this.current = null;
+        }
+
+        var booleanDisposablePrototype = BooleanDisposable.prototype;
+
+        /**
+         * Gets the underlying disposable.
+         * @return The underlying disposable.
+         */
+        booleanDisposablePrototype.getDisposable = function () {
+            return this.current;
+        };
+
+        /**
+         * Sets the underlying disposable.
+         * @param {Disposable} value The new underlying disposable.
+         */  
+        booleanDisposablePrototype.setDisposable = function (value) {
+            if (this.current && this.isSingle) {
+                throw new Error('Disposable has already been assigned');
+            }
+
+            var shouldDispose = this.isDisposed, old;
+            if (!shouldDispose) {
+                old = this.current;
+                this.current = value;
+            }
+            if (old) {
+                old.dispose();
+            }
+            if (shouldDispose && value) {
+                value.dispose();
+            }
+        };
+
+        /** 
+         * Disposes the underlying disposable as well as all future replacements.
+         */
+        booleanDisposablePrototype.dispose = function () {
+            var old;
+            if (!this.isDisposed) {
+                this.isDisposed = true;
+                old = this.current;
+                this.current = null;
+            }
+            if (old) {
+                old.dispose();
+            }
+        };
+
+        return BooleanDisposable;
+    }());
+
+    /**
+     * Represents a disposable resource which only allows a single assignment of its underlying disposable resource.
+     * If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an Error.
+     */
+    var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = (function (super_) {
+        inherits(SingleAssignmentDisposable, super_);
+
+        function SingleAssignmentDisposable() {
+            super_.call(this, true);
+        }
+
+        return SingleAssignmentDisposable;
+    }(BooleanDisposable));
+
+    /**
+     * Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource.
+     */
+    var SerialDisposable = Rx.SerialDisposable = (function (super_) {
+        inherits(SerialDisposable, super_);
+
+        function SerialDisposable() {
+            super_.call(this, false);
+        }
+
+        return SerialDisposable;
+    }(BooleanDisposable));
+
+    /**
+     * Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed.
+     */  
+    var RefCountDisposable = Rx.RefCountDisposable = (function () {
+
+        function InnerDisposable(disposable) {
+            this.disposable = disposable;
+            this.disposable.count++;
+            this.isInnerDisposed = false;
+        }
+
+        InnerDisposable.prototype.dispose = function () {
+            if (!this.disposable.isDisposed) {
+                if (!this.isInnerDisposed) {
+                    this.isInnerDisposed = true;
+                    this.disposable.count--;
+                    if (this.disposable.count === 0 && this.disposable.isPrimaryDisposed) {
+                        this.disposable.isDisposed = true;
+                        this.disposable.underlyingDisposable.dispose();
+                    }
+                }
+            }
+        };
+
+        /**
+         * Initializes a new instance of the RefCountDisposable with the specified disposable.
+         * @constructor
+         * @param {Disposable} disposable Underlying disposable.
+          */
+        function RefCountDisposable(disposable) {
+            this.underlyingDisposable = disposable;
+            this.isDisposed = false;
+            this.isPrimaryDisposed = false;
+            this.count = 0;
+        }
+
+        /** 
+         * Disposes the underlying disposable only when all dependent disposables have been disposed 
+         */
+        RefCountDisposable.prototype.dispose = function () {
+            if (!this.isDisposed) {
+                if (!this.isPrimaryDisposed) {
+                    this.isPrimaryDisposed = true;
+                    if (this.count === 0) {
+                        this.isDisposed = true;
+                        this.underlyingDisposable.dispose();
+                    }
+                }
+            }
+        };
+
+        /**
+         * Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable.      
+         * @returns {Disposable} A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime.
+         */        
+        RefCountDisposable.prototype.getDisposable = function () {
+            return this.isDisposed ? disposableEmpty : new InnerDisposable(this);
+        };
+
+        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);
+    };
+
+    /** Provides a set of static properties to access commonly used schedulers. */
+    var Scheduler = Rx.Scheduler = (function () {
+
+        /** 
+         * @constructor 
+         * @private
+         */
+        function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) {
+            this.now = now;
+            this._schedule = schedule;
+            this._scheduleRelative = scheduleRelative;
+            this._scheduleAbsolute = scheduleAbsolute;
+        }
+
+        function invokeRecImmediate(scheduler, pair) {
+            var state = pair.first, action = pair.second, group = new CompositeDisposable(),
+            recursiveAction = function (state1) {
+                action(state1, function (state2) {
+                    var isAdded = false, isDone = false,
+                    d = scheduler.scheduleWithState(state2, function (scheduler1, state3) {
+                        if (isAdded) {
+                            group.remove(d);
+                        } else {
+                            isDone = true;
+                        }
+                        recursiveAction(state3);
+                        return disposableEmpty;
+                    });
+                    if (!isDone) {
+                        group.add(d);
+                        isAdded = true;
+                    }
+                });
+            };
+            recursiveAction(state);
+            return group;
+        }
+
+        function invokeRecDate(scheduler, pair, method) {
+            var state = pair.first, action = pair.second, group = new CompositeDisposable(),
+            recursiveAction = function (state1) {
+                action(state1, function (state2, dueTime1) {
+                    var isAdded = false, isDone = false,
+                    d = scheduler[method].call(scheduler, state2, dueTime1, function (scheduler1, state3) {
+                        if (isAdded) {
+                            group.remove(d);
+                        } else {
+                            isDone = true;
+                        }
+                        recursiveAction(state3);
+                        return disposableEmpty;
+                    });
+                    if (!isDone) {
+                        group.add(d);
+                        isAdded = true;
+                    }
+                });
+            };
+            recursiveAction(state);
+            return group;
+        }
+
+        function invokeAction(scheduler, action) {
+            action();
+            return disposableEmpty;
+        }
+
+        var schedulerProto = Scheduler.prototype;
+
+        /**
+         * Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions.       
+         * @param {Function} handler Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false.
+         * @returns {Scheduler} Wrapper around the original scheduler, enforcing exception handling.
+         */        
+        schedulerProto.catchException = schedulerProto['catch'] = function (handler) {
+            return new CatchScheduler(this, handler);
+        };
+        
+        /**
+         * Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. The periodic task will be scheduled using window.setInterval for the base implementation.       
+         * @param {Number} period Period for running the work periodically.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled recurring action (best effort).
+         */        
+        schedulerProto.schedulePeriodic = function (period, action) {
+            return this.schedulePeriodicWithState(null, period, function () {
+                action();
+            });
+        };
+
+        /**
+         * Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. The periodic task will be scheduled using window.setInterval for the base implementation.       
+         * @param {Mixed} state Initial state passed to the action upon the first iteration.
+         * @param {Number} period Period for running the work periodically.
+         * @param {Function} action Action to be executed, potentially updating the state.
+         * @returns {Disposable} The disposable object used to cancel the scheduled recurring action (best effort).
+         */
+        schedulerProto.schedulePeriodicWithState = function (state, period, action) {
+            var s = state, id = setInterval(function () {
+                s = action(s);
+            }, period);
+            return disposableCreate(function () {
+                clearInterval(id);
+            });
+        };
+
+        /**
+         * Schedules an action to be executed.        
+         * @param {Function} action Action to execute.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.schedule = function (action) {
+            return this._schedule(action, invokeAction);
+        };
+
+        /**
+         * Schedules an action to be executed.    
+         * @param state State passed to the action to be executed.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleWithState = function (state, action) {
+            return this._schedule(state, action);
+        };
+
+        /**
+         * Schedules an action to be executed after the specified relative due time.       
+         * @param {Function} action Action to execute.
+         * @param {Number} dueTime Relative time after which to execute the action.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleWithRelative = function (dueTime, action) {
+            return this._scheduleRelative(action, dueTime, invokeAction);
+        };
+
+        /**
+         * Schedules an action to be executed after dueTime.     
+         * @param state State passed to the action to be executed.
+         * @param {Function} action Action to be executed.
+         * @param {Number} dueTime Relative time after which to execute the action.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleWithRelativeAndState = function (state, dueTime, action) {
+            return this._scheduleRelative(state, dueTime, action);
+        };
+
+        /**
+         * Schedules an action to be executed at the specified absolute due time.    
+         * @param {Function} action Action to execute.
+         * @param {Number} dueTime Absolute time at which to execute the action.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+          */
+        schedulerProto.scheduleWithAbsolute = function (dueTime, action) {
+            return this._scheduleAbsolute(action, dueTime, invokeAction);
+        };
+
+        /**
+         * Schedules an action to be executed at dueTime.     
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Function} action Action to be executed.
+         * @param {Number}dueTime Absolute time at which to execute the action.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleWithAbsoluteAndState = function (state, dueTime, action) {
+            return this._scheduleAbsolute(state, dueTime, action);
+        };
+
+        /**
+         * Schedules an action to be executed recursively.
+         * @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursive = function (action) {
+            return this.scheduleRecursiveWithState(action, function (_action, self) {
+                _action(function () {
+                    self(_action);
+                });
+            });
+        };
+
+        /**
+         * Schedules an action to be executed recursively.     
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Function} action Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursiveWithState = function (state, action) {
+            return this.scheduleWithState({ first: state, second: action }, function (s, p) {
+                return invokeRecImmediate(s, p);
+            });
+        };
+
+        /**
+         * Schedules an action to be executed recursively after a specified relative due time.     
+         * @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time.
+         * @param {Number}dueTime Relative time after which to execute the action for the first time.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursiveWithRelative = function (dueTime, action) {
+            return this.scheduleRecursiveWithRelativeAndState(action, dueTime, function (_action, self) {
+                _action(function (dt) {
+                    self(_action, dt);
+                });
+            });
+        };
+
+        /**
+         * Schedules an action to be executed recursively after a specified relative due time.  
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Function} action Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state.
+         * @param {Number}dueTime Relative time after which to execute the action for the first time.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursiveWithRelativeAndState = function (state, dueTime, action) {
+            return this._scheduleRelative({ first: state, second: action }, dueTime, function (s, p) {
+                return invokeRecDate(s, p, 'scheduleWithRelativeAndState');
+            });
+        };
+
+        /**
+         * Schedules an action to be executed recursively at a specified absolute due time.    
+         * @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time.
+         * @param {Number}dueTime Absolute time at which to execute the action for the first time.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursiveWithAbsolute = function (dueTime, action) {
+            return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, function (_action, self) {
+                _action(function (dt) {
+                    self(_action, dt);
+                });
+            });
+        };
+
+        /**
+         * Schedules an action to be executed recursively at a specified absolute due time.     
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Function} action Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state.
+         * @param {Number}dueTime Absolute time at which to execute the action for the first time.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        schedulerProto.scheduleRecursiveWithAbsoluteAndState = function (state, dueTime, action) {
+            return this._scheduleAbsolute({ first: state, second: action }, dueTime, function (s, p) {
+                return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
+            });
+        };
+
+        /** Gets the current time according to the local machine's system clock. */
+        Scheduler.now = defaultNow;
+
+        /**
+         * Normalizes the specified TimeSpan value to a positive value.
+         * @param {Number} timeSpan The time span value to normalize.
+         * @returns {Number} The specified TimeSpan value if it is zero or positive; otherwise, 0
+         */   
+        Scheduler.normalize = function (timeSpan) {
+            if (timeSpan < 0) {
+                timeSpan = 0;
+            }
+            return timeSpan;
+        };
+
+        return Scheduler;
+    }());
+
+    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);
+  }());
+
+    /** 
+     * Gets a scheduler that schedules work as soon as possible on the current thread.
+     */
+    var currentThreadScheduler = Scheduler.currentThread = (function () {
+        var queue;
+
+        function runTrampoline (q) {
+            var item;
+            while (q.length > 0) {
+                item = q.dequeue();
+                if (!item.isCancelled()) {
+                    // Note, do not schedule blocking work!
+                    while (item.dueTime - Scheduler.now() > 0) {
+                    }
+                    if (!item.isCancelled()) {
+                        item.invoke();
+                    }
+                }
+            }            
+        }
+
+        function scheduleNow(state, action) {
+            return this.scheduleWithRelativeAndState(state, 0, action);
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            var dt = this.now() + Scheduler.normalize(dueTime),
+                    si = new ScheduledItem(this, state, action, dt),
+                    t;
+            if (!queue) {
+                queue = new PriorityQueue(4);
+                queue.enqueue(si);
+                try {
+                    runTrampoline(queue);
+                } catch (e) { 
+                    throw e;
+                } finally {
+                    queue = null;
+                }
+            } else {
+                queue.enqueue(si);
+            }
+            return si.disposable;
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+        }
+
+        var currentScheduler = new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        currentScheduler.scheduleRequired = function () { return queue === null; };
+        currentScheduler.ensureTrampoline = function (action) {
+            if (queue === null) {
+                return this.schedule(action);
+            } else {
+                return action();
+            }
+        };
+
+        return currentScheduler;
+    }());
+
+  
+  var scheduleMethod, clearMethod = noop;
+  (function () {
+
+      var reNative = RegExp('^' +
+        String(toString)
+          .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+          .replace(/toString| for [^\]]+/g, '.*?') + '$'
+      );
+
+      var setImmediate = typeof (setImmediate = freeGlobal && moduleExports && freeGlobal.setImmediate) == 'function' &&
+        !reNative.test(setImmediate) && setImmediate,
+        clearImmediate = typeof (clearImmediate = freeGlobal && moduleExports && freeGlobal.clearImmediate) == 'function' &&
+        !reNative.test(clearImmediate) && clearImmediate;
+
+      function postMessageSupported () {
+        // Ensure not in a worker
+        if (!root.postMessage || root.importScripts) { return false; }
+        var isAsync = false, 
+            oldHandler = root.onmessage;
+        // Test for async
+        root.onmessage = function () { isAsync = true; };
+        root.postMessage('','*');
+        root.onmessage = oldHandler;
+
+        return isAsync;
+      }
+
+      // Use in order, nextTick, setImmediate, postMessage, MessageChannel, script readystatechanged, setTimeout
+      if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+        scheduleMethod = process.nextTick;
+      } else if (typeof setImmediate === 'function') {
+        scheduleMethod = setImmediate;
+        clearMethod = clearImmediate;
+      } else if (postMessageSupported()) {
+          var MSG_PREFIX = 'ms.rx.schedule' + Math.random(),
+            tasks = {},
+            taskId = 0;
+
+          function onGlobalPostMessage(event) {
+            // Only if we're a match to avoid any other global events
+            if (typeof event.data === 'string' && event.data.substring(0, MSG_PREFIX.length) === MSG_PREFIX) {
+              var handleId = event.data.substring(MSG_PREFIX.length),
+                action = tasks[handleId];
+              action();
+              delete tasks[handleId];
+            }
+          }
+
+          if (root.addEventListener) {
+            root.addEventListener('message', onGlobalPostMessage, false);
+          } else {
+            root.attachEvent('onmessage', onGlobalPostMessage, false);
+          }
+
+          scheduleMethod = function (action) {
+            var currentId = taskId++;
+            tasks[currentId] = action;
+            root.postMessage(MSG_PREFIX + currentId, '*');
+          };
+      } else if (!!root.MessageChannel) {
+          var channel = new root.MessageChannel(),
+            channelTasks = {},
+            channelTaskId = 0;
+
+          channel.port1.onmessage = function (event) {
+            var id = event.data,
+              action = channelTasks[id];
+            action();
+            delete channelTasks[id];
+          };
+
+          scheduleMethod = function (action) {
+            var id = channelTaskId++;
+            channelTasks[id] = action;
+            channel.port2.postMessage(id);     
+          };
+      } else if ('document' in root && 'onreadystatechange' in root.document.createElement('script')) {
+          
+        scheduleMethod = function (action) {
+          var scriptElement = root.document.createElement('script');
+          scriptElement.onreadystatechange = function () { 
+            action();
+            scriptElement.onreadystatechange = null;
+            scriptElement.parentNode.removeChild(scriptElement);
+            scriptElement = null;  
+          };
+          root.document.documentElement.appendChild(scriptElement);  
+        };
+
+      } else {
+        scheduleMethod = function (action) { return setTimeout(action, 0); };
+        clearMethod = clearTimeout;
+      }
+  }());
+
+  /** 
+   * Gets a scheduler that schedules work via a timed callback based upon platform.
+   */
+  var timeoutScheduler = Scheduler.timeout = (function () {
+
+    function scheduleNow(state, action) {
+        var scheduler = this,
+          disposable = new SingleAssignmentDisposable();
+        var id = scheduleMethod(function () {
+          if (!disposable.isDisposed) {
+            disposable.setDisposable(action(scheduler, state));
+          }
+        });
+        return new CompositeDisposable(disposable, disposableCreate(function () {
+          clearMethod(id);
+        }));
+    }
+
+    function scheduleRelative(state, dueTime, action) {
+        var scheduler = this,
+          dt = Scheduler.normalize(dueTime);
+        if (dt === 0) {
+          return scheduler.scheduleWithState(state, action);
+        }
+        var disposable = new SingleAssignmentDisposable();
+        var id = setTimeout(function () {
+          if (!disposable.isDisposed) {
+            disposable.setDisposable(action(scheduler, state));
+          }
+        }, dt);
+        return new CompositeDisposable(disposable, disposableCreate(function () {
+          clearTimeout(id);
+        }));
+    }
+
+    function scheduleAbsolute(state, dueTime, action) {
+      return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+    }
+
+    return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+  })();
+
+    /** @private */
+    var CatchScheduler = (function (_super) {
+
+        function localNow() {
+            return this._scheduler.now();
+        }
+
+        function scheduleNow(state, action) {
+            return this._scheduler.scheduleWithState(state, this._wrap(action));
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            return this._scheduler.scheduleWithRelativeAndState(state, dueTime, this._wrap(action));
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this._scheduler.scheduleWithAbsoluteAndState(state, dueTime, this._wrap(action));
+        }
+
+        inherits(CatchScheduler, _super);
+
+        /** @private */
+        function CatchScheduler(scheduler, handler) {
+            this._scheduler = scheduler;
+            this._handler = handler;
+            this._recursiveOriginal = null;
+            this._recursiveWrapper = null;
+            _super.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        }
+
+        /** @private */
+        CatchScheduler.prototype._clone = function (scheduler) {
+            return new CatchScheduler(scheduler, this._handler);
+        };
+
+        /** @private */
+        CatchScheduler.prototype._wrap = function (action) {
+            var parent = this;
+            return function (self, state) {
+                try {
+                    return action(parent._getRecursiveWrapper(self), state);
+                } catch (e) {
+                    if (!parent._handler(e)) { throw e; }
+                    return disposableEmpty;
+                }
+            };
+        };
+
+        /** @private */
+        CatchScheduler.prototype._getRecursiveWrapper = function (scheduler) {
+            if (this._recursiveOriginal !== scheduler) {
+                this._recursiveOriginal = scheduler;
+                var wrapper = this._clone(scheduler);
+                wrapper._recursiveOriginal = scheduler;
+                wrapper._recursiveWrapper = wrapper;
+                this._recursiveWrapper = wrapper;
+            }
+            return this._recursiveWrapper;
+        };
+
+        /** @private */
+        CatchScheduler.prototype.schedulePeriodicWithState = function (state, period, action) {
+            var self = this, failed = false, d = new SingleAssignmentDisposable();
+
+            d.setDisposable(this._scheduler.schedulePeriodicWithState(state, period, function (state1) {
+                if (failed) { return null; }
+                try {
+                    return action(state1);
+                } catch (e) {
+                    failed = true;
+                    if (!self._handler(e)) { throw e; }
+                    d.dispose();
+                    return null;
+                }
+            }));
+
+            return d;
+        };
+
+        return CatchScheduler;
+    }(Scheduler));
+
+    /**
+     *  Represents a notification to an observer.
+     */
+    var Notification = Rx.Notification = (function () {
+        function Notification(kind, hasValue) { 
+            this.hasValue = hasValue == null ? false : hasValue;
+            this.kind = kind;
+        }
+
+        var NotificationPrototype = Notification.prototype;
+
+        /**
+         * Invokes the delegate corresponding to the notification or the observer's method corresponding to the notification and returns the produced result.
+         * 
+         * @memberOf Notification
+         * @param {Any} observerOrOnNext Delegate to invoke for an OnNext notification or Observer to invoke the notification on..
+         * @param {Function} onError Delegate to invoke for an OnError notification.
+         * @param {Function} onCompleted Delegate to invoke for an OnCompleted notification.
+         * @returns {Any} Result produced by the observation.
+         */
+        NotificationPrototype.accept = function (observerOrOnNext, onError, onCompleted) {
+            if (arguments.length === 1 && typeof observerOrOnNext === 'object') {
+                return this._acceptObservable(observerOrOnNext);
+            }
+            return this._accept(observerOrOnNext, onError, onCompleted);
+        };
+
+        /**
+         * Returns an observable sequence with a single notification.
+         * 
+         * @memberOf Notification
+         * @param {Scheduler} [scheduler] Scheduler to send out the notification calls on.
+         * @returns {Observable} The observable sequence that surfaces the behavior of the notification upon subscription.
+         */
+        NotificationPrototype.toObservable = function (scheduler) {
+            var notification = this;
+            scheduler || (scheduler = immediateScheduler);
+            return new AnonymousObservable(function (observer) {
+                return scheduler.schedule(function () {
+                    notification._acceptObservable(observer);
+                    if (notification.kind === 'N') {
+                        observer.onCompleted();
+                    }
+                });
+            });
+        };
+
+        return Notification;
+    })();
+
+    /**
+     * Creates an object that represents an OnNext notification to an observer.
+     * @param {Any} value The value contained in the notification.
+     * @returns {Notification} The OnNext notification containing the value.
+     */
+    var notificationCreateOnNext = Notification.createOnNext = (function () {
+
+        function _accept (onNext) {
+            return onNext(this.value);
+        }
+
+        function _acceptObservable(observer) {
+            return observer.onNext(this.value);
+        }
+
+        function toString () {
+            return 'OnNext(' + this.value + ')';
+        }
+
+        return function (value) {
+            var notification = new Notification('N', true);
+            notification.value = value;
+            notification._accept = _accept;
+            notification._acceptObservable = _acceptObservable;
+            notification.toString = toString;
+            return notification;
+        };
+    }());
+
+    /**
+     * Creates an object that represents an OnError notification to an observer.
+     * @param {Any} error The exception contained in the notification.
+     * @returns {Notification} The OnError notification containing the exception.
+     */
+    var notificationCreateOnError = Notification.createOnError = (function () {
+
+        function _accept (onNext, onError) {
+            return onError(this.exception);
+        }
+
+        function _acceptObservable(observer) {
+            return observer.onError(this.exception);
+        }
+
+        function toString () {
+            return 'OnError(' + this.exception + ')';
+        }
+
+        return function (exception) {
+            var notification = new Notification('E');
+            notification.exception = exception;
+            notification._accept = _accept;
+            notification._acceptObservable = _acceptObservable;
+            notification.toString = toString;
+            return notification;
+        };
+    }());
+
+    /**
+     * Creates an object that represents an OnCompleted notification to an observer.
+     * @returns {Notification} The OnCompleted notification.
+     */
+    var notificationCreateOnCompleted = Notification.createOnCompleted = (function () {
+
+        function _accept (onNext, onError, onCompleted) {
+            return onCompleted();
+        }
+
+        function _acceptObservable(observer) {
+            return observer.onCompleted();
+        }
+
+        function toString () {
+            return 'OnCompleted()';
+        }
+
+        return function () {
+            var notification = new Notification('C');
+            notification._accept = _accept;
+            notification._acceptObservable = _acceptObservable;
+            notification.toString = toString;
+            return notification;
+        };
+    }());
+
+  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;
+        });
+    });
+  };
+
+  /**
+   * 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. 
+     */
+    var AbstractObserver = Rx.internals.AbstractObserver = (function (_super) {
+        inherits(AbstractObserver, _super);
+
+        /**
+         * Creates a new observer in a non-stopped state.
+         *
+         * @constructor
+         */
+        function AbstractObserver() {
+            this.isStopped = false;
+            _super.call(this);
+        }
+
+        /**
+         * Notifies the observer of a new element in the sequence.
+         *  
+         * @memberOf AbstractObserver
+         * @param {Any} value Next element in the sequence. 
+         */
+        AbstractObserver.prototype.onNext = function (value) {
+            if (!this.isStopped) {
+                this.next(value);
+            }
+        };
+
+        /**
+         * Notifies the observer that an exception has occurred.
+         * 
+         * @memberOf AbstractObserver
+         * @param {Any} error The error that has occurred.     
+         */    
+        AbstractObserver.prototype.onError = function (error) {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.error(error);
+            }
+        };
+
+        /**
+         * Notifies the observer of the end of the sequence.
+         */    
+        AbstractObserver.prototype.onCompleted = function () {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.completed();
+            }
+        };
+
+        /**
+         * Disposes the observer, causing it to transition to the stopped state.
+         */
+        AbstractObserver.prototype.dispose = function () {
+            this.isStopped = true;
+        };
+
+        AbstractObserver.prototype.fail = function (e) {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.error(e);
+                return true;
+            }
+
+            return false;
+        };
+
+        return AbstractObserver;
+    }(Observer));
+
+  /**
+   * Class to create an Observer instance from delegate-based implementations of the on* methods.
+   */
+  var AnonymousObserver = Rx.AnonymousObserver = (function (_super) {
+    inherits(AnonymousObserver, _super);
+
+    /**
+     * Creates an observer from the specified OnNext, OnError, and OnCompleted actions.
+     * @param {Any} onNext Observer's OnNext action implementation.
+     * @param {Any} onError Observer's OnError action implementation.
+     * @param {Any} onCompleted Observer's OnCompleted action implementation.  
+     */      
+    function AnonymousObserver(onNext, onError, onCompleted) {
+      _super.call(this);
+      this._onNext = onNext;
+      this._onError = onError;
+      this._onCompleted = onCompleted;
+    }
+
+    /**
+     * Calls the onNext action.
+     * @param {Any} value Next element in the sequence.   
+     */     
+    AnonymousObserver.prototype.next = function (value) {
+      this._onNext(value);
+    };
+
+    /**
+     * Calls the onError action.
+     * @param {Any} error The error that has occurred.   
+     */     
+    AnonymousObserver.prototype.error = function (exception) {
+      this._onError(exception);
+    };
+
+    /**
+     *  Calls the onCompleted action.
+     */        
+    AnonymousObserver.prototype.completed = function () {
+      this._onCompleted();
+    };
+
+    return AnonymousObserver;
+  }(AbstractObserver));
+
+    var CheckedObserver = (function (_super) {
+        inherits(CheckedObserver, _super);
+
+        function CheckedObserver(observer) {
+            _super.call(this);
+            this._observer = observer;
+            this._state = 0; // 0 - idle, 1 - busy, 2 - done
+        }
+
+        var CheckedObserverPrototype = CheckedObserver.prototype;
+
+        CheckedObserverPrototype.onNext = function (value) {
+            this.checkAccess();
+            try {
+                this._observer.onNext(value);
+            } catch (e) { 
+                throw e;                
+            } finally {
+                this._state = 0;
+            }
+        };
+
+        CheckedObserverPrototype.onError = function (err) {
+            this.checkAccess();
+            try {
+                this._observer.onError(err);
+            } catch (e) { 
+                throw e;                
+            } finally {
+                this._state = 2;
+            }
+        };
+
+        CheckedObserverPrototype.onCompleted = function () {
+            this.checkAccess();
+            try {
+                this._observer.onCompleted();
+            } catch (e) { 
+                throw e;                
+            } finally {
+                this._state = 2;
+            }
+        };
+
+        CheckedObserverPrototype.checkAccess = function () {
+            if (this._state === 1) { throw new Error('Re-entrancy detected'); }
+            if (this._state === 2) { throw new Error('Observer completed'); }
+            if (this._state === 0) { this._state = 1; }
+        };
+
+        return CheckedObserver;
+    }(Observer));
+
+  var ScheduledObserver = Rx.internals.ScheduledObserver = (function (_super) {
+    inherits(ScheduledObserver, _super);
+
+    function ScheduledObserver(scheduler, observer) {
+      _super.call(this);
+      this.scheduler = scheduler;
+      this.observer = observer;
+      this.isAcquired = false;
+      this.hasFaulted = false;
+      this.queue = [];
+      this.disposable = new SerialDisposable();
+    }
+
+    ScheduledObserver.prototype.next = function (value) {
+      var self = this;
+      this.queue.push(function () {
+        self.observer.onNext(value);
+      });
+    };
+
+    ScheduledObserver.prototype.error = function (exception) {
+      var self = this;
+      this.queue.push(function () {
+        self.observer.onError(exception);
+      });
+    };
+
+    ScheduledObserver.prototype.completed = function () {
+      var self = this;
+      this.queue.push(function () {
+        self.observer.onCompleted();
+      });
+    };
+
+    ScheduledObserver.prototype.ensureActive = function () {
+      var isOwner = false, parent = this;
+      if (!this.hasFaulted && this.queue.length > 0) {
+        isOwner = !this.isAcquired;
+        this.isAcquired = true;
+      }
+      if (isOwner) {
+        this.disposable.setDisposable(this.scheduler.scheduleRecursive(function (self) {
+          var work;
+          if (parent.queue.length > 0) {
+            work = parent.queue.shift();
+          } else {
+            parent.isAcquired = false;
+            return;
+          }
+          try {
+            work();
+          } catch (ex) {
+            parent.queue = [];
+            parent.hasFaulted = true;
+            throw ex;
+          }
+          self();
+        }));
+      }
+    };
+
+    ScheduledObserver.prototype.dispose = function () {
+      _super.prototype.dispose.call(this);
+      this.disposable.dispose();
+    };
+
+    return ScheduledObserver;
+  }(AbstractObserver));
+
+    /** @private */
+    var ObserveOnObserver = (function (_super) {
+        inherits(ObserveOnObserver, _super);
+
+        /** @private */ 
+        function ObserveOnObserver() {
+            _super.apply(this, arguments);
+        }
+
+        /** @private */ 
+        ObserveOnObserver.prototype.next = function (value) {
+            _super.prototype.next.call(this, value);
+            this.ensureActive();
+        };
+
+        /** @private */ 
+        ObserveOnObserver.prototype.error = function (e) {
+            _super.prototype.error.call(this, e);
+            this.ensureActive();
+        };
+
+        /** @private */ 
+        ObserveOnObserver.prototype.completed = function () {
+            _super.prototype.completed.call(this);
+            this.ensureActive();
+        };
+
+        return ObserveOnObserver;
+    })(ScheduledObserver);
+
+  var observableProto;
+
+  /**
+   * Represents a push-style collection.
+   */
+  var Observable = Rx.Observable = (function () {
+
+    function Observable(subscribe) {
+      this._subscribe = subscribe;
+    }
+
+    observableProto = Observable.prototype;
+
+    /**
+     *  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);
+
+      return this._subscribe(subscriber);
+    };
+
+    return Observable;
+  })();
+
+  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);
+      }
+
+      return subscriber;
+    }
+
+    function AnonymousObservable(subscribe) {
+      if (!(this instanceof AnonymousObservable)) {
+        return new AnonymousObservable(subscribe);
+      }
+
+      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;
+            }
+          }
+        }
+
+        return autoDetachObserver;
+      }
+
+      __super__.call(this, s);
+    }
+
+    return AnonymousObservable;
+
+  }(Observable));
+
+    /** @private */
+    var AutoDetachObserver = (function (_super) {
+        inherits(AutoDetachObserver, _super);
+
+        function AutoDetachObserver(observer) {
+            _super.call(this);
+            this.observer = observer;
+            this.m = new SingleAssignmentDisposable();
+        }
+
+        var AutoDetachObserverPrototype = AutoDetachObserver.prototype;
+
+        AutoDetachObserverPrototype.next = function (value) {
+            var noError = false;
+            try {
+                this.observer.onNext(value);
+                noError = true;
+            } catch (e) { 
+                throw e;                
+            } finally {
+                if (!noError) {
+                    this.dispose();
+                }
+            }
+        };
+
+        AutoDetachObserverPrototype.error = function (exn) {
+            try {
+                this.observer.onError(exn);
+            } catch (e) { 
+                throw e;                
+            } finally {
+                this.dispose();
+            }
+        };
+
+        AutoDetachObserverPrototype.completed = function () {
+            try {
+                this.observer.onCompleted();
+            } catch (e) { 
+                throw e;                
+            } finally {
+                this.dispose();
+            }
+        };
+
+        AutoDetachObserverPrototype.setDisposable = function (value) { this.m.setDisposable(value); };
+        AutoDetachObserverPrototype.getDisposable = function (value) { return this.m.getDisposable(); };
+        /* @private */
+        AutoDetachObserverPrototype.disposable = function (value) {
+            return arguments.length ? this.getDisposable() : setDisposable(value);
+        };
+
+        AutoDetachObserverPrototype.dispose = function () {
+            _super.prototype.dispose.call(this);
+            this.m.dispose();
+        };
+
+        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;
+        }
+    };
+
+    /**
+     *  Represents an object that is both an observable sequence as well as an observer.
+     *  Each notification is broadcasted to all subscribed observers.
+     */
+    var Subject = Rx.Subject = (function (_super) {
+        function subscribe(observer) {
+            checkDisposed.call(this);
+            if (!this.isStopped) {
+                this.observers.push(observer);
+                return new InnerSubscription(this, observer);
+            }
+            if (this.exception) {
+                observer.onError(this.exception);
+                return disposableEmpty;
+            }
+            observer.onCompleted();
+            return disposableEmpty;
+        }
+
+        inherits(Subject, _super);
+
+        /**
+         * Creates a subject.
+         * @constructor
+         */      
+        function Subject() {
+            _super.call(this, subscribe);
+            this.isDisposed = false,
+            this.isStopped = false,
+            this.observers = [];
+        }
+
+        addProperties(Subject.prototype, Observer, {
+            /**
+             * Indicates whether the subject has observers subscribed to it.
+             * @returns {Boolean} Indicates whether the subject has observers subscribed to it.
+             */         
+            hasObservers: function () {
+                return this.observers.length > 0;
+            },
+            /**
+             * Notifies all subscribed observers about the end of the sequence.
+             */                          
+            onCompleted: function () {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onCompleted();
+                    }
+
+                    this.observers = [];
+                }
+            },
+            /**
+             * Notifies all subscribed observers about the exception.
+             * @param {Mixed} error The exception to send to all observers.
+             */               
+            onError: function (exception) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    this.exception = exception;
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onError(exception);
+                    }
+
+                    this.observers = [];
+                }
+            },
+            /**
+             * Notifies all subscribed observers about the arrival of the specified element in the sequence.
+             * @param {Mixed} value The value to send to all observers.
+             */                 
+            onNext: function (value) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onNext(value);
+                    }
+                }
+            },
+            /**
+             * Unsubscribe all observers and release resources.
+             */                
+            dispose: function () {
+                this.isDisposed = true;
+                this.observers = null;
+            }
+        });
+
+        /**
+         * Creates a subject from the specified observer and observable.
+         * @param {Observer} observer The observer used to send messages to the subject.
+         * @param {Observable} observable The observable used to subscribe to messages sent from the subject.
+         * @returns {Subject} Subject implemented using the given observer and observable.
+         */
+        Subject.create = function (observer, observable) {
+            return new AnonymousSubject(observer, observable);
+        };
+
+        return Subject;
+    }(Observable));
+
+    /**
+     *  Represents the result of an asynchronous operation.
+     *  The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers.
+     */   
+    var AsyncSubject = Rx.AsyncSubject = (function (_super) {
+
+        function subscribe(observer) {
+            checkDisposed.call(this);
+            
+            if (!this.isStopped) {
+                this.observers.push(observer);
+                return new InnerSubscription(this, observer);
+            }
+
+            var ex = this.exception,
+                hv = this.hasValue,
+                v = this.value;
+
+            if (ex) {
+                observer.onError(ex);
+            } else if (hv) {
+                observer.onNext(v);
+                observer.onCompleted();
+            } else {
+                observer.onCompleted();
+            }
+
+            return disposableEmpty;
+        }
+
+        inherits(AsyncSubject, _super);
+
+        /**
+         * Creates a subject that can only receive one value and that value is cached for all future observations.
+         * @constructor
+         */ 
+        function AsyncSubject() {
+            _super.call(this, subscribe);
+
+            this.isDisposed = false;
+            this.isStopped = false;
+            this.value = null;
+            this.hasValue = false;
+            this.observers = [];
+            this.exception = null;
+        }
+
+        addProperties(AsyncSubject.prototype, Observer, {
+            /**
+             * Indicates whether the subject has observers subscribed to it.
+             * @returns {Boolean} Indicates whether the subject has observers subscribed to it.
+             */         
+            hasObservers: function () {
+                checkDisposed.call(this);
+                return this.observers.length > 0;
+            },
+            /**
+             * Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any).
+             */ 
+            onCompleted: function () {
+                var o, i, len;
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    this.isStopped = true;
+                    var os = this.observers.slice(0),
+                        v = this.value,
+                        hv = this.hasValue;
+
+                    if (hv) {
+                        for (i = 0, len = os.length; i < len; i++) {
+                            o = os[i];
+                            o.onNext(v);
+                            o.onCompleted();
+                        }
+                    } else {
+                        for (i = 0, len = os.length; i < len; i++) {
+                            os[i].onCompleted();
+                        }
+                    }
+
+                    this.observers = [];
+                }
+            },
+            /**
+             * Notifies all subscribed observers about the exception.
+             * @param {Mixed} error The exception to send to all observers.
+             */ 
+            onError: function (exception) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    this.exception = exception;
+
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onError(exception);
+                    }
+
+                    this.observers = [];
+                }
+            },
+            /**
+             * Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers.
+             * @param {Mixed} value The value to store in the subject.
+             */             
+            onNext: function (value) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    this.value = value;
+                    this.hasValue = true;
+                }
+            },
+            /**
+             * Unsubscribe all observers and release resources.
+             */
+            dispose: function () {
+                this.isDisposed = true;
+                this.observers = null;
+                this.exception = null;
+                this.value = null;
+            }
+        });
+
+        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;
+    }
+}.call(this));