adding RxJS

js/libs/rxjs/rx.aggregates.js

@@ -0,0 +1,684 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+  // References
+  var Observable = Rx.Observable,
+    observableProto = Observable.prototype,
+    CompositeDisposable = Rx.CompositeDisposable,
+    AnonymousObservable = Rx.AnonymousObservable,
+    isEqual = Rx.internals.isEqual,
+    helpers = Rx.helpers,
+    defaultComparer = helpers.defaultComparer,
+    identity = helpers.identity,
+    subComparer = helpers.defaultSubComparer,
+    isPromise = helpers.isPromise,
+    observableFromPromise = Observable.fromPromise;
+
+  // Defaults
+  var argumentOutOfRange = 'Argument out of range',
+      sequenceContainsNoElements = "Sequence contains no elements.";
+  
+    function extremaBy(source, keySelector, comparer) {
+        return new AnonymousObservable(function (observer) {
+            var hasValue = false, lastKey = null, list = [];
+            return source.subscribe(function (x) {
+                var comparison, key;
+                try {
+                    key = keySelector(x);
+                } catch (ex) {
+                    observer.onError(ex);
+                    return;
+                }
+                comparison = 0;
+                if (!hasValue) {
+                    hasValue = true;
+                    lastKey = key;
+                } else {
+                    try {
+                        comparison = comparer(key, lastKey);
+                    } catch (ex1) {
+                        observer.onError(ex1);
+                        return;
+                    }
+                }
+                if (comparison > 0) {
+                    lastKey = key;
+                    list = [];
+                }
+                if (comparison >= 0) {
+                    list.push(x);
+                }
+            }, observer.onError.bind(observer), function () {
+                observer.onNext(list);
+                observer.onCompleted();
+            });
+        });
+    }
+
+    function firstOnly(x) {
+        if (x.length === 0) {
+            throw new Error(sequenceContainsNoElements);
+        }
+        return x[0];
+    }
+
+    /**
+     * Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
+     * For aggregation behavior with incremental intermediate results, see Observable.scan.
+     * @example
+     * 1 - res = source.aggregate(function (acc, x) { return acc + x; });
+     * 2 - res = source.aggregate(0, function (acc, x) { return acc + x; });
+     * @param {Mixed} [seed] The initial accumulator value.
+     * @param {Function} accumulator An accumulator function to be invoked on each element.
+     * @returns {Observable} An observable sequence containing a single element with the final accumulator value.
+     */
+    observableProto.aggregate = function () {
+        var seed, hasSeed, accumulator;
+        if (arguments.length === 2) {
+            seed = arguments[0];
+            hasSeed = true;
+            accumulator = arguments[1];
+        } else {
+            accumulator = arguments[0];
+        }
+        return hasSeed ? this.scan(seed, accumulator).startWith(seed).finalValue() : this.scan(accumulator).finalValue();
+    };
+
+    /**
+     * Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
+     * For aggregation behavior with incremental intermediate results, see Observable.scan.
+     * @example
+     * 1 - res = source.reduce(function (acc, x) { return acc + x; });
+     * 2 - res = source.reduce(function (acc, x) { return acc + x; }, 0);
+     * @param {Function} accumulator An accumulator function to be invoked on each element.
+     * @param {Any} [seed] The initial accumulator value.     
+     * @returns {Observable} An observable sequence containing a single element with the final accumulator value.
+     */
+    observableProto.reduce = function (accumulator) {
+        var seed, hasSeed;
+        if (arguments.length === 2) {
+            hasSeed = true;
+            seed = arguments[1];
+        } 
+        return hasSeed ? this.scan(seed, accumulator).startWith(seed).finalValue() : this.scan(accumulator).finalValue();
+    };
+
+    /**
+     * Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.
+     * @example
+     * var result = source.any();
+     * var result = source.any(function (x) { return x > 3; });
+     * @param {Function} [predicate] A function to test each element for a condition.
+     * @returns {Observable} An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate if given, else if any items are in the sequence.
+     */
+    observableProto.some = observableProto.any = function (predicate, thisArg) {
+        var source = this;
+        return predicate ? 
+            source.where(predicate, thisArg).any() : 
+            new AnonymousObservable(function (observer) {
+                return source.subscribe(function () {
+                    observer.onNext(true);
+                    observer.onCompleted();
+                }, observer.onError.bind(observer), function () {
+                    observer.onNext(false);
+                    observer.onCompleted();
+                });
+            });
+    };
+
+    /**
+     * Determines whether an observable sequence is empty.
+     *
+     * @memberOf Observable#
+     * @returns {Observable} An observable sequence containing a single element determining whether the source sequence is empty.
+     */
+    observableProto.isEmpty = function () {
+        return this.any().select(function (b) { return !b; });
+    };
+
+    /**
+     * Determines whether all elements of an observable sequence satisfy a condition.
+     * 
+     * 1 - res = source.all(function (value) { return value.length > 3; });
+     * @memberOf Observable#
+     * @param {Function} [predicate] A function to test each element for a condition.
+     * @param {Any} [thisArg] Object to use as this when executing callback.
+     * @returns {Observable} An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.
+     */
+    observableProto.every = observableProto.all = function (predicate, thisArg) {
+        return this.where(function (v) {
+            return !predicate(v);
+        }, thisArg).any().select(function (b) {
+            return !b;
+        });
+    };
+
+    /**
+     * Determines whether an observable sequence contains a specified element with an optional equality comparer.
+     * @example
+     * 1 - res = source.contains(42);
+     * 2 - res = source.contains({ value: 42 }, function (x, y) { return x.value === y.value; });
+     * @param value The value to locate in the source sequence.
+     * @param {Function} [comparer] An equality comparer to compare elements.
+     * @returns {Observable} An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value.
+     */
+    observableProto.contains = function (value, comparer) {
+        comparer || (comparer = defaultComparer);
+        return this.where(function (v) {
+            return comparer(v, value);
+        }).any();
+    };
+
+    /**
+     * Returns an observable sequence containing a value that represents how many elements in the specified observable sequence satisfy a condition if provided, else the count of items.
+     * @example
+     * res = source.count();
+     * res = source.count(function (x) { return x > 3; });
+     * @param {Function} [predicate]A function to test each element for a condition.
+     * @param {Any} [thisArg] Object to use as this when executing callback.        
+     * @returns {Observable} An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function if provided, else the count of items in the sequence.
+     */
+    observableProto.count = function (predicate, thisArg) {
+        return predicate ?
+            this.where(predicate, thisArg).count() :
+            this.aggregate(0, function (count) {
+                return count + 1;
+            });
+    };
+
+    /**
+     * Computes the sum of a sequence of values that are obtained by invoking an optional transform function on each element of the input sequence, else if not specified computes the sum on each item in the sequence.
+     * @example
+     * var res = source.sum();
+     * var res = source.sum(function (x) { return x.value; });
+     * @param {Function} [selector] A transform function to apply to each element.
+     * @param {Any} [thisArg] Object to use as this when executing callback.        
+     * @returns {Observable} An observable sequence containing a single element with the sum of the values in the source sequence.
+     */    
+    observableProto.sum = function (keySelector, thisArg) {
+        return keySelector ? 
+            this.select(keySelector, thisArg).sum() :
+            this.aggregate(0, function (prev, curr) {
+                return prev + curr;
+            });
+    };
+
+    /**
+     * Returns the elements in an observable sequence with the minimum key value according to the specified comparer.
+     * @example
+     * var res = source.minBy(function (x) { return x.value; });
+     * var res = source.minBy(function (x) { return x.value; }, function (x, y) { return x - y; });
+     * @param {Function} keySelector Key selector function.
+     * @param {Function} [comparer] Comparer used to compare key values.
+     * @returns {Observable} An observable sequence containing a list of zero or more elements that have a minimum key value.
+     */  
+    observableProto.minBy = function (keySelector, comparer) {
+        comparer || (comparer = subComparer);
+        return extremaBy(this, keySelector, function (x, y) {
+            return comparer(x, y) * -1;
+        });
+    };
+
+    /**
+     * Returns the minimum element in an observable sequence according to the optional comparer else a default greater than less than check.
+     * @example
+     * var res = source.min();
+     * var res = source.min(function (x, y) { return x.value - y.value; });
+     * @param {Function} [comparer] Comparer used to compare elements.
+     * @returns {Observable} An observable sequence containing a single element with the minimum element in the source sequence.
+     */
+    observableProto.min = function (comparer) {
+        return this.minBy(identity, comparer).select(function (x) {
+            return firstOnly(x);
+        });
+    };
+
+    /**
+     * Returns the elements in an observable sequence with the maximum  key value according to the specified comparer.
+     * @example
+     * var res = source.maxBy(function (x) { return x.value; });
+     * var res = source.maxBy(function (x) { return x.value; }, function (x, y) { return x - y;; });
+     * @param {Function} keySelector Key selector function.
+     * @param {Function} [comparer]  Comparer used to compare key values.
+     * @returns {Observable} An observable sequence containing a list of zero or more elements that have a maximum key value.
+     */
+    observableProto.maxBy = function (keySelector, comparer) {
+        comparer || (comparer = subComparer);
+        return extremaBy(this, keySelector, comparer);
+    };
+
+    /**
+     * Returns the maximum value in an observable sequence according to the specified comparer.
+     * @example
+     * var res = source.max();
+     * var res = source.max(function (x, y) { return x.value - y.value; });
+     * @param {Function} [comparer] Comparer used to compare elements.
+     * @returns {Observable} An observable sequence containing a single element with the maximum element in the source sequence.
+     */
+    observableProto.max = function (comparer) {
+        return this.maxBy(identity, comparer).select(function (x) {
+            return firstOnly(x);
+        });
+    };
+
+    /**
+     * Computes the average of an observable sequence of values that are in the sequence or obtained by invoking a transform function on each element of the input sequence if present.
+     * @example
+     * var res = res = source.average();
+     * var res = res = source.average(function (x) { return x.value; });
+     * @param {Function} [selector] A transform function to apply to each element.
+     * @param {Any} [thisArg] Object to use as this when executing callback.        
+     * @returns {Observable} An observable sequence containing a single element with the average of the sequence of values.
+     */
+    observableProto.average = function (keySelector, thisArg) {
+        return keySelector ?
+            this.select(keySelector, thisArg).average() :
+            this.scan({
+                sum: 0,
+                count: 0
+            }, function (prev, cur) {
+                return {
+                    sum: prev.sum + cur,
+                    count: prev.count + 1
+                };
+            }).finalValue().select(function (s) {
+                if (s.count === 0) {
+                    throw new Error('The input sequence was empty');
+                }
+                return s.sum / s.count;
+            });
+    };
+
+  function sequenceEqualArray(first, second, comparer) {
+      return new AnonymousObservable(function (observer) {
+        var count = 0, len = second.length;
+        return first.subscribe(function (value) {
+          var equal = false;
+          try {
+            if (count < len) {
+              equal = comparer(value, second[count++]);
+            }
+          } catch (e) {
+            observer.onError(e);
+            return;
+          }
+          if (!equal) {
+            observer.onNext(false);
+            observer.onCompleted();
+          }
+        }, observer.onError.bind(observer), function () {
+          observer.onNext(count === len);
+          observer.onCompleted();
+        });
+      });
+  }
+
+  /**
+   *  Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.
+   * 
+   * @example
+   * var res = res = source.sequenceEqual([1,2,3]);
+   * var res = res = source.sequenceEqual([{ value: 42 }], function (x, y) { return x.value === y.value; });
+   * 3 - res = source.sequenceEqual(Rx.Observable.returnValue(42));
+   * 4 - res = source.sequenceEqual(Rx.Observable.returnValue({ value: 42 }), function (x, y) { return x.value === y.value; });
+   * @param {Observable} second Second observable sequence or array to compare.
+   * @param {Function} [comparer] Comparer used to compare elements of both sequences.
+   * @returns {Observable} An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer.
+   */
+  observableProto.sequenceEqual = function (second, comparer) {
+    var first = this;
+    comparer || (comparer = defaultComparer);
+    if (Array.isArray(second)) {
+      return sequenceEqualArray(first, second, comparer);
+    }
+    return new AnonymousObservable(function (observer) {
+      var donel = false, doner = false, ql = [], qr = [];
+      var subscription1 = first.subscribe(function (x) {
+        var equal, v;
+        if (qr.length > 0) {
+            v = qr.shift();
+            try {
+              equal = comparer(v, x);
+            } catch (e) {
+              observer.onError(e);
+              return;
+            }
+            if (!equal) {
+              observer.onNext(false);
+              observer.onCompleted();
+            }
+        } else if (doner) {
+          observer.onNext(false);
+          observer.onCompleted();
+        } else {
+          ql.push(x);
+        }
+      }, observer.onError.bind(observer), function () {
+        donel = true;
+        if (ql.length === 0) {
+          if (qr.length > 0) {
+            observer.onNext(false);
+            observer.onCompleted();
+          } else if (doner) {
+            observer.onNext(true);
+            observer.onCompleted();
+          }
+        }
+      });
+
+      isPromise(second) && (second = observableFromPromise(second));
+      var subscription2 = second.subscribe(function (x) {
+        var equal, v;
+        if (ql.length > 0) {
+          v = ql.shift();
+          try {
+            equal = comparer(v, x);
+          } catch (exception) {
+            observer.onError(exception);
+            return;
+          }
+          if (!equal) {
+            observer.onNext(false);
+            observer.onCompleted();
+          }
+        } else if (donel) {
+          observer.onNext(false);
+          observer.onCompleted();
+        } else {
+          qr.push(x);
+        }
+      }, observer.onError.bind(observer), function () {
+        doner = true;
+        if (qr.length === 0) {
+          if (ql.length > 0) {
+            observer.onNext(false);
+            observer.onCompleted();
+          } else if (donel) {
+            observer.onNext(true);
+            observer.onCompleted();
+          }
+        }
+      });
+      return new CompositeDisposable(subscription1, subscription2);
+    });
+  };
+
+    function elementAtOrDefault(source, index, hasDefault, defaultValue) {
+        if (index < 0) {
+            throw new Error(argumentOutOfRange);
+        }
+        return new AnonymousObservable(function (observer) {
+            var i = index;
+            return source.subscribe(function (x) {
+                if (i === 0) {
+                    observer.onNext(x);
+                    observer.onCompleted();
+                }
+                i--;
+            }, observer.onError.bind(observer), function () {
+                if (!hasDefault) {
+                    observer.onError(new Error(argumentOutOfRange));
+                } else {
+                    observer.onNext(defaultValue);
+                    observer.onCompleted();
+                }
+            });
+        });
+    }
+
+    /**
+     * Returns the element at a specified index in a sequence.
+     * @example
+     * var res = source.elementAt(5);
+     * @param {Number} index The zero-based index of the element to retrieve.
+     * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence.
+     */
+    observableProto.elementAt =  function (index) {
+        return elementAtOrDefault(this, index, false);
+    };
+
+    /**
+     * Returns the element at a specified index in a sequence or a default value if the index is out of range.
+     * @example
+     * var res = source.elementAtOrDefault(5);
+     * var res = source.elementAtOrDefault(5, 0);
+     * @param {Number} index The zero-based index of the element to retrieve.
+     * @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
+     * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence.
+     */    
+    observableProto.elementAtOrDefault = function (index, defaultValue) {
+        return elementAtOrDefault(this, index, true, defaultValue);
+    };
+
+    function singleOrDefaultAsync(source, hasDefault, defaultValue) {
+        return new AnonymousObservable(function (observer) {
+            var value = defaultValue, seenValue = false;
+            return source.subscribe(function (x) {
+                if (seenValue) {
+                    observer.onError(new Error('Sequence contains more than one element'));
+                } else {
+                    value = x;
+                    seenValue = true;
+                }
+            }, observer.onError.bind(observer), function () {
+                if (!seenValue && !hasDefault) {
+                    observer.onError(new Error(sequenceContainsNoElements));
+                } else {
+                    observer.onNext(value);
+                    observer.onCompleted();
+                }
+            });
+        });
+    }
+
+    /**
+     * Returns the only element of an observable sequence that satisfies the condition in the optional predicate, and reports an exception if there is not exactly one element in the observable sequence.
+     * @example
+     * var res = res = source.single();
+     * var res = res = source.single(function (x) { return x === 42; });
+     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.        
+     * @returns {Observable} Sequence containing the single element in the observable sequence that satisfies the condition in the predicate.
+     */
+    observableProto.single = function (predicate, thisArg) {
+        return predicate ?
+            this.where(predicate, thisArg).single() :
+            singleOrDefaultAsync(this, false);
+    };
+
+    /**
+     * Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence.
+     * @example
+     * var res = res = source.singleOrDefault();
+     * var res = res = source.singleOrDefault(function (x) { return x === 42; });
+     * res = source.singleOrDefault(function (x) { return x === 42; }, 0);
+     * res = source.singleOrDefault(null, 0);
+     * @memberOf Observable#
+     * @param {Function} predicate A predicate function to evaluate for elements in the source sequence.
+     * @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.        
+     * @returns {Observable} Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+     */
+    observableProto.singleOrDefault = function (predicate, defaultValue, thisArg) {
+        return predicate?
+            this.where(predicate, thisArg).singleOrDefault(null, defaultValue) :
+            singleOrDefaultAsync(this, true, defaultValue)
+    };
+    function firstOrDefaultAsync(source, hasDefault, defaultValue) {
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(function (x) {
+                observer.onNext(x);
+                observer.onCompleted();
+            }, observer.onError.bind(observer), function () {
+                if (!hasDefault) {
+                    observer.onError(new Error(sequenceContainsNoElements));
+                } else {
+                    observer.onNext(defaultValue);
+                    observer.onCompleted();
+                }
+            });
+        });
+    }
+
+    /**
+     * Returns the first element of an observable sequence that satisfies the condition in the predicate if present else the first item in the sequence.
+     * @example
+     * var res = res = source.first();
+     * var res = res = source.first(function (x) { return x > 3; });
+     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.     
+     * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate if provided, else the first item in the sequence.
+     */    
+    observableProto.first = function (predicate, thisArg) {
+        return predicate ?
+            this.where(predicate, thisArg).first() :
+            firstOrDefaultAsync(this, false);
+    };
+
+    /**
+     * Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+     * @example     
+     * var res = res = source.firstOrDefault();
+     * var res = res = source.firstOrDefault(function (x) { return x > 3; });
+     * var res = source.firstOrDefault(function (x) { return x > 3; }, 0);
+     * var res = source.firstOrDefault(null, 0);
+     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence. 
+     * @param {Any} [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+     * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+     */
+    observableProto.firstOrDefault = function (predicate, defaultValue, thisArg) {
+        return predicate ?
+            this.where(predicate).firstOrDefault(null, defaultValue) :
+            firstOrDefaultAsync(this, true, defaultValue);
+    };
+
+    function lastOrDefaultAsync(source, hasDefault, defaultValue) {
+        return new AnonymousObservable(function (observer) {
+            var value = defaultValue, seenValue = false;
+            return source.subscribe(function (x) {
+                value = x;
+                seenValue = true;
+            }, observer.onError.bind(observer), function () {
+                if (!seenValue && !hasDefault) {
+                    observer.onError(new Error(sequenceContainsNoElements));
+                } else {
+                    observer.onNext(value);
+                    observer.onCompleted();
+                }
+            });
+        });
+    }
+
+    /**
+     * Returns the last element of an observable sequence that satisfies the condition in the predicate if specified, else the last element.
+     * @example
+     * var res = source.last();
+     * var res = source.last(function (x) { return x > 3; });
+     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.     
+     * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate.
+     */
+    observableProto.last = function (predicate, thisArg) {
+        return predicate ?
+            this.where(predicate, thisArg).last() :
+            lastOrDefaultAsync(this, false);
+    };
+
+    /**
+     * Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+     * @example
+     * var res = source.lastOrDefault();
+     * var res = source.lastOrDefault(function (x) { return x > 3; });
+     * var res = source.lastOrDefault(function (x) { return x > 3; }, 0);
+     * var res = source.lastOrDefault(null, 0);
+     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+     * @param [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.     
+     * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+     */
+    observableProto.lastOrDefault = function (predicate, defaultValue, thisArg) {
+        return predicate ? 
+            this.where(predicate, thisArg).lastOrDefault(null, defaultValue) :
+            lastOrDefaultAsync(this, true, defaultValue);
+    };
+
+    function findValue (source, predicate, thisArg, yieldIndex) {
+        return new AnonymousObservable(function (observer) {
+            var i = 0;
+            return source.subscribe(function (x) {
+                var shouldRun;
+                try {
+                    shouldRun = predicate.call(thisArg, x, i, source);
+                } catch(e) {
+                    observer.onError(e);
+                    return;
+                }
+                if (shouldRun) {
+                    observer.onNext(yieldIndex ? i : x);
+                    observer.onCompleted();
+                } else {
+                    i++;
+                }
+            }, observer.onError.bind(observer), function () {
+                observer.onNext(yieldIndex ? -1 : undefined);
+                observer.onCompleted();
+            });
+        });        
+    }
+
+    /**
+     * Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Observable sequence.
+     * @param {Function} predicate The predicate that defines the conditions of the element to search for.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.          
+     * @returns {Observable} An Observable sequence with the first element that matches the conditions defined by the specified predicate, if found; otherwise, undefined.
+     */
+    observableProto.find = function (predicate, thisArg) {
+        return findValue(this, predicate, thisArg, false);
+    };
+
+    /**
+     * Searches for an element that matches the conditions defined by the specified predicate, and returns 
+     * an Observable sequence with the zero-based index of the first occurrence within the entire Observable sequence. 
+     * @param {Function} predicate The predicate that defines the conditions of the element to search for.
+     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.          
+     * @returns {Observable} An Observable sequence with the zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1.
+    */
+    observableProto.findIndex = function (predicate, thisArg) {
+        return findValue(this, predicate, thisArg, true);
+    };
+
+    return Rx;
+}));

js/libs/rxjs/rx.async.compat.js

@@ -0,0 +1,396 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx.binding', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    // Aliases
+    var Observable = Rx.Observable,
+    	observableProto = Observable.prototype,
+      observableFromPromise = Observable.fromPromise,
+      observableThrow = Observable.throwException,
+      AnonymousObservable = Rx.AnonymousObservable,
+      AsyncSubject = Rx.AsyncSubject,
+      disposableCreate = Rx.Disposable.create,
+      CompositeDisposable= Rx.CompositeDisposable,
+      immediateScheduler = Rx.Scheduler.immediate,
+      timeoutScheduler = Rx.Scheduler.timeout,
+      slice = Array.prototype.slice;
+
+    /**
+     * Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence.
+     * 
+     * @example
+     * var res = Rx.Observable.start(function () { console.log('hello'); });
+     * var res = Rx.Observable.start(function () { console.log('hello'); }, Rx.Scheduler.timeout);
+     * var res = Rx.Observable.start(function () { this.log('hello'); }, Rx.Scheduler.timeout, console);
+     * 
+     * @param {Function} func Function to run asynchronously.
+     * @param {Scheduler} [scheduler]  Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param [context]  The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Observable} An observable sequence exposing the function's result value, or an exception.
+     * 
+     * Remarks
+     * * The function is called immediately, not during the subscription of the resulting sequence.
+     * * Multiple subscriptions to the resulting sequence can observe the function's result.  
+     */
+    Observable.start = function (func, scheduler, context) {
+        return observableToAsync(func, scheduler, context)();
+    };
+
+    /**
+     * Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.
+     * 
+     * @example
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; })(4, 3);
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; }, Rx.Scheduler.timeout)(4, 3);
+     * var res = Rx.Observable.toAsync(function (x) { this.log(x); }, Rx.Scheduler.timeout, console)('hello');
+     * 
+     * @param {Function} function Function to convert to an asynchronous function.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Function} Asynchronous function.
+     */
+    var observableToAsync = Observable.toAsync = function (func, scheduler, context) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = arguments, 
+                subject = new AsyncSubject();
+
+            scheduler.schedule(function () {
+                var result;
+                try {
+                    result = func.apply(context, args);
+                } catch (e) {
+                    subject.onError(e);
+                    return;
+                }
+                subject.onNext(result);
+                subject.onCompleted();
+            });
+            return subject.asObservable();
+        };
+    };
+
+    /**
+     * Converts a callback function to an observable sequence. 
+     * 
+     * @param {Function} function Function with a callback as the last parameter to convert to an Observable sequence.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback to produce a single item to yield on next.
+     * @returns {Function} A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array.
+     */
+    Observable.fromCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = immediateScheduler);
+        return function () {
+            var args = slice.call(arguments, 0);
+
+            return new AnonymousObservable(function (observer) {
+                return scheduler.schedule(function () {
+                    function handler(e) {
+                        var results = e;
+                        
+                        if (selector) {
+                            try {
+                                results = selector(arguments);
+                            } catch (err) {
+                                observer.onError(err);
+                                return;
+                            }
+                        } else {
+                            if (results.length === 1) {
+                                results = results[0];
+                            }
+                        }
+
+                        observer.onNext(results);
+                        observer.onCompleted();
+                    }
+
+                    args.push(handler);
+                    func.apply(context, args);
+                });
+            });
+        };
+    };
+
+    /**
+     * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
+     * @param {Function} func The function to call
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback minus the error to produce a single item to yield on next.     
+     * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
+     */
+    Observable.fromNodeCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = immediateScheduler);
+        return function () {
+            var args = slice.call(arguments, 0);
+
+            return new AnonymousObservable(function (observer) {
+                return scheduler.schedule(function () {
+                    
+                    function handler(err) {
+                        if (err) {
+                            observer.onError(err);
+                            return;
+                        }
+
+                        var results = slice.call(arguments, 1);
+                        
+                        if (selector) {
+                            try {
+                                results = selector(results);
+                            } catch (e) {
+                                observer.onError(e);
+                                return;
+                            }
+                        } else {
+                            if (results.length === 1) {
+                                results = results[0];
+                            }
+                        }
+
+                        observer.onNext(results);
+                        observer.onCompleted();
+                    }
+
+                    args.push(handler);
+                    func.apply(context, args);
+                });
+            });
+        };
+    };
+
+  function fixEvent(event) {
+    var stopPropagation = function () {
+      this.cancelBubble = true;
+    };
+
+    var preventDefault = function () {
+      this.bubbledKeyCode = this.keyCode;
+      if (this.ctrlKey) {
+        try {
+          this.keyCode = 0;
+        } catch (e) { }
+      }
+      this.defaultPrevented = true;
+      this.returnValue = false;
+      this.modified = true;
+    };
+
+    event || (event = root.event);
+    if (!event.target) {
+      event.target = event.target || event.srcElement; 
+
+      if (event.type == 'mouseover') {
+        event.relatedTarget = event.fromElement;
+      }
+      if (event.type == 'mouseout') {
+        event.relatedTarget = event.toElement;
+      }
+      // Adding stopPropogation and preventDefault to IE
+      if (!event.stopPropagation){
+        event.stopPropagation = stopPropagation;
+        event.preventDefault = preventDefault;
+      }
+      // Normalize key events
+      switch(event.type){
+        case 'keypress':
+          var c = ('charCode' in event ? event.charCode : event.keyCode);
+          if (c == 10) {
+            c = 0;
+            event.keyCode = 13;
+          } else if (c == 13 || c == 27) {
+            c = 0; 
+          } else if (c == 3) {
+            c = 99; 
+          }
+          event.charCode = c;
+          event.keyChar = event.charCode ? String.fromCharCode(event.charCode) : '';
+          break;
+      }                    
+    }
+
+    return event;
+  }
+
+  function createListener (element, name, handler) {
+    // Node.js specific
+    if (element.addListener) {
+      element.addListener(name, handler);
+      return disposableCreate(function () {
+        element.removeListener(name, handler);
+      });
+    }
+    // Standards compliant
+    if (element.addEventListener) {
+      element.addEventListener(name, handler, false);
+      return disposableCreate(function () {
+        element.removeEventListener(name, handler, false);
+      });
+    } 
+    if (element.attachEvent) {
+      // IE Specific
+      var innerHandler = function (event) {
+        handler(fixEvent(event));
+      };
+      element.attachEvent('on' + name, innerHandler);
+      return disposableCreate(function () {
+        element.detachEvent('on' + name, innerHandler);
+      });         
+    }
+    // Level 1 DOM Events      
+    element['on' + name] = handler;
+    return disposableCreate(function () {
+      element['on' + name] = null;
+    });
+  }
+
+  function createEventListener (el, eventName, handler) {
+    var disposables = new CompositeDisposable();
+
+    // Asume NodeList
+    if (typeof el.item === 'function' && typeof el.length === 'number') {
+      for (var i = 0, len = el.length; i < len; i++) {
+        disposables.add(createEventListener(el.item(i), eventName, handler));
+      }
+    } else if (el) {
+      disposables.add(createListener(el, eventName, handler));
+    }
+
+    return disposables;
+  }
+
+  // Check for Angular/jQuery/Zepto support
+  var jq =
+   !!root.angular && !!angular.element ? angular.element :
+   (!!root.jQuery ? root.jQuery : (
+     !!root.Zepto ? root.Zepto : null));
+
+  // Check for ember
+  var ember = !!root.Ember && typeof root.Ember.addListener === 'function';
+
+  /**
+   * Creates an observable sequence by adding an event listener to the matching DOMElement or each item in the NodeList.
+   *
+   * @example
+   *   var source = Rx.Observable.fromEvent(element, 'mouseup');
+   * 
+   * @param {Object} element The DOMElement or NodeList to attach a listener.
+   * @param {String} eventName The event name to attach the observable sequence.
+   * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+   * @returns {Observable} An observable sequence of events from the specified element and the specified event.
+   */
+  Observable.fromEvent = function (element, eventName, selector) {
+    if (ember) {
+      return fromEventPattern(
+        function (h) { Ember.addListener(element, eventName); },
+        function (h) { Ember.removeListener(element, eventName); },
+        selector);
+    }    
+    if (jq) {
+      var $elem = jq(element);
+      return fromEventPattern(
+        function (h) { $elem.on(eventName, h); },
+        function (h) { $elem.off(eventName, h); },
+        selector);
+    }
+    return new AnonymousObservable(function (observer) {
+      return createEventListener(
+        element, 
+        eventName, 
+        function handler (e) { 
+          var results = e;
+
+          if (selector) {
+            try {
+              results = selector(arguments);
+            } catch (err) {
+              observer.onError(err);
+              return
+            }
+          }
+
+          observer.onNext(results); 
+        });
+    }).publish().refCount();
+  };
+  /**
+   * Creates an observable sequence from an event emitter via an addHandler/removeHandler pair.
+   * @param {Function} addHandler The function to add a handler to the emitter.
+   * @param {Function} [removeHandler] The optional function to remove a handler from an emitter.
+   * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
+   * @returns {Observable} An observable sequence which wraps an event from an event emitter
+   */
+  var fromEventPattern = Observable.fromEventPattern = function (addHandler, removeHandler, selector) {
+    return new AnonymousObservable(function (observer) {
+      function innerHandler (e) {
+        var result = e;
+        if (selector) {
+          try {
+            result = selector(arguments);
+          } catch (err) {
+            observer.onError(err);
+            return;
+          }
+        }
+        observer.onNext(result);
+      }
+
+      var returnValue = addHandler(innerHandler);
+      return disposableCreate(function () {
+        if (removeHandler) {
+          removeHandler(innerHandler, returnValue);
+        }
+      });
+    }).publish().refCount();
+  };
+
+  /**
+   * Invokes the asynchronous function, surfacing the result through an observable sequence.
+   * @param {Function} functionAsync Asynchronous function which returns a Promise to run.
+   * @returns {Observable} An observable sequence exposing the function's result value, or an exception.
+   */
+  Observable.startAsync = function (functionAsync) {
+    var promise;
+    try {
+      promise = functionAsync();
+    } catch (e) {
+      return observableThrow(e);
+    }
+    return observableFromPromise(promise);
+  }
+
+    return Rx;
+}));

js/libs/rxjs/rx.async.compat.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx.binding","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){function d(b){var c=function(){this.cancelBubble=!0},d=function(){if(this.bubbledKeyCode=this.keyCode,this.ctrlKey)try{this.keyCode=0}catch(a){}this.defaultPrevented=!0,this.returnValue=!1,this.modified=!0};if(b||(b=a.event),!b.target)switch(b.target=b.target||b.srcElement,"mouseover"==b.type&&(b.relatedTarget=b.fromElement),"mouseout"==b.type&&(b.relatedTarget=b.toElement),b.stopPropagation||(b.stopPropagation=c,b.preventDefault=d),b.type){case"keypress":var e="charCode"in b?b.charCode:b.keyCode;10==e?(e=0,b.keyCode=13):13==e||27==e?e=0:3==e&&(e=99),b.charCode=e,b.keyChar=b.charCode?String.fromCharCode(b.charCode):""}return b}function e(a,b,c){if(a.addListener)return a.addListener(b,c),l(function(){a.removeListener(b,c)});if(a.addEventListener)return a.addEventListener(b,c,!1),l(function(){a.removeEventListener(b,c,!1)});if(a.attachEvent){var e=function(a){c(d(a))};return a.attachEvent("on"+b,e),l(function(){a.detachEvent("on"+b,e)})}return a["on"+b]=c,l(function(){a["on"+b]=null})}function f(a,b,c){var d=new m;if("function"==typeof a.item&&"number"==typeof a.length)for(var g=0,h=a.length;h>g;g++)d.add(f(a.item(g),b,c));else a&&d.add(e(a,b,c));return d}var g=c.Observable,h=(g.prototype,g.fromPromise),i=g.throwException,j=c.AnonymousObservable,k=c.AsyncSubject,l=c.Disposable.create,m=c.CompositeDisposable,n=c.Scheduler.immediate,o=c.Scheduler.timeout,p=Array.prototype.slice;g.start=function(a,b,c){return q(a,b,c)()};var q=g.toAsync=function(a,b,c){return b||(b=o),function(){var d=arguments,e=new k;return b.schedule(function(){var b;try{b=a.apply(c,d)}catch(f){return e.onError(f),void 0}e.onNext(b),e.onCompleted()}),e.asObservable()}};g.fromCallback=function(a,b,c,d){return b||(b=n),function(){var e=p.call(arguments,0);return new j(function(f){return b.schedule(function(){function b(a){var b=a;if(d)try{b=d(arguments)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)})})}},g.fromNodeCallback=function(a,b,c,d){return b||(b=n),function(){var e=p.call(arguments,0);return new j(function(f){return b.schedule(function(){function b(a){if(a)return f.onError(a),void 0;var b=p.call(arguments,1);if(d)try{b=d(b)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)})})}};var r=a.angular&&angular.element?angular.element:a.jQuery?a.jQuery:a.Zepto?a.Zepto:null,s=!!a.Ember&&"function"==typeof a.Ember.addListener;g.fromEvent=function(a,b,c){if(s)return t(function(){Ember.addListener(a,b)},function(){Ember.removeListener(a,b)},c);if(r){var d=r(a);return t(function(a){d.on(b,a)},function(a){d.off(b,a)},c)}return new j(function(d){return f(a,b,function(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)})}).publish().refCount()};var t=g.fromEventPattern=function(a,b,c){return new j(function(d){function e(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)}var f=a(e);return l(function(){b&&b(e,f)})}).publish().refCount()};return g.startAsync=function(a){var b;try{b=a()}catch(c){return i(c)}return h(b)},c});

js/libs/rxjs/rx.async.js

@@ -0,0 +1,328 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx.binding', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    // Aliases
+    var Observable = Rx.Observable,
+    	observableProto = Observable.prototype,
+      observableFromPromise = Observable.fromPromise,
+      observableThrow = Observable.throwException,
+      AnonymousObservable = Rx.AnonymousObservable,
+      AsyncSubject = Rx.AsyncSubject,
+      disposableCreate = Rx.Disposable.create,
+      CompositeDisposable= Rx.CompositeDisposable,
+      immediateScheduler = Rx.Scheduler.immediate,
+      timeoutScheduler = Rx.Scheduler.timeout,
+      slice = Array.prototype.slice;
+
+    /**
+     * Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence.
+     * 
+     * @example
+     * var res = Rx.Observable.start(function () { console.log('hello'); });
+     * var res = Rx.Observable.start(function () { console.log('hello'); }, Rx.Scheduler.timeout);
+     * var res = Rx.Observable.start(function () { this.log('hello'); }, Rx.Scheduler.timeout, console);
+     * 
+     * @param {Function} func Function to run asynchronously.
+     * @param {Scheduler} [scheduler]  Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param [context]  The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Observable} An observable sequence exposing the function's result value, or an exception.
+     * 
+     * Remarks
+     * * The function is called immediately, not during the subscription of the resulting sequence.
+     * * Multiple subscriptions to the resulting sequence can observe the function's result.  
+     */
+    Observable.start = function (func, scheduler, context) {
+        return observableToAsync(func, scheduler, context)();
+    };
+
+    /**
+     * Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.
+     * 
+     * @example
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; })(4, 3);
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; }, Rx.Scheduler.timeout)(4, 3);
+     * var res = Rx.Observable.toAsync(function (x) { this.log(x); }, Rx.Scheduler.timeout, console)('hello');
+     * 
+     * @param {Function} function Function to convert to an asynchronous function.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Function} Asynchronous function.
+     */
+    var observableToAsync = Observable.toAsync = function (func, scheduler, context) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = arguments, 
+                subject = new AsyncSubject();
+
+            scheduler.schedule(function () {
+                var result;
+                try {
+                    result = func.apply(context, args);
+                } catch (e) {
+                    subject.onError(e);
+                    return;
+                }
+                subject.onNext(result);
+                subject.onCompleted();
+            });
+            return subject.asObservable();
+        };
+    };
+
+    /**
+     * Converts a callback function to an observable sequence. 
+     * 
+     * @param {Function} function Function with a callback as the last parameter to convert to an Observable sequence.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback to produce a single item to yield on next.
+     * @returns {Function} A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array.
+     */
+    Observable.fromCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = immediateScheduler);
+        return function () {
+            var args = slice.call(arguments, 0);
+
+            return new AnonymousObservable(function (observer) {
+                return scheduler.schedule(function () {
+                    function handler(e) {
+                        var results = e;
+                        
+                        if (selector) {
+                            try {
+                                results = selector(arguments);
+                            } catch (err) {
+                                observer.onError(err);
+                                return;
+                            }
+                        } else {
+                            if (results.length === 1) {
+                                results = results[0];
+                            }
+                        }
+
+                        observer.onNext(results);
+                        observer.onCompleted();
+                    }
+
+                    args.push(handler);
+                    func.apply(context, args);
+                });
+            });
+        };
+    };
+
+    /**
+     * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
+     * @param {Function} func The function to call
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback minus the error to produce a single item to yield on next.     
+     * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
+     */
+    Observable.fromNodeCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = immediateScheduler);
+        return function () {
+            var args = slice.call(arguments, 0);
+
+            return new AnonymousObservable(function (observer) {
+                return scheduler.schedule(function () {
+                    
+                    function handler(err) {
+                        if (err) {
+                            observer.onError(err);
+                            return;
+                        }
+
+                        var results = slice.call(arguments, 1);
+                        
+                        if (selector) {
+                            try {
+                                results = selector(results);
+                            } catch (e) {
+                                observer.onError(e);
+                                return;
+                            }
+                        } else {
+                            if (results.length === 1) {
+                                results = results[0];
+                            }
+                        }
+
+                        observer.onNext(results);
+                        observer.onCompleted();
+                    }
+
+                    args.push(handler);
+                    func.apply(context, args);
+                });
+            });
+        };
+    };
+
+  function createListener (element, name, handler) {
+    // Node.js specific
+    if (element.addListener) {
+      element.addListener(name, handler);
+      return disposableCreate(function () {
+        element.removeListener(name, handler);
+      });
+    } 
+    if (element.addEventListener) {
+      element.addEventListener(name, handler, false);
+      return disposableCreate(function () {
+        element.removeEventListener(name, handler, false);
+      });
+    }
+    throw new Error('No listener found');
+  }
+
+  function createEventListener (el, eventName, handler) {
+    var disposables = new CompositeDisposable();
+
+    // Asume NodeList
+    if (typeof el.item === 'function' && typeof el.length === 'number') {
+      for (var i = 0, len = el.length; i < len; i++) {
+        disposables.add(createEventListener(el.item(i), eventName, handler));
+      }
+    } else if (el) {
+      disposables.add(createListener(el, eventName, handler));
+    }
+
+    return disposables;
+  }
+
+  // Check for Angular/jQuery/Zepto support
+  var jq =
+   !!root.angular && !!angular.element ? angular.element :
+   (!!root.jQuery ? root.jQuery : (
+     !!root.Zepto ? root.Zepto : null));
+
+  // Check for ember
+  var ember = !!root.Ember && typeof root.Ember.addListener === 'function';
+
+  /**
+   * Creates an observable sequence by adding an event listener to the matching DOMElement or each item in the NodeList.
+   *
+   * @example
+   *   var source = Rx.Observable.fromEvent(element, 'mouseup');
+   * 
+   * @param {Object} element The DOMElement or NodeList to attach a listener.
+   * @param {String} eventName The event name to attach the observable sequence.
+   * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+   * @returns {Observable} An observable sequence of events from the specified element and the specified event.
+   */
+  Observable.fromEvent = function (element, eventName, selector) {
+    if (ember) {
+      return fromEventPattern(
+        function (h) { Ember.addListener(element, eventName); },
+        function (h) { Ember.removeListener(element, eventName); },
+        selector);
+    }    
+    if (jq) {
+      var $elem = jq(element);
+      return fromEventPattern(
+        function (h) { $elem.on(eventName, h); },
+        function (h) { $elem.off(eventName, h); },
+        selector);
+    }
+    return new AnonymousObservable(function (observer) {
+      return createEventListener(
+        element, 
+        eventName, 
+        function handler (e) { 
+          var results = e;
+
+          if (selector) {
+            try {
+              results = selector(arguments);
+            } catch (err) {
+              observer.onError(err);
+              return
+            }
+          }
+
+          observer.onNext(results); 
+        });
+    }).publish().refCount();
+  };
+  /**
+   * Creates an observable sequence from an event emitter via an addHandler/removeHandler pair.
+   * @param {Function} addHandler The function to add a handler to the emitter.
+   * @param {Function} [removeHandler] The optional function to remove a handler from an emitter.
+   * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
+   * @returns {Observable} An observable sequence which wraps an event from an event emitter
+   */
+  var fromEventPattern = Observable.fromEventPattern = function (addHandler, removeHandler, selector) {
+    return new AnonymousObservable(function (observer) {
+      function innerHandler (e) {
+        var result = e;
+        if (selector) {
+          try {
+            result = selector(arguments);
+          } catch (err) {
+            observer.onError(err);
+            return;
+          }
+        }
+        observer.onNext(result);
+      }
+
+      var returnValue = addHandler(innerHandler);
+      return disposableCreate(function () {
+        if (removeHandler) {
+          removeHandler(innerHandler, returnValue);
+        }
+      });
+    }).publish().refCount();
+  };
+
+  /**
+   * Invokes the asynchronous function, surfacing the result through an observable sequence.
+   * @param {Function} functionAsync Asynchronous function which returns a Promise to run.
+   * @returns {Observable} An observable sequence exposing the function's result value, or an exception.
+   */
+  Observable.startAsync = function (functionAsync) {
+    var promise;
+    try {
+      promise = functionAsync();
+    } catch (e) {
+      return observableThrow(e);
+    }
+    return observableFromPromise(promise);
+  }
+
+    return Rx;
+}));

js/libs/rxjs/rx.async.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx.binding","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){function d(a,b,c){if(a.addListener)return a.addListener(b,c),k(function(){a.removeListener(b,c)});if(a.addEventListener)return a.addEventListener(b,c,!1),k(function(){a.removeEventListener(b,c,!1)});throw new Error("No listener found")}function e(a,b,c){var f=new l;if("function"==typeof a.item&&"number"==typeof a.length)for(var g=0,h=a.length;h>g;g++)f.add(e(a.item(g),b,c));else a&&f.add(d(a,b,c));return f}var f=c.Observable,g=(f.prototype,f.fromPromise),h=f.throwException,i=c.AnonymousObservable,j=c.AsyncSubject,k=c.Disposable.create,l=c.CompositeDisposable,m=c.Scheduler.immediate,n=c.Scheduler.timeout,o=Array.prototype.slice;f.start=function(a,b,c){return p(a,b,c)()};var p=f.toAsync=function(a,b,c){return b||(b=n),function(){var d=arguments,e=new j;return b.schedule(function(){var b;try{b=a.apply(c,d)}catch(f){return e.onError(f),void 0}e.onNext(b),e.onCompleted()}),e.asObservable()}};f.fromCallback=function(a,b,c,d){return b||(b=m),function(){var e=o.call(arguments,0);return new i(function(f){return b.schedule(function(){function b(a){var b=a;if(d)try{b=d(arguments)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)})})}},f.fromNodeCallback=function(a,b,c,d){return b||(b=m),function(){var e=o.call(arguments,0);return new i(function(f){return b.schedule(function(){function b(a){if(a)return f.onError(a),void 0;var b=o.call(arguments,1);if(d)try{b=d(b)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)})})}};var q=a.angular&&angular.element?angular.element:a.jQuery?a.jQuery:a.Zepto?a.Zepto:null,r=!!a.Ember&&"function"==typeof a.Ember.addListener;f.fromEvent=function(a,b,c){if(r)return s(function(){Ember.addListener(a,b)},function(){Ember.removeListener(a,b)},c);if(q){var d=q(a);return s(function(a){d.on(b,a)},function(a){d.off(b,a)},c)}return new i(function(d){return e(a,b,function(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)})}).publish().refCount()};var s=f.fromEventPattern=function(a,b,c){return new i(function(d){function e(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)}var f=a(e);return k(function(){b&&b(e,f)})}).publish().refCount()};return f.startAsync=function(a){var b;try{b=a()}catch(c){return h(c)}return g(b)},c});

js/libs/rxjs/rx.backpressure.js

@@ -0,0 +1,398 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+  // References
+  var Observable = Rx.Observable,
+    observableProto = Observable.prototype,
+    AnonymousObservable = Rx.AnonymousObservable,
+    CompositeDisposable = Rx.CompositeDisposable,
+    Subject = Rx.Subject,
+    Observer = Rx.Observer,
+    disposableEmpty = Rx.Disposable.empty,
+    disposableCreate = Rx.Disposable.create,
+    inherits = Rx.internals.inherits,
+    addProperties = Rx.internals.addProperties,  
+    timeoutScheduler = Rx.Scheduler.timeout,
+    identity = Rx.helpers.identity;
+
+  var objectDisposed = 'Object has been disposed';
+  function checkDisposed() { if (this.isDisposed) { throw new Error(objectDisposed); } }
+
+  var PausableObservable = (function (_super) {
+
+    inherits(PausableObservable, _super);
+
+    function subscribe(observer) {
+      var conn = this.source.publish(),
+        subscription = conn.subscribe(observer),
+        connection = disposableEmpty;
+
+      var pausable = this.subject.distinctUntilChanged().subscribe(function (b) {
+        if (b) {
+          connection = conn.connect();
+        } else {
+          connection.dispose();
+          connection = disposableEmpty;
+        }
+      });
+
+      return new CompositeDisposable(subscription, connection, pausable);
+    }
+
+    function PausableObservable(source, subject) {
+      this.source = source;
+      this.subject = subject || new Subject();
+      this.isPaused = true;
+      _super.call(this, subscribe);
+    }
+
+    PausableObservable.prototype.pause = function () {
+      if (this.isPaused === true){
+        return;
+      }
+      this.isPaused = true;
+      this.subject.onNext(false);
+    };
+
+    PausableObservable.prototype.resume = function () {
+      if (this.isPaused === false){
+        return;
+      }
+      this.isPaused = false;
+      this.subject.onNext(true);
+    };
+
+    return PausableObservable;
+
+  }(Observable));
+
+  /**
+   * Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
+   * @example
+   * var pauser = new Rx.Subject();
+   * var source = Rx.Observable.interval(100).pausable(pauser);
+   * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
+   * @returns {Observable} The observable sequence which is paused based upon the pauser.
+   */
+  observableProto.pausable = function (pauser) {
+    return new PausableObservable(this, pauser);
+  };
+  function combineLatestSource(source, subject, resultSelector) {
+    return new AnonymousObservable(function (observer) {
+      var n = 2,
+        hasValue = [false, false],
+        hasValueAll = false,
+        isDone = false,
+        values = new Array(n);
+
+      function next(x, i) {
+        values[i] = x
+        var res;
+        hasValue[i] = true;
+        if (hasValueAll || (hasValueAll = hasValue.every(identity))) {
+            try {
+                res = resultSelector.apply(null, values);
+            } catch (ex) {
+                observer.onError(ex);
+                return;
+            }
+            observer.onNext(res);
+        } else if (isDone) {
+            observer.onCompleted();
+        }
+      }
+
+      return new CompositeDisposable(
+        source.subscribe(
+          function (x) {
+            next(x, 0);
+          },
+          observer.onError.bind(observer),
+          function () {
+            isDone = true;
+            observer.onCompleted();
+          }),
+        subject.subscribe(
+          function (x) {
+            next(x, 1);
+          },
+          observer.onError.bind(observer))
+        );
+    });
+  }
+
+  var PausableBufferedObservable = (function (_super) {
+
+    inherits(PausableBufferedObservable, _super);
+
+    function subscribe(observer) {
+      var q = [], previous = true;
+      
+      var subscription =  
+        combineLatestSource(
+          this.source,
+          this.subject.distinctUntilChanged(), 
+          function (data, shouldFire) {
+            return { data: data, shouldFire: shouldFire };      
+          })
+          .subscribe(
+            function (results) {
+              if (results.shouldFire && previous) {
+                observer.onNext(results.data);
+              }
+              if (results.shouldFire && !previous) {
+                while (q.length > 0) {
+                  observer.onNext(q.shift());
+                }
+                previous = true;
+              } else if (!results.shouldFire && !previous) {
+                q.push(results.data);
+              } else if (!results.shouldFire && previous) {
+                previous = false;
+              }
+
+            }, 
+            observer.onError.bind(observer),
+            observer.onCompleted.bind(observer)
+          );
+
+      this.subject.onNext(false);
+
+      return subscription;      
+    }
+
+    function PausableBufferedObservable(source, subject) {
+      this.source = source;
+      this.subject = subject || new Subject();
+      this.isPaused = true;
+      _super.call(this, subscribe);
+    }
+
+    PausableBufferedObservable.prototype.pause = function () {
+      if (this.isPaused === true){
+        return;
+      }
+      this.isPaused = true;
+      this.subject.onNext(false);
+    };
+
+    PausableBufferedObservable.prototype.resume = function () {
+      if (this.isPaused === false){
+        return;
+      }
+      this.isPaused = false;
+      this.subject.onNext(true);
+    };
+
+    return PausableBufferedObservable; 
+
+  }(Observable));
+
+  /**
+   * Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
+   * and yields the values that were buffered while paused.
+   * @example
+   * var pauser = new Rx.Subject();
+   * var source = Rx.Observable.interval(100).pausableBuffered(pauser);
+   * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
+   * @returns {Observable} The observable sequence which is paused based upon the pauser.
+   */  
+  observableProto.pausableBuffered = function (subject) {
+    return new PausableBufferedObservable(this, subject);
+  };
+
+  /**
+   * Attaches a controller to the observable sequence with the ability to queue.
+   * @example
+   * var source = Rx.Observable.interval(100).controlled();
+   * source.request(3); // Reads 3 values
+   * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
+   * @returns {Observable} The observable sequence which is paused based upon the pauser.
+   */ 
+  observableProto.controlled = function (enableQueue) {
+    if (enableQueue == null) {  enableQueue = true; }
+    return new ControlledObservable(this, enableQueue);
+  };
+  var ControlledObservable = (function (_super) {
+
+    inherits(ControlledObservable, _super);
+
+    function subscribe (observer) {
+      return this.source.subscribe(observer);
+    }
+
+    function ControlledObservable (source, enableQueue) {
+      _super.call(this, subscribe);
+      this.subject = new ControlledSubject(enableQueue);
+      this.source = source.multicast(this.subject).refCount();
+    }
+
+    ControlledObservable.prototype.request = function (numberOfItems) {
+      if (numberOfItems == null) { numberOfItems = -1; }
+      return this.subject.request(numberOfItems);
+    };
+
+    return ControlledObservable;
+
+  }(Observable));
+
+    var ControlledSubject = Rx.ControlledSubject = (function (_super) {
+
+        function subscribe (observer) {
+            return this.subject.subscribe(observer);
+        }
+
+        inherits(ControlledSubject, _super);
+
+        function ControlledSubject(enableQueue) {
+            if (enableQueue == null) {
+                enableQueue = true;
+            }
+
+            _super.call(this, subscribe);
+            this.subject = new Subject();
+            this.enableQueue = enableQueue;
+            this.queue = enableQueue ? [] : null;
+            this.requestedCount = 0;
+            this.requestedDisposable = disposableEmpty;
+            this.error = null;
+            this.hasFailed = false;
+            this.hasCompleted = false;
+            this.controlledDisposable = disposableEmpty;
+        }
+
+        addProperties(ControlledSubject.prototype, Observer, {
+            onCompleted: function () {
+                checkDisposed.call(this);
+                this.hasCompleted = true;
+
+                if (!this.enableQueue || this.queue.length === 0) {
+                    this.subject.onCompleted();
+                }
+            },
+            onError: function (error) {
+                checkDisposed.call(this);
+                this.hasFailed = true;
+                this.error = error;
+
+                if (!this.enableQueue || this.queue.length === 0) {
+                    this.subject.onError(error);
+                }   
+            },
+            onNext: function (value) {
+                checkDisposed.call(this);
+                var hasRequested = false;
+
+                if (this.requestedCount === 0) {
+                    if (this.enableQueue) {
+                        this.queue.push(value);
+                    }
+                } else {
+                    if (this.requestedCount !== -1) {
+                        if (this.requestedCount-- === 0) {
+                            this.disposeCurrentRequest();
+                        }
+                    }
+                    hasRequested = true;
+                }
+
+                if (hasRequested) {
+                    this.subject.onNext(value);
+                }
+            },
+            _processRequest: function (numberOfItems) {
+                if (this.enableQueue) {
+                    //console.log('queue length', this.queue.length);
+
+                    while (this.queue.length >= numberOfItems && numberOfItems > 0) {
+                        //console.log('number of items', numberOfItems);
+                        this.subject.onNext(this.queue.shift());
+                        numberOfItems--;
+                    }
+
+                    if (this.queue.length !== 0) {
+                        return { numberOfItems: numberOfItems, returnValue: true };
+                    } else {
+                        return { numberOfItems: numberOfItems, returnValue: false };
+                    }
+                }
+
+                if (this.hasFailed) {
+                    this.subject.onError(this.error);
+                    this.controlledDisposable.dispose();
+                    this.controlledDisposable = disposableEmpty;
+                } else if (this.hasCompleted) {
+                    this.subject.onCompleted();
+                    this.controlledDisposable.dispose();
+                    this.controlledDisposable = disposableEmpty;                   
+                }
+
+                return { numberOfItems: numberOfItems, returnValue: false };
+            },
+            request: function (number) {
+                checkDisposed.call(this);
+                this.disposeCurrentRequest();
+                var self = this,
+                    r = this._processRequest(number);
+
+                number = r.numberOfItems;
+                if (!r.returnValue) {
+                    this.requestedCount = number;
+                    this.requestedDisposable = disposableCreate(function () {
+                        self.requestedCount = 0;
+                    });
+
+                    return this.requestedDisposable
+                } else {
+                    return disposableEmpty;
+                }
+            },
+            disposeCurrentRequest: function () {
+                this.requestedDisposable.dispose();
+                this.requestedDisposable = disposableEmpty;
+            },
+
+            dispose: function () {
+                this.isDisposed = true;
+                this.error = null;
+                this.subject.dispose();
+                this.requestedDisposable.dispose();
+            }
+        });
+
+        return ControlledSubject;
+    }(Observable));
+    return Rx;
+}));

js/libs/rxjs/rx.backpressure.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){function d(){if(this.isDisposed)throw new Error(q)}function e(a,b,c){return new h(function(d){function e(a,b){k[b]=a;var e;if(g[b]=!0,h||(h=g.every(p))){try{e=c.apply(null,k)}catch(f){return d.onError(f),void 0}d.onNext(e)}else j&&d.onCompleted()}var f=2,g=[!1,!1],h=!1,j=!1,k=new Array(f);return new i(a.subscribe(function(a){e(a,0)},d.onError.bind(d),function(){j=!0,d.onCompleted()}),b.subscribe(function(a){e(a,1)},d.onError.bind(d)))})}var f=c.Observable,g=f.prototype,h=c.AnonymousObservable,i=c.CompositeDisposable,j=c.Subject,k=c.Observer,l=c.Disposable.empty,m=c.Disposable.create,n=c.internals.inherits,o=c.internals.addProperties,p=(c.Scheduler.timeout,c.helpers.identity),q="Object has been disposed",r=function(a){function b(a){var b=this.source.publish(),c=b.subscribe(a),d=l,e=this.subject.distinctUntilChanged().subscribe(function(a){a?d=b.connect():(d.dispose(),d=l)});return new i(c,d,e)}function c(c,d){this.source=c,this.subject=d||new j,this.isPaused=!0,a.call(this,b)}return n(c,a),c.prototype.pause=function(){this.isPaused!==!0&&(this.isPaused=!0,this.subject.onNext(!1))},c.prototype.resume=function(){this.isPaused!==!1&&(this.isPaused=!1,this.subject.onNext(!0))},c}(f);g.pausable=function(a){return new r(this,a)};var s=function(a){function b(a){var b=[],c=!0,d=e(this.source,this.subject.distinctUntilChanged(),function(a,b){return{data:a,shouldFire:b}}).subscribe(function(d){if(d.shouldFire&&c&&a.onNext(d.data),d.shouldFire&&!c){for(;b.length>0;)a.onNext(b.shift());c=!0}else d.shouldFire||c?!d.shouldFire&&c&&(c=!1):b.push(d.data)},a.onError.bind(a),a.onCompleted.bind(a));return this.subject.onNext(!1),d}function c(c,d){this.source=c,this.subject=d||new j,this.isPaused=!0,a.call(this,b)}return n(c,a),c.prototype.pause=function(){this.isPaused!==!0&&(this.isPaused=!0,this.subject.onNext(!1))},c.prototype.resume=function(){this.isPaused!==!1&&(this.isPaused=!1,this.subject.onNext(!0))},c}(f);g.pausableBuffered=function(a){return new s(this,a)},g.controlled=function(a){return null==a&&(a=!0),new t(this,a)};var t=function(a){function b(a){return this.source.subscribe(a)}function c(c,d){a.call(this,b),this.subject=new u(d),this.source=c.multicast(this.subject).refCount()}return n(c,a),c.prototype.request=function(a){return null==a&&(a=-1),this.subject.request(a)},c}(f),u=c.ControlledSubject=function(a){function b(a){return this.subject.subscribe(a)}function c(c){null==c&&(c=!0),a.call(this,b),this.subject=new j,this.enableQueue=c,this.queue=c?[]:null,this.requestedCount=0,this.requestedDisposable=l,this.error=null,this.hasFailed=!1,this.hasCompleted=!1,this.controlledDisposable=l}return n(c,a),o(c.prototype,k,{onCompleted:function(){d.call(this),this.hasCompleted=!0,this.enableQueue&&0!==this.queue.length||this.subject.onCompleted()},onError:function(a){d.call(this),this.hasFailed=!0,this.error=a,this.enableQueue&&0!==this.queue.length||this.subject.onError(a)},onNext:function(a){d.call(this);var b=!1;0===this.requestedCount?this.enableQueue&&this.queue.push(a):(-1!==this.requestedCount&&0===this.requestedCount--&&this.disposeCurrentRequest(),b=!0),b&&this.subject.onNext(a)},_processRequest:function(a){if(this.enableQueue){for(;this.queue.length>=a&&a>0;)this.subject.onNext(this.queue.shift()),a--;return 0!==this.queue.length?{numberOfItems:a,returnValue:!0}:{numberOfItems:a,returnValue:!1}}return this.hasFailed?(this.subject.onError(this.error),this.controlledDisposable.dispose(),this.controlledDisposable=l):this.hasCompleted&&(this.subject.onCompleted(),this.controlledDisposable.dispose(),this.controlledDisposable=l),{numberOfItems:a,returnValue:!1}},request:function(a){d.call(this),this.disposeCurrentRequest();var b=this,c=this._processRequest(a);return a=c.numberOfItems,c.returnValue?l:(this.requestedCount=a,this.requestedDisposable=m(function(){b.requestedCount=0}),this.requestedDisposable)},disposeCurrentRequest:function(){this.requestedDisposable.dispose(),this.requestedDisposable=l},dispose:function(){this.isDisposed=!0,this.error=null,this.subject.dispose(),this.requestedDisposable.dispose()}}),c}(f);return c});

js/libs/rxjs/rx.binding.js

@@ -0,0 +1,561 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    var Observable = Rx.Observable,
+        observableProto = Observable.prototype,
+        AnonymousObservable = Rx.AnonymousObservable,
+        Subject = Rx.Subject,
+        AsyncSubject = Rx.AsyncSubject,
+        Observer = Rx.Observer,
+        ScheduledObserver = Rx.internals.ScheduledObserver,
+        disposableCreate = Rx.Disposable.create,
+        disposableEmpty = Rx.Disposable.empty,
+        CompositeDisposable = Rx.CompositeDisposable,
+        currentThreadScheduler = Rx.Scheduler.currentThread,
+        inherits = Rx.internals.inherits,
+        addProperties = Rx.internals.addProperties;
+
+    // Utilities
+    var objectDisposed = 'Object has been disposed';
+    function checkDisposed() {
+        if (this.isDisposed) {
+            throw new Error(objectDisposed);
+        }
+    }
+
+    /**
+     * Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each
+     * subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's
+     * invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.
+     * 
+     * @example
+     * 1 - res = source.multicast(observable);
+     * 2 - res = source.multicast(function () { return new Subject(); }, function (x) { return x; });
+     * 
+     * @param {Function|Subject} subjectOrSubjectSelector 
+     * Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function.
+     * Or:
+     * Subject to push source elements into.
+     * 
+     * @param {Function} [selector] Optional selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. Specified only if <paramref name="subjectOrSubjectSelector" is a factory function.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.multicast = function (subjectOrSubjectSelector, selector) {
+        var source = this;
+        return typeof subjectOrSubjectSelector === 'function' ?
+            new AnonymousObservable(function (observer) {
+                var connectable = source.multicast(subjectOrSubjectSelector());
+                return new CompositeDisposable(selector(connectable).subscribe(observer), connectable.connect());
+            }) :
+            new ConnectableObservable(source, subjectOrSubjectSelector);
+    };
+
+    /**
+     * Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.
+     * This operator is a specialization of Multicast using a regular Subject.
+     * 
+     * @example
+     * var resres = source.publish();
+     * var res = source.publish(function (x) { return x; });
+     * 
+     * @param {Function} [selector] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.publish = function (selector) {
+        return !selector ?
+            this.multicast(new Subject()) :
+            this.multicast(function () {
+                return new Subject();
+            }, selector);
+    };
+
+    /**
+     * Returns an observable sequence that shares a single subscription to the underlying sequence.
+     * This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+     * 
+     * @example
+     * var res = source.share();
+     * 
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+     */
+    observableProto.share = function () {
+        return this.publish(null).refCount();
+    };
+
+    /**
+     * Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
+     * This operator is a specialization of Multicast using a AsyncSubject.
+     * 
+     * @example
+     * var res = source.publishLast();
+     * var res = source.publishLast(function (x) { return x; });
+     * 
+     * @param selector [Optional] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.publishLast = function (selector) {
+        return !selector ?
+            this.multicast(new AsyncSubject()) :
+            this.multicast(function () {
+                return new AsyncSubject();
+            }, selector);
+    };
+
+    /**
+     * Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
+     * This operator is a specialization of Multicast using a BehaviorSubject.
+     * 
+     * @example
+     * var res = source.publishValue(42);
+     * var res = source.publishValue(function (x) { return x.select(function (y) { return y * y; }) }, 42);
+     * 
+     * @param {Function} [selector] Optional selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on.
+     * @param {Mixed} initialValue Initial value received by observers upon subscription.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.publishValue = function (initialValueOrSelector, initialValue) {
+        return arguments.length === 2 ?
+            this.multicast(function () {
+                return new BehaviorSubject(initialValue);
+            }, initialValueOrSelector) :
+            this.multicast(new BehaviorSubject(initialValueOrSelector));
+    };
+
+    /**
+     * Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
+     * This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+     * 
+     * @example
+     * var res = source.shareValue(42);
+     * 
+     * @param {Mixed} initialValue Initial value received by observers upon subscription.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+     */
+    observableProto.shareValue = function (initialValue) {
+        return this.publishValue(initialValue).
+            refCount();
+    };
+
+    /**
+     * Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
+     * This operator is a specialization of Multicast using a ReplaySubject.
+     * 
+     * @example
+     * var res = source.replay(null, 3);
+     * var res = source.replay(null, 3, 500);
+     * var res = source.replay(null, 3, 500, scheduler);
+     * var res = source.replay(function (x) { return x.take(6).repeat(); }, 3, 500, scheduler);
+     * 
+     * @param selector [Optional] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy.
+     * @param bufferSize [Optional] Maximum element count of the replay buffer.
+     * @param window [Optional] Maximum time length of the replay buffer.
+     * @param scheduler [Optional] Scheduler where connected observers within the selector function will be invoked on.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.replay = function (selector, bufferSize, window, scheduler) {
+        return !selector ?
+            this.multicast(new ReplaySubject(bufferSize, window, scheduler)) :
+            this.multicast(function () {
+                return new ReplaySubject(bufferSize, window, scheduler);
+            }, selector);
+    };
+
+    /**
+     * Returns an observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
+     * This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+     * 
+     * @example
+     * var res = source.replayWhileObserved(3);
+     * var res = source.replayWhileObserved(3, 500);
+     * var res = source.replayWhileObserved(3, 500, scheduler);
+     * 
+
+     * @param bufferSize [Optional] Maximum element count of the replay buffer.
+     * @param window [Optional] Maximum time length of the replay buffer.
+     * @param scheduler [Optional] Scheduler where connected observers within the selector function will be invoked on.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+     */
+    observableProto.replayWhileObserved = function (bufferSize, window, scheduler) {
+        return this.replay(null, bufferSize, window, scheduler).refCount();
+    };
+
+    /** @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 a value that changes over time.
+     *  Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications.
+     */
+    var BehaviorSubject = Rx.BehaviorSubject = (function (_super) {
+        function subscribe(observer) {
+            checkDisposed.call(this);
+            if (!this.isStopped) {
+                this.observers.push(observer);
+                observer.onNext(this.value);
+                return new InnerSubscription(this, observer);
+            }
+            var ex = this.exception;
+            if (ex) {
+                observer.onError(ex);
+            } else {
+                observer.onCompleted();
+            }
+            return disposableEmpty;
+        }
+
+        inherits(BehaviorSubject, _super);
+
+        /**
+         * @constructor
+         *  Initializes a new instance of the BehaviorSubject class which creates a subject that caches its last value and starts with the specified value.
+         *  @param {Mixed} value Initial value sent to observers when no other value has been received by the subject yet.
+         */       
+        function BehaviorSubject(value) {
+            _super.call(this, subscribe);
+
+            this.value = value,
+            this.observers = [],
+            this.isDisposed = false,
+            this.isStopped = false,
+            this.exception = null;
+        }
+
+        addProperties(BehaviorSubject.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 (error) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    this.exception = error;
+
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onError(error);
+                    }
+
+                    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) {
+                    this.value = value;
+                    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;
+                this.value = null;
+                this.exception = null;
+            }
+        });
+
+        return BehaviorSubject;
+    }(Observable));
+
+    /**
+     * Represents an object that is both an observable sequence as well as an observer.
+     * Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies.
+     */  
+    var ReplaySubject = Rx.ReplaySubject = (function (_super) {
+
+        function RemovableDisposable (subject, observer) {
+            this.subject = subject;
+            this.observer = observer;
+        };
+
+        RemovableDisposable.prototype.dispose = function () {
+            this.observer.dispose();
+            if (!this.subject.isDisposed) {
+                var idx = this.subject.observers.indexOf(this.observer);
+                this.subject.observers.splice(idx, 1);
+            }
+        };
+
+        function subscribe(observer) {
+            var so = new ScheduledObserver(this.scheduler, observer),
+                subscription = new RemovableDisposable(this, so);
+            checkDisposed.call(this);
+            this._trim(this.scheduler.now());
+            this.observers.push(so);
+
+            var n = this.q.length;
+
+            for (var i = 0, len = this.q.length; i < len; i++) {
+                so.onNext(this.q[i].value);
+            }
+
+            if (this.hasError) {
+                n++;
+                so.onError(this.error);
+            } else if (this.isStopped) {
+                n++;
+                so.onCompleted();
+            }
+
+            so.ensureActive(n);
+            return subscription;
+        }
+
+        inherits(ReplaySubject, _super);
+
+        /**
+         *  Initializes a new instance of the ReplaySubject class with the specified buffer size, window size and scheduler.
+         *  @param {Number} [bufferSize] Maximum element count of the replay buffer.
+         *  @param {Number} [windowSize] Maximum time length of the replay buffer.
+         *  @param {Scheduler} [scheduler] Scheduler the observers are invoked on.
+         */
+        function ReplaySubject(bufferSize, windowSize, scheduler) {
+            this.bufferSize = bufferSize == null ? Number.MAX_VALUE : bufferSize;
+            this.windowSize = windowSize == null ? Number.MAX_VALUE : windowSize;
+            this.scheduler = scheduler || currentThreadScheduler;
+            this.q = [];
+            this.observers = [];
+            this.isStopped = false;
+            this.isDisposed = false;
+            this.hasError = false;
+            this.error = null;
+            _super.call(this, subscribe);
+        }
+
+        addProperties(ReplaySubject.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;
+            },            
+            /* @private  */
+            _trim: function (now) {
+                while (this.q.length > this.bufferSize) {
+                    this.q.shift();
+                }
+                while (this.q.length > 0 && (now - this.q[0].interval) > this.windowSize) {
+                    this.q.shift();
+                }
+            },
+            /**
+             * 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) {
+                var observer;
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var now = this.scheduler.now();
+                    this.q.push({ interval: now, value: value });
+                    this._trim(now);
+
+                    var o = this.observers.slice(0);
+                    for (var i = 0, len = o.length; i < len; i++) {
+                        observer = o[i];
+                        observer.onNext(value);
+                        observer.ensureActive();
+                    }
+                }
+            },
+            /**
+             * Notifies all subscribed observers about the exception.
+             * @param {Mixed} error The exception to send to all observers.
+             */                 
+            onError: function (error) {
+                var observer;
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    this.isStopped = true;
+                    this.error = error;
+                    this.hasError = true;
+                    var now = this.scheduler.now();
+                    this._trim(now);
+                    var o = this.observers.slice(0);
+                    for (var i = 0, len = o.length; i < len; i++) {
+                        observer = o[i];
+                        observer.onError(error);
+                        observer.ensureActive();
+                    }
+                    this.observers = [];
+                }
+            },
+            /**
+             * Notifies all subscribed observers about the end of the sequence.
+             */             
+            onCompleted: function () {
+                var observer;
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    this.isStopped = true;
+                    var now = this.scheduler.now();
+                    this._trim(now);
+                    var o = this.observers.slice(0);
+                    for (var i = 0, len = o.length; i < len; i++) {
+                        observer = o[i];
+                        observer.onCompleted();
+                        observer.ensureActive();
+                    }
+                    this.observers = [];
+                }
+            },
+            /**
+             * Unsubscribe all observers and release resources.
+             */               
+            dispose: function () {
+                this.isDisposed = true;
+                this.observers = null;
+            }
+        });
+
+        return ReplaySubject;
+    }(Observable));
+
+    /** @private */
+    var ConnectableObservable = Rx.ConnectableObservable = (function (_super) {
+        inherits(ConnectableObservable, _super);
+
+        /**
+         * @constructor
+         * @private
+         */
+        function ConnectableObservable(source, subject) {
+            var state = {
+                subject: subject,
+                source: source.asObservable(),
+                hasSubscription: false,
+                subscription: null
+            };
+
+            this.connect = function () {
+                if (!state.hasSubscription) {
+                    state.hasSubscription = true;
+                    state.subscription = new CompositeDisposable(state.source.subscribe(state.subject), disposableCreate(function () {
+                        state.hasSubscription = false;
+                    }));
+                }
+                return state.subscription;
+            };
+
+            function subscribe(observer) {
+                return state.subject.subscribe(observer);
+            }
+
+            _super.call(this, subscribe);
+        }
+
+        /**
+         * @private
+         * @memberOf ConnectableObservable
+         */
+        ConnectableObservable.prototype.connect = function () { return this.connect(); };
+
+        /**
+         * @private
+         * @memberOf ConnectableObservable
+         */        
+        ConnectableObservable.prototype.refCount = function () {
+            var connectableSubscription = null, count = 0, source = this;
+            return new AnonymousObservable(function (observer) {
+                var shouldConnect, subscription;
+                count++;
+                shouldConnect = count === 1;
+                subscription = source.subscribe(observer);
+                if (shouldConnect) {
+                    connectableSubscription = source.connect();
+                }
+                return disposableCreate(function () {
+                    subscription.dispose();
+                    count--;
+                    if (count === 0) {
+                        connectableSubscription.dispose();
+                    }
+                });
+            });
+        };
+
+        return ConnectableObservable;
+    }(Observable));
+
+    return Rx;
+}));

js/libs/rxjs/rx.coincidence.js

@@ -0,0 +1,689 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    var Observable = Rx.Observable,
+        CompositeDisposable = Rx.CompositeDisposable,
+        RefCountDisposable = Rx.RefCountDisposable,
+        SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
+        SerialDisposable = Rx.SerialDisposable,
+        Subject = Rx.Subject,
+        observableProto = Observable.prototype,
+        observableEmpty = Observable.empty,
+        AnonymousObservable = Rx.AnonymousObservable,
+        observerCreate = Rx.Observer.create,
+        addRef = Rx.internals.addRef,
+        defaultComparer = Rx.internals.isEqual,
+        noop = Rx.helpers.noop;
+    
+    // Real Dictionary
+    var primes = [1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647];
+    var noSuchkey = "no such key";
+    var duplicatekey = "duplicate key";
+
+    function isPrime(candidate) {
+        if (candidate & 1 === 0) {
+            return candidate === 2;
+        }
+        var num1 = Math.sqrt(candidate),
+            num2 = 3;
+        while (num2 <= num1) {
+            if (candidate % num2 === 0) {
+                return false;
+            }
+            num2 += 2;
+        }
+        return true;
+    }
+
+    function getPrime(min) {
+        var index, num, candidate;
+        for (index = 0; index < primes.length; ++index) {
+            num = primes[index];
+            if (num >= min) {
+                return num;
+            }
+        }
+        candidate = min | 1;
+        while (candidate < primes[primes.length - 1]) {
+            if (isPrime(candidate)) {
+                return candidate;
+            }
+            candidate += 2;
+        }
+        return min;
+    }
+
+    function stringHashFn(str) {
+        var hash = 757602046;
+        if (!str.length) {
+            return hash;
+        }
+        for (var i = 0, len = str.length; i < len; i++) {
+            var character = str.charCodeAt(i);
+            hash = ((hash<<5)-hash)+character;
+            hash = hash & hash;
+        }
+        return hash;
+    }
+
+    function numberHashFn(key) {
+        var c2 = 0x27d4eb2d; 
+        key = (key ^ 61) ^ (key >>> 16);
+        key = key + (key << 3);
+        key = key ^ (key >>> 4);
+        key = key * c2;
+        key = key ^ (key >>> 15);
+        return key;
+    }
+
+    var getHashCode = (function () {
+        var uniqueIdCounter = 0;
+
+        return function (obj) {
+            if (obj == null) { 
+                throw new Error(noSuchkey);
+            }
+
+            // Check for built-ins before tacking on our own for any object
+            if (typeof obj === 'string') {
+                return stringHashFn(obj);
+            }
+
+            if (typeof obj === 'number') {
+                return numberHashFn(obj);
+            }
+
+            if (typeof obj === 'boolean') {
+                return obj === true ? 1 : 0;
+            }
+
+            if (obj instanceof Date) {
+                return obj.getTime();
+            }
+
+            if (obj.getHashCode) {
+                return obj.getHashCode();
+            }
+
+            var id = 17 * uniqueIdCounter++;
+            obj.getHashCode = function () { return id; };
+            return id;
+        };
+    } ());
+
+    function newEntry() {
+        return { key: null, value: null, next: 0, hashCode: 0 };
+    }
+
+    // Dictionary implementation
+
+    var Dictionary = function (capacity, comparer) {
+        if (capacity < 0) {
+            throw new Error('out of range')
+        }
+        if (capacity > 0) {
+            this._initialize(capacity);
+        }
+        
+        this.comparer = comparer || defaultComparer;
+        this.freeCount = 0;
+        this.size = 0;
+        this.freeList = -1;
+    };
+
+    Dictionary.prototype._initialize = function (capacity) {
+        var prime = getPrime(capacity), i;
+        this.buckets = new Array(prime);
+        this.entries = new Array(prime);
+        for (i = 0; i < prime; i++) {
+            this.buckets[i] = -1;
+            this.entries[i] = newEntry();
+        }
+        this.freeList = -1;
+    };
+    Dictionary.prototype.count = function () {
+        return this.size;
+    };
+    Dictionary.prototype.add = function (key, value) {
+        return this._insert(key, value, true);
+    };
+    Dictionary.prototype._insert = function (key, value, add) {
+        if (!this.buckets) {
+            this._initialize(0);
+        }
+        var index3;
+        var num = getHashCode(key) & 2147483647;
+        var index1 = num % this.buckets.length;
+        for (var index2 = this.buckets[index1]; index2 >= 0; index2 = this.entries[index2].next) {
+            if (this.entries[index2].hashCode === num && this.comparer(this.entries[index2].key, key)) {
+                if (add) {
+                    throw new Error(duplicatekey);
+                }
+                this.entries[index2].value = value;
+                return;
+            }
+        }
+        if (this.freeCount > 0) {
+            index3 = this.freeList;
+            this.freeList = this.entries[index3].next;
+            --this.freeCount;
+        } else {
+            if (this.size === this.entries.length) {
+                this._resize();
+                index1 = num % this.buckets.length;
+            }
+            index3 = this.size;
+            ++this.size;
+        }
+        this.entries[index3].hashCode = num;
+        this.entries[index3].next = this.buckets[index1];
+        this.entries[index3].key = key;
+        this.entries[index3].value = value;
+        this.buckets[index1] = index3;
+    };
+
+    Dictionary.prototype._resize = function () {
+        var prime = getPrime(this.size * 2),
+            numArray = new Array(prime);
+        for (index = 0; index < numArray.length; ++index) {
+            numArray[index] = -1;
+        }
+        var entryArray = new Array(prime);
+        for (index = 0; index < this.size; ++index) {
+            entryArray[index] = this.entries[index];
+        }
+        for (var index = this.size; index < prime; ++index) {
+            entryArray[index] = newEntry();
+        }
+        for (var index1 = 0; index1 < this.size; ++index1) {
+            var index2 = entryArray[index1].hashCode % prime;
+            entryArray[index1].next = numArray[index2];
+            numArray[index2] = index1;
+        }
+        this.buckets = numArray;
+        this.entries = entryArray;
+    };
+
+    Dictionary.prototype.remove = function (key) {
+        if (this.buckets) {
+            var num = getHashCode(key) & 2147483647;
+            var index1 = num % this.buckets.length;
+            var index2 = -1;
+            for (var index3 = this.buckets[index1]; index3 >= 0; index3 = this.entries[index3].next) {
+                if (this.entries[index3].hashCode === num && this.comparer(this.entries[index3].key, key)) {
+                    if (index2 < 0) {
+                        this.buckets[index1] = this.entries[index3].next;
+                    } else {
+                        this.entries[index2].next = this.entries[index3].next;
+                    }
+                    this.entries[index3].hashCode = -1;
+                    this.entries[index3].next = this.freeList;
+                    this.entries[index3].key = null;
+                    this.entries[index3].value = null;
+                    this.freeList = index3;
+                    ++this.freeCount;
+                    return true;
+                } else {
+                    index2 = index3;
+                }
+            }
+        }
+        return false;
+    };
+
+    Dictionary.prototype.clear = function () {
+        var index, len;
+        if (this.size <= 0) {
+            return;
+        }
+        for (index = 0, len = this.buckets.length; index < len; ++index) {
+            this.buckets[index] = -1;
+        }
+        for (index = 0; index < this.size; ++index) {
+            this.entries[index] = newEntry();
+        }
+        this.freeList = -1;
+        this.size = 0;
+    };
+
+    Dictionary.prototype._findEntry = function (key) {
+        if (this.buckets) {
+            var num = getHashCode(key) & 2147483647;
+            for (var index = this.buckets[num % this.buckets.length]; index >= 0; index = this.entries[index].next) {
+                if (this.entries[index].hashCode === num && this.comparer(this.entries[index].key, key)) {
+                    return index;
+                }
+            }
+        }
+        return -1;
+    };
+
+    Dictionary.prototype.count = function () {
+        return this.size - this.freeCount;
+    };
+
+    Dictionary.prototype.tryGetValue = function (key) {
+        var entry = this._findEntry(key);
+        if (entry >= 0) {
+            return this.entries[entry].value;
+        }
+        return undefined;
+    };
+
+    Dictionary.prototype.getValues = function () {
+        var index = 0, results = [];
+        if (this.entries) {
+            for (var index1 = 0; index1 < this.size; index1++) {
+                if (this.entries[index1].hashCode >= 0) {
+                    results[index++] = this.entries[index1].value;
+                }
+            }
+        }
+        return results;
+    };
+
+    Dictionary.prototype.get = function (key) {
+        var entry = this._findEntry(key);
+        if (entry >= 0) {
+            return this.entries[entry].value;
+        }
+        throw new Error(noSuchkey);
+    };
+
+    Dictionary.prototype.set = function (key, value) {
+        this._insert(key, value, false);
+    };
+
+    Dictionary.prototype.containskey = function (key) {
+        return this._findEntry(key) >= 0;
+    };
+
+    /**
+     *  Correlates the elements of two sequences based on overlapping durations.
+     *  
+     *  @param {Observable} right The right observable sequence to join elements for.
+     *  @param {Function} leftDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the left observable sequence, used to determine overlap.
+     *  @param {Function} rightDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the right observable sequence, used to determine overlap.
+     *  @param {Function} resultSelector A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. The parameters passed to the function correspond with the elements from the left and right source sequences for which overlap occurs.
+     *  @returns {Observable} An observable sequence that contains result elements computed from source elements that have an overlapping duration.
+     */    
+    observableProto.join = function (right, leftDurationSelector, rightDurationSelector, resultSelector) {
+        var left = this;
+        return new AnonymousObservable(function (observer) {
+            var group = new CompositeDisposable(),
+            leftDone = false,
+            leftId = 0,
+            leftMap = new Dictionary(),
+            rightDone = false,
+            rightId = 0,
+            rightMap = new Dictionary();
+            group.add(left.subscribe(function (value) {
+                var duration,
+                expire,
+                id = leftId++,
+                md = new SingleAssignmentDisposable(),
+                result,
+                values;
+                leftMap.add(id, value);
+                group.add(md);
+                expire = function () {
+                    if (leftMap.remove(id) && leftMap.count() === 0 && leftDone) {
+                        observer.onCompleted();
+                    }
+                    return group.remove(md);
+                };
+                try {
+                    duration = leftDurationSelector(value);
+                } catch (e) {
+                    observer.onError(e);
+                    return;
+                }
+                md.setDisposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), function () { expire(); }));
+                values = rightMap.getValues();
+                for (var i = 0; i < values.length; i++) {
+                    try {
+                        result = resultSelector(value, values[i]);
+                    } catch (exception) {
+                        observer.onError(exception);
+                        return;
+                    }
+                    observer.onNext(result);
+                }
+            }, observer.onError.bind(observer), function () {
+                leftDone = true;
+                if (rightDone || leftMap.count() === 0) {
+                    observer.onCompleted();
+                }
+            }));
+            group.add(right.subscribe(function (value) {
+                var duration,
+                expire,
+                id = rightId++,
+                md = new SingleAssignmentDisposable(),
+                result,
+                values;
+                rightMap.add(id, value);
+                group.add(md);
+                expire = function () {
+                    if (rightMap.remove(id) && rightMap.count() === 0 && rightDone) {
+                        observer.onCompleted();
+                    }
+                    return group.remove(md);
+                };
+                try {
+                    duration = rightDurationSelector(value);
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                md.setDisposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), function () { expire(); }));
+                values = leftMap.getValues();
+                for (var i = 0; i < values.length; i++) {
+                    try {
+                        result = resultSelector(values[i], value);
+                    } catch (exception) {
+                        observer.onError(exception);
+                        return;
+                    }
+                    observer.onNext(result);
+                }
+            }, observer.onError.bind(observer), function () {
+                rightDone = true;
+                if (leftDone || rightMap.count() === 0) {
+                    observer.onCompleted();
+                }
+            }));
+            return group;
+        });
+    };
+
+    /**
+     *  Correlates the elements of two sequences based on overlapping durations, and groups the results.
+     *  
+     *  @param {Observable} right The right observable sequence to join elements for.
+     *  @param {Function} leftDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the left observable sequence, used to determine overlap.
+     *  @param {Function} rightDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the right observable sequence, used to determine overlap.
+     *  @param {Function} resultSelector A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. The first parameter passed to the function is an element of the left sequence. The second parameter passed to the function is an observable sequence with elements from the right sequence that overlap with the left sequence's element.
+     *  @returns {Observable} An observable sequence that contains result elements computed from source elements that have an overlapping duration.
+     */    
+    observableProto.groupJoin = function (right, leftDurationSelector, rightDurationSelector, resultSelector) {
+        var left = this;
+        return new AnonymousObservable(function (observer) {
+            var nothing = function () {};
+            var group = new CompositeDisposable();
+            var r = new RefCountDisposable(group);
+            var leftMap = new Dictionary();
+            var rightMap = new Dictionary();
+            var leftID = 0;
+            var rightID = 0;
+
+            group.add(left.subscribe(
+                function (value) {
+                    var s = new Subject();
+                    var id = leftID++;
+                    leftMap.add(id, s);
+                    var i, len, leftValues, rightValues;
+
+                    var result;
+                    try {
+                        result = resultSelector(value, addRef(s, r));
+                    } catch (e) {
+                        leftValues = leftMap.getValues();
+                        for (i = 0, len = leftValues.length; i < len; i++) {
+                            leftValues[i].onError(e);
+                        }
+                        observer.onError(e);
+                        return;
+                    }
+                    observer.onNext(result);
+
+                    rightValues = rightMap.getValues();
+                    for (i = 0, len = rightValues.length; i < len; i++) {
+                        s.onNext(rightValues[i]);
+                    }
+
+                    var md = new SingleAssignmentDisposable();
+                    group.add(md);
+
+                    var expire = function () {
+                        if (leftMap.remove(id)) {
+                            s.onCompleted();
+                        }
+                            
+                        group.remove(md);
+                    };
+
+                    var duration;
+                    try {
+                        duration = leftDurationSelector(value);
+                    } catch (e) {
+                        leftValues = leftMap.getValues();
+                        for (i = 0, len = leftMap.length; i < len; i++) {
+                            leftValues[i].onError(e);
+                        }
+                        observer.onError(e);
+                        return;
+                    }
+
+                    md.setDisposable(duration.take(1).subscribe(
+                        nothing,
+                        function (e) {
+                            leftValues = leftMap.getValues();
+                            for (i = 0, len = leftValues.length; i < len; i++) {
+                                leftValues[i].onError(e);
+                            }
+                            observer.onError(e);
+                        },
+                        expire)
+                    );
+                },
+                function (e) {
+                    var leftValues = leftMap.getValues();
+                    for (var i = 0, len = leftValues.length; i < len; i++) {
+                        leftValues[i].onError(e);
+                    }
+                    observer.onError(e);
+                },
+                observer.onCompleted.bind(observer)));
+
+            group.add(right.subscribe(
+                function (value) {
+                    var leftValues, i, len;
+                    var id = rightID++;
+                    rightMap.add(id, value);
+
+                    var md = new SingleAssignmentDisposable();
+                    group.add(md);
+
+                    var expire = function () {
+                        rightMap.remove(id);
+                        group.remove(md);
+                    };
+
+                    var duration;
+                    try {
+                        duration = rightDurationSelector(value);
+                    } catch (e) {
+                        leftValues = leftMap.getValues();
+                        for (i = 0, len = leftMap.length; i < len; i++) {
+                            leftValues[i].onError(e);
+                        }
+                        observer.onError(e);
+                        return;
+                    }
+                    md.setDisposable(duration.take(1).subscribe(
+                        nothing,
+                        function (e) {
+                            leftValues = leftMap.getValues();
+                            for (i = 0, len = leftMap.length; i < len; i++) {
+                                leftValues[i].onError(e);
+                            }
+                            observer.onError(e);
+                        },
+                        expire)
+                    );
+
+                    leftValues = leftMap.getValues();
+                    for (i = 0, len = leftValues.length; i < len; i++) {
+                        leftValues[i].onNext(value);
+                    }
+                },
+                function (e) {
+                    var leftValues = leftMap.getValues();
+                    for (var i = 0, len = leftValues.length; i < len; i++) {
+                        leftValues[i].onError(e);
+                    }
+                    observer.onError(e);
+                }));
+
+            return r;
+        });
+    };
+
+    /**
+     *  Projects each element of an observable sequence into zero or more buffers.
+     *  
+     *  @param {Mixed} bufferOpeningsOrClosingSelector Observable sequence whose elements denote the creation of new windows, or, a function invoked to define the boundaries of the produced windows (a new window is started when the previous one is closed, resulting in non-overlapping windows).
+     *  @param {Function} [bufferClosingSelector] A function invoked to define the closing of each produced window. If a closing selector function is specified for the first parameter, this parameter is ignored.
+     *  @returns {Observable} An observable sequence of windows.    
+     */
+    observableProto.buffer = function (bufferOpeningsOrClosingSelector, bufferClosingSelector) {
+        return this.window.apply(this, arguments).selectMany(function (x) { return x.toArray(); });
+    };
+
+    /**
+     *  Projects each element of an observable sequence into zero or more windows.
+     *  
+     *  @param {Mixed} windowOpeningsOrClosingSelector Observable sequence whose elements denote the creation of new windows, or, a function invoked to define the boundaries of the produced windows (a new window is started when the previous one is closed, resulting in non-overlapping windows).
+     *  @param {Function} [windowClosingSelector] A function invoked to define the closing of each produced window. If a closing selector function is specified for the first parameter, this parameter is ignored.
+     *  @returns {Observable} An observable sequence of windows.
+     */    
+    observableProto.window = function (windowOpeningsOrClosingSelector, windowClosingSelector) {
+        if (arguments.length === 1 && typeof arguments[0] !== 'function') {
+            return observableWindowWithBounaries.call(this, windowOpeningsOrClosingSelector);
+        }
+        return typeof windowOpeningsOrClosingSelector === 'function' ?
+            observableWindowWithClosingSelector.call(this, windowOpeningsOrClosingSelector) :
+            observableWindowWithOpenings.call(this, windowOpeningsOrClosingSelector, windowClosingSelector);
+    };
+    
+    function observableWindowWithOpenings(windowOpenings, windowClosingSelector) {
+        return windowOpenings.groupJoin(this, windowClosingSelector, function () {
+            return observableEmpty();
+        }, function (_, window) {
+            return window;
+        });
+    }
+
+    function observableWindowWithBounaries(windowBoundaries) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var window = new Subject(), 
+                d = new CompositeDisposable(), 
+                r = new RefCountDisposable(d);
+
+            observer.onNext(addRef(window, r));
+
+            d.add(source.subscribe(function (x) {
+                window.onNext(x);
+            }, function (err) {
+                window.onError(err);
+                observer.onError(err);
+            }, function () {
+                window.onCompleted();
+                observer.onCompleted();
+            }));
+
+            d.add(windowBoundaries.subscribe(function (w) {
+                window.onCompleted();
+                window = new Subject();
+                observer.onNext(addRef(window, r));
+            }, function (err) {
+                window.onError(err);
+                observer.onError(err);
+            }, function () {
+                window.onCompleted();
+                observer.onCompleted();
+            }));
+
+            return r;
+        });
+    }
+
+    function observableWindowWithClosingSelector(windowClosingSelector) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var createWindowClose,
+                m = new SerialDisposable(),
+                d = new CompositeDisposable(m),
+                r = new RefCountDisposable(d),
+                window = new Subject();
+            observer.onNext(addRef(window, r));
+            d.add(source.subscribe(function (x) {
+                window.onNext(x);
+            }, function (ex) {
+                window.onError(ex);
+                observer.onError(ex);
+            }, function () {
+                window.onCompleted();
+                observer.onCompleted();
+            }));
+            createWindowClose = function () {
+                var m1, windowClose;
+                try {
+                    windowClose = windowClosingSelector();
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                m1 = new SingleAssignmentDisposable();
+                m.setDisposable(m1);
+                m1.setDisposable(windowClose.take(1).subscribe(noop, function (ex) {
+                    window.onError(ex);
+                    observer.onError(ex);
+                }, function () {
+                    window.onCompleted();
+                    window = new Subject();
+                    observer.onNext(addRef(window, r));
+                    createWindowClose();
+                }));
+            };
+            createWindowClose();
+            return r;
+        });
+    }
+
+    return Rx;
+}));

js/libs/rxjs/rx.experimental.js

@@ -0,0 +1,471 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+  // Aliases
+  var Observable = Rx.Observable,
+    observableProto = Observable.prototype,
+    AnonymousObservable = Rx.AnonymousObservable,
+    observableConcat = Observable.concat,
+    observableDefer = Observable.defer,
+    observableEmpty = Observable.empty,
+    disposableEmpty = Rx.Disposable.empty,
+    CompositeDisposable = Rx.CompositeDisposable,
+    SerialDisposable = Rx.SerialDisposable,
+    SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
+    Enumerator = Rx.internals.Enumerator,
+    Enumerable = Rx.internals.Enumerable,
+    enumerableForEach = Enumerable.forEach,
+    immediateScheduler = Rx.Scheduler.immediate,
+    currentThreadScheduler = Rx.Scheduler.currentThread,
+    slice = Array.prototype.slice,
+    AsyncSubject = Rx.AsyncSubject,
+    Observer = Rx.Observer,
+    inherits = Rx.internals.inherits,
+    addProperties = Rx.internals.addProperties,
+    noop = Rx.helpers.noop,
+    isPromise = Rx.helpers.isPromise,
+    observableFromPromise = Observable.fromPromise;
+
+  // Utilities
+  function argsOrArray(args, idx) {
+    return args.length === 1 && Array.isArray(args[idx]) ?
+      args[idx] :
+      slice.call(args);
+  }
+
+  // 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 };
+
+  function enumerableWhile(condition, source) {
+    return new Enumerable(function () {
+      return new Enumerator(function () {
+        return condition() ?
+          { done: false, value: source } :
+          { done: true, value: undefined };  
+      });
+    });
+  }
+
+     /**
+     *  Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
+     *  This operator allows for a fluent style of writing queries that use the same sequence multiple times.
+     *
+     * @param {Function} selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
+     * @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
+     */
+    observableProto.letBind = observableProto['let'] = function (func) {
+        return func(this);
+    };
+
+   /**
+   *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
+   *  
+   * @example
+   *  1 - res = Rx.Observable.if(condition, obs1);
+   *  2 - res = Rx.Observable.if(condition, obs1, obs2);
+   *  3 - res = Rx.Observable.if(condition, obs1, scheduler);
+   * @param {Function} condition The condition which determines if the thenSource or elseSource will be run.
+   * @param {Observable} thenSource The observable sequence or Promise that will be run if the condition function returns true.
+   * @param {Observable} [elseSource] The observable sequence or Promise that will be run if the condition function returns false. If this is not provided, it defaults to Rx.Observabe.Empty with the specified scheduler.  
+   * @returns {Observable} An observable sequence which is either the thenSource or elseSource.
+   */
+  Observable['if'] = Observable.ifThen = function (condition, thenSource, elseSourceOrScheduler) {
+    return observableDefer(function () {
+      elseSourceOrScheduler || (elseSourceOrScheduler = observableEmpty());
+
+      isPromise(thenSource) && (thenSource = observableFromPromise(thenSource));
+      isPromise(elseSourceOrScheduler) && (elseSourceOrScheduler = observableFromPromise(elseSourceOrScheduler));
+
+      // Assume a scheduler for empty only
+      typeof elseSourceOrScheduler.now === 'function' && (elseSourceOrScheduler = observableEmpty(elseSourceOrScheduler));
+      return condition() ? thenSource : elseSourceOrScheduler;
+    });
+  };
+
+     /**
+     *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
+     * There is an alias for this method called 'forIn' for browsers <IE9
+     * @param {Array} sources An array of values to turn into an observable sequence.
+     * @param {Function} resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
+     * @returns {Observable} An observable sequence from the concatenated observable sequences.  
+     */ 
+    Observable['for'] = Observable.forIn = function (sources, resultSelector) {
+        return enumerableForEach(sources, resultSelector).concat();
+    };
+
+   /**
+   *  Repeats source as long as condition holds emulating a while loop.
+   * There is an alias for this method called 'whileDo' for browsers <IE9
+   *
+   * @param {Function} condition The condition which determines if the source will be repeated.
+   * @param {Observable} source The observable sequence that will be run if the condition function returns true.
+   * @returns {Observable} An observable sequence which is repeated as long as the condition holds.  
+   */
+  var observableWhileDo = Observable['while'] = Observable.whileDo = function (condition, source) {
+    isPromise(source) && (source = observableFromPromise(source));
+    return enumerableWhile(condition, source).concat();
+  };
+
+     /**
+     *  Repeats source as long as condition holds emulating a do while loop.
+     *
+     * @param {Function} condition The condition which determines if the source will be repeated.
+     * @param {Observable} source The observable sequence that will be run if the condition function returns true.
+     * @returns {Observable} An observable sequence which is repeated as long as the condition holds. 
+     */ 
+    observableProto.doWhile = function (condition) {
+        return observableConcat([this, observableWhileDo(condition, this)]);
+    };
+
+   /**
+   *  Uses selector to determine which source in sources to use.
+   *  There is an alias 'switchCase' for browsers <IE9.
+   *  
+   * @example
+   *  1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
+   *  1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
+   *  1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
+   * 
+   * @param {Function} selector The function which extracts the value for to test in a case statement.
+   * @param {Array} sources A object which has keys which correspond to the case statement labels.
+   * @param {Observable} [elseSource] The observable sequence or Promise that will be run if the sources are not matched. If this is not provided, it defaults to Rx.Observabe.empty with the specified scheduler.
+   *       
+   * @returns {Observable} An observable sequence which is determined by a case statement.  
+   */
+  Observable['case'] = Observable.switchCase = function (selector, sources, defaultSourceOrScheduler) {
+    return observableDefer(function () {
+      defaultSourceOrScheduler || (defaultSourceOrScheduler = observableEmpty());
+
+      typeof defaultSourceOrScheduler.now === 'function' && (defaultSourceOrScheduler = observableEmpty(defaultSourceOrScheduler));
+      
+      var result = sources[selector()];
+      isPromise(result) && (result = observableFromPromise(result));
+      
+      return result || defaultSourceOrScheduler;
+    });
+  };
+
+     /**
+     *  Expands an observable sequence by recursively invoking selector.
+     *  
+     * @param {Function} selector Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again.
+     * @param {Scheduler} [scheduler] Scheduler on which to perform the expansion. If not provided, this defaults to the current thread scheduler.
+     * @returns {Observable} An observable sequence containing all the elements produced by the recursive expansion.
+     */
+    observableProto.expand = function (selector, scheduler) {
+        scheduler || (scheduler = immediateScheduler);
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var q = [],
+                m = new SerialDisposable(),
+                d = new CompositeDisposable(m),
+                activeCount = 0,
+                isAcquired = false;
+
+            var ensureActive = function () {
+                var isOwner = false;
+                if (q.length > 0) {
+                    isOwner = !isAcquired;
+                    isAcquired = true;
+                }
+                if (isOwner) {
+                    m.setDisposable(scheduler.scheduleRecursive(function (self) {
+                        var work;
+                        if (q.length > 0) {
+                            work = q.shift();
+                        } else {
+                            isAcquired = false;
+                            return;
+                        }
+                        var m1 = new SingleAssignmentDisposable();
+                        d.add(m1);
+                        m1.setDisposable(work.subscribe(function (x) {
+                            observer.onNext(x);
+                            var result = null;
+                            try {
+                                result = selector(x);
+                            } catch (e) {
+                                observer.onError(e);
+                            }
+                            q.push(result);
+                            activeCount++;
+                            ensureActive();
+                        }, observer.onError.bind(observer), function () {
+                            d.remove(m1);
+                            activeCount--;
+                            if (activeCount === 0) {
+                                observer.onCompleted();
+                            }
+                        }));
+                        self();
+                    }));
+                }
+            };
+
+            q.push(source);
+            activeCount++;
+            ensureActive();
+            return d;
+        });
+    };
+
+   /**
+   *  Runs all observable sequences in parallel and collect their last elements.
+   *  
+   * @example
+   *  1 - res = Rx.Observable.forkJoin([obs1, obs2]);
+   *  1 - res = Rx.Observable.forkJoin(obs1, obs2, ...);  
+   * @returns {Observable} An observable sequence with an array collecting the last elements of all the input sequences.
+   */
+  Observable.forkJoin = function () {
+    var allSources = argsOrArray(arguments, 0);
+    return new AnonymousObservable(function (subscriber) {
+      var count = allSources.length;
+      if (count === 0) {
+        subscriber.onCompleted();
+        return disposableEmpty;
+      }
+      var group = new CompositeDisposable(),
+        finished = false,
+        hasResults = new Array(count),
+        hasCompleted = new Array(count),
+        results = new Array(count);
+
+      for (var idx = 0; idx < count; idx++) {
+        (function (i) {
+          var source = allSources[i];
+          isPromise(source) && (source = observableFromPromise(source));
+          group.add(
+            source.subscribe(
+              function (value) {
+              if (!finished) {
+                hasResults[i] = true;
+                results[i] = value;
+              }
+            }, 
+            function (e) {
+              finished = true;
+              subscriber.onError(e);
+              group.dispose();
+            }, 
+            function () {
+              if (!finished) {
+                if (!hasResults[i]) {
+                    subscriber.onCompleted();
+                    return;
+                }
+                hasCompleted[i] = true;
+                for (var ix = 0; ix < count; ix++) {
+                  if (!hasCompleted[ix]) { return; }
+                }
+                finished = true;
+                subscriber.onNext(results);
+                subscriber.onCompleted();
+              }
+            }));
+        })(idx);
+      }
+
+      return group;
+    });
+  };
+
+   /**
+   *  Runs two observable sequences in parallel and combines their last elemenets.
+   *
+   * @param {Observable} second Second observable sequence.
+   * @param {Function} resultSelector Result selector function to invoke with the last elements of both sequences.
+   * @returns {Observable} An observable sequence with the result of calling the selector function with the last elements of both input sequences.
+   */
+  observableProto.forkJoin = function (second, resultSelector) {
+    var first = this;
+
+    return new AnonymousObservable(function (observer) {
+      var leftStopped = false, rightStopped = false,
+        hasLeft = false, hasRight = false,
+        lastLeft, lastRight,
+        leftSubscription = new SingleAssignmentDisposable(), rightSubscription = new SingleAssignmentDisposable();
+
+      isPromise(second) && (second = observableFromPromise(second));
+
+      leftSubscription.setDisposable(
+          first.subscribe(function (left) {
+            hasLeft = true;
+            lastLeft = left;
+          }, function (err) {
+            rightSubscription.dispose();
+            observer.onError(err);
+          }, function () {
+            leftStopped = true;
+            if (rightStopped) {
+              if (!hasLeft) {
+                  observer.onCompleted();
+              } else if (!hasRight) {
+                  observer.onCompleted();
+              } else {
+                var result;
+                try {
+                  result = resultSelector(lastLeft, lastRight);
+                } catch (e) {
+                  observer.onError(e);
+                  return;
+                }
+                observer.onNext(result);
+                observer.onCompleted();
+              }
+            }
+          })
+      );
+
+      rightSubscription.setDisposable(
+        second.subscribe(function (right) {
+          hasRight = true;
+          lastRight = right;
+        }, function (err) {
+          leftSubscription.dispose();
+          observer.onError(err);
+        }, function () {
+          rightStopped = true;
+          if (leftStopped) {
+            if (!hasLeft) {
+              observer.onCompleted();
+            } else if (!hasRight) {
+              observer.onCompleted();
+            } else {
+              var result;
+              try {
+                result = resultSelector(lastLeft, lastRight);
+              } catch (e) {
+                observer.onError(e);
+                return;
+              }
+              observer.onNext(result);
+              observer.onCompleted();
+            }
+          }
+        })
+      );
+
+      return new CompositeDisposable(leftSubscription, rightSubscription);
+    });
+  };
+
+    /**
+     * Comonadic bind operator.
+     * @param {Function} selector A transform function to apply to each element.
+     * @param {Object} scheduler Scheduler used to execute the operation. If not specified, defaults to the ImmediateScheduler.
+     * @returns {Observable} An observable sequence which results from the comonadic bind operation.
+     */
+    observableProto.manySelect = function (selector, scheduler) {
+        scheduler || (scheduler = immediateScheduler);
+        var source = this;
+        return observableDefer(function () {
+            var chain;
+
+            return source
+                .select(
+                    function (x) {
+                        var curr = new ChainObservable(x);
+                        if (chain) {
+                            chain.onNext(x);
+                        }
+                        chain = curr;
+
+                        return curr;
+                    })
+                .doAction(
+                    noop,
+                    function (e) {
+                        if (chain) {
+                            chain.onError(e);
+                        }
+                    },
+                    function () {
+                        if (chain) {
+                            chain.onCompleted();
+                        }
+                    })
+                .observeOn(scheduler)
+                .select(function (x, i, o) { return selector(x, i, o); });
+        });
+    };
+
+    var ChainObservable = (function (_super) {
+
+        function subscribe (observer) {
+            var self = this, g = new CompositeDisposable();
+            g.add(currentThreadScheduler.schedule(function () {
+                observer.onNext(self.head);
+                g.add(self.tail.mergeObservable().subscribe(observer));
+            }));
+
+            return g;
+        }
+
+        inherits(ChainObservable, _super);
+
+        function ChainObservable(head) {
+            _super.call(this, subscribe);
+            this.head = head;
+            this.tail = new AsyncSubject();
+        }
+
+        addProperties(ChainObservable.prototype, Observer, {
+            onCompleted: function () {
+                this.onNext(Observable.empty());
+            },
+            onError: function (e) {
+                this.onNext(Observable.throwException(e));
+            },
+            onNext: function (v) {
+                this.tail.onNext(v);
+                this.tail.onCompleted();
+            }
+        });
+
+        return ChainObservable;
+
+    }(Observable));
+
+    return Rx;
+}));

js/libs/rxjs/rx.experimental.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c,d){function e(a,b){return 1===a.length&&Array.isArray(a[b])?a[b]:v.call(a)}function f(a,b){return new r(function(){return new q(function(){return a()?{done:!1,value:b}:{done:!0,value:d}})})}var g=c.Observable,h=g.prototype,i=c.AnonymousObservable,j=g.concat,k=g.defer,l=g.empty,m=c.Disposable.empty,n=c.CompositeDisposable,o=c.SerialDisposable,p=c.SingleAssignmentDisposable,q=c.internals.Enumerator,r=c.internals.Enumerable,s=r.forEach,t=c.Scheduler.immediate,u=c.Scheduler.currentThread,v=Array.prototype.slice,w=c.AsyncSubject,x=c.Observer,y=c.internals.inherits,z=c.internals.addProperties,A=c.helpers.noop,B=c.helpers.isPromise,C=g.fromPromise,D="object"==typeof Symbol&&Symbol.iterator||"_es6shim_iterator_";a.Set&&"function"==typeof(new a.Set)["@@iterator"]&&(D="@@iterator");h.letBind=h.let=function(a){return a(this)},g["if"]=g.ifThen=function(a,b,c){return k(function(){return c||(c=l()),B(b)&&(b=C(b)),B(c)&&(c=C(c)),"function"==typeof c.now&&(c=l(c)),a()?b:c})},g["for"]=g.forIn=function(a,b){return s(a,b).concat()};var E=g["while"]=g.whileDo=function(a,b){return B(b)&&(b=C(b)),f(a,b).concat()};h.doWhile=function(a){return j([this,E(a,this)])},g["case"]=g.switchCase=function(a,b,c){return k(function(){c||(c=l()),"function"==typeof c.now&&(c=l(c));var d=b[a()];return B(d)&&(d=C(d)),d||c})},h.expand=function(a,b){b||(b=t);var c=this;return new i(function(d){var e=[],f=new o,g=new n(f),h=0,i=!1,j=function(){var c=!1;e.length>0&&(c=!i,i=!0),c&&f.setDisposable(b.scheduleRecursive(function(b){var c;if(!(e.length>0))return i=!1,void 0;c=e.shift();var f=new p;g.add(f),f.setDisposable(c.subscribe(function(b){d.onNext(b);var c=null;try{c=a(b)}catch(f){d.onError(f)}e.push(c),h++,j()},d.onError.bind(d),function(){g.remove(f),h--,0===h&&d.onCompleted()})),b()}))};return e.push(c),h++,j(),g})},g.forkJoin=function(){var a=e(arguments,0);return new i(function(b){var c=a.length;if(0===c)return b.onCompleted(),m;for(var d=new n,e=!1,f=new Array(c),g=new Array(c),h=new Array(c),i=0;c>i;i++)!function(i){var j=a[i];B(j)&&(j=C(j)),d.add(j.subscribe(function(a){e||(f[i]=!0,h[i]=a)},function(a){e=!0,b.onError(a),d.dispose()},function(){if(!e){if(!f[i])return b.onCompleted(),void 0;g[i]=!0;for(var a=0;c>a;a++)if(!g[a])return;e=!0,b.onNext(h),b.onCompleted()}}))}(i);return d})},h.forkJoin=function(a,b){var c=this;return new i(function(d){var e,f,g=!1,h=!1,i=!1,j=!1,k=new p,l=new p;return B(a)&&(a=C(a)),k.setDisposable(c.subscribe(function(a){i=!0,e=a},function(a){l.dispose(),d.onError(a)},function(){if(g=!0,h)if(i)if(j){var a;try{a=b(e,f)}catch(c){return d.onError(c),void 0}d.onNext(a),d.onCompleted()}else d.onCompleted();else d.onCompleted()})),l.setDisposable(a.subscribe(function(a){j=!0,f=a},function(a){k.dispose(),d.onError(a)},function(){if(h=!0,g)if(i)if(j){var a;try{a=b(e,f)}catch(c){return d.onError(c),void 0}d.onNext(a),d.onCompleted()}else d.onCompleted();else d.onCompleted()})),new n(k,l)})},h.manySelect=function(a,b){b||(b=t);var c=this;return k(function(){var d;return c.select(function(a){var b=new F(a);return d&&d.onNext(a),d=b,b}).doAction(A,function(a){d&&d.onError(a)},function(){d&&d.onCompleted()}).observeOn(b).select(function(b,c,d){return a(b,c,d)})})};var F=function(a){function b(a){var b=this,c=new n;return c.add(u.schedule(function(){a.onNext(b.head),c.add(b.tail.mergeObservable().subscribe(a))})),c}function c(c){a.call(this,b),this.head=c,this.tail=new w}return y(c,a),z(c.prototype,x,{onCompleted:function(){this.onNext(g.empty())},onError:function(a){this.onNext(g.throwException(a))},onNext:function(a){this.tail.onNext(a),this.tail.onCompleted()}}),c}(g);return c});

js/libs/rxjs/rx.joinpatterns.js

@@ -0,0 +1,415 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    // Aliases
+    var Observable = Rx.Observable,
+        observableProto = Observable.prototype,
+        AnonymousObservable = Rx.AnonymousObservable,
+        observableThrow = Observable.throwException,
+        observerCreate = Rx.Observer.create,
+        SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
+        CompositeDisposable = Rx.CompositeDisposable,
+        AbstractObserver = Rx.internals.AbstractObserver,
+        noop = Rx.helpers.noop,
+        defaultComparer = Rx.internals.isEqual,
+        inherits = Rx.internals.inherits,
+        slice = Array.prototype.slice;
+
+    // Utilities
+    function argsOrArray(args, idx) {
+        return args.length === 1 && Array.isArray(args[idx]) ?
+            args[idx] :
+            slice.call(args);
+    }
+
+    /** @private */
+    var Map = (function () {
+
+        /**
+         * @constructor
+         * @private
+         */
+        function Map() {
+            this.keys = [];
+            this.values = [];
+        }
+
+        /**
+         * @private
+         * @memberOf Map#
+         */
+        Map.prototype['delete'] = function (key) {
+            var i = this.keys.indexOf(key);
+            if (i !== -1) {
+                this.keys.splice(i, 1);
+                this.values.splice(i, 1);
+            }
+            return i !== -1;
+        };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */
+        Map.prototype.get = function (key, fallback) {
+            var i = this.keys.indexOf(key);
+            return i !== -1 ? this.values[i] : fallback;
+        };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */
+        Map.prototype.set = function (key, value) {
+            var i = this.keys.indexOf(key);
+            if (i !== -1) {
+                this.values[i] = value;
+            }
+            this.values[this.keys.push(key) - 1] = value;
+        };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */
+        Map.prototype.size = function () { return this.keys.length; };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */        
+        Map.prototype.has = function (key) {
+            return this.keys.indexOf(key) !== -1;
+        };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */        
+        Map.prototype.getKeys = function () { return this.keys.slice(0); };
+
+        /**
+         * @private
+         * @memberOf Map#
+         */        
+        Map.prototype.getValues = function () { return this.values.slice(0); };
+
+        return Map;
+    }());
+
+    /**
+     * @constructor
+     * Represents a join pattern over observable sequences.
+     */
+    function Pattern(patterns) {
+        this.patterns = patterns;
+    }
+
+    /**
+     *  Creates a pattern that matches the current plan matches and when the specified observable sequences has an available value.
+     *  
+     *  @param other Observable sequence to match in addition to the current pattern.
+     *  @return Pattern object that matches when all observable sequences in the pattern have an available value.   
+     */ 
+    Pattern.prototype.and = function (other) {
+        var patterns = this.patterns.slice(0);
+        patterns.push(other);
+        return new Pattern(patterns);
+    };
+
+    /**
+     *  Matches when all observable sequences in the pattern (specified using a chain of and operators) have an available value and projects the values.
+     *  
+     *  @param selector Selector that will be invoked with available values from the source sequences, in the same order of the sequences in the pattern.
+     *  @return Plan that produces the projected values, to be fed (with other plans) to the when operator.
+     */
+    Pattern.prototype.then = function (selector) {
+        return new Plan(this, selector);
+    };
+
+    function Plan(expression, selector) {
+        this.expression = expression;
+        this.selector = selector;
+    }
+    
+    Plan.prototype.activate = function (externalSubscriptions, observer, deactivate) {
+        var self = this;
+        var joinObservers = [];
+        for (var i = 0, len = this.expression.patterns.length; i < len; i++) {
+            joinObservers.push(planCreateObserver(externalSubscriptions, this.expression.patterns[i], observer.onError.bind(observer)));
+        }
+        var activePlan = new ActivePlan(joinObservers, function () {
+            var result;
+            try {
+                result = self.selector.apply(self, arguments);
+            } catch (exception) {
+                observer.onError(exception);
+                return;
+            }
+            observer.onNext(result);
+        }, function () {
+            for (var j = 0, jlen = joinObservers.length; j < jlen; j++) {
+                joinObservers[j].removeActivePlan(activePlan);
+            }
+            deactivate(activePlan);
+        });
+        for (i = 0, len = joinObservers.length; i < len; i++) {
+            joinObservers[i].addActivePlan(activePlan);
+        }
+        return activePlan;
+    };
+
+    function planCreateObserver(externalSubscriptions, observable, onError) {
+        var entry = externalSubscriptions.get(observable);
+        if (!entry) {
+            var observer = new JoinObserver(observable, onError);
+            externalSubscriptions.set(observable, observer);
+            return observer;
+        }
+        return entry;
+    }
+
+    // Active Plan
+    function ActivePlan(joinObserverArray, onNext, onCompleted) {
+        var i, joinObserver;
+        this.joinObserverArray = joinObserverArray;
+        this.onNext = onNext;
+        this.onCompleted = onCompleted;
+        this.joinObservers = new Map();
+        for (i = 0; i < this.joinObserverArray.length; i++) {
+            joinObserver = this.joinObserverArray[i];
+            this.joinObservers.set(joinObserver, joinObserver);
+        }
+    }
+
+    ActivePlan.prototype.dequeue = function () {
+        var values = this.joinObservers.getValues();
+        for (var i = 0, len = values.length; i < len; i++) {
+            values[i].queue.shift();
+        }
+    };
+    ActivePlan.prototype.match = function () {
+        var firstValues, i, len, isCompleted, values, hasValues = true;
+        for (i = 0, len = this.joinObserverArray.length; i < len; i++) {
+            if (this.joinObserverArray[i].queue.length === 0) {
+                hasValues = false;
+                break;
+            }
+        }
+        if (hasValues) {
+            firstValues = [];
+            isCompleted = false;
+            for (i = 0, len = this.joinObserverArray.length; i < len; i++) {
+                firstValues.push(this.joinObserverArray[i].queue[0]);
+                if (this.joinObserverArray[i].queue[0].kind === 'C') {
+                    isCompleted = true;
+                }
+            }
+            if (isCompleted) {
+                this.onCompleted();
+            } else {
+                this.dequeue();
+                values = [];
+                for (i = 0; i < firstValues.length; i++) {
+                    values.push(firstValues[i].value);
+                }
+                this.onNext.apply(this, values);
+            }
+        }
+    };
+
+    /** @private */
+    var JoinObserver = (function (_super) {
+
+        inherits(JoinObserver, _super);
+
+        /**
+         * @constructor
+         * @private
+         */
+        function JoinObserver(source, onError) {
+            _super.call(this);
+            this.source = source;
+            this.onError = onError;
+            this.queue = [];
+            this.activePlans = [];
+            this.subscription = new SingleAssignmentDisposable();
+            this.isDisposed = false;
+        }
+
+        var JoinObserverPrototype = JoinObserver.prototype;
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */
+        JoinObserverPrototype.next = function (notification) {
+            if (!this.isDisposed) {
+                if (notification.kind === 'E') {
+                    this.onError(notification.exception);
+                    return;
+                }
+                this.queue.push(notification);
+                var activePlans = this.activePlans.slice(0);
+                for (var i = 0, len = activePlans.length; i < len; i++) {
+                    activePlans[i].match();
+                }
+            }
+        };
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */        
+        JoinObserverPrototype.error = noop;
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */        
+        JoinObserverPrototype.completed = noop;
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */
+        JoinObserverPrototype.addActivePlan = function (activePlan) {
+            this.activePlans.push(activePlan);
+        };
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */        
+        JoinObserverPrototype.subscribe = function () {
+            this.subscription.setDisposable(this.source.materialize().subscribe(this));
+        };
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */        
+        JoinObserverPrototype.removeActivePlan = function (activePlan) {
+            var idx = this.activePlans.indexOf(activePlan);
+            this.activePlans.splice(idx, 1);
+            if (this.activePlans.length === 0) {
+                this.dispose();
+            }
+        };
+
+        /**
+         * @memberOf JoinObserver#
+         * @private
+         */        
+        JoinObserverPrototype.dispose = function () {
+            _super.prototype.dispose.call(this);
+            if (!this.isDisposed) {
+                this.isDisposed = true;
+                this.subscription.dispose();
+            }
+        };
+        
+        return JoinObserver;
+    } (AbstractObserver));
+
+    /**
+     *  Creates a pattern that matches when both observable sequences have an available value.
+     *  
+     *  @param right Observable sequence to match with the current sequence.
+     *  @return {Pattern} Pattern object that matches when both observable sequences have an available value.     
+     */
+    observableProto.and = function (right) {
+        return new Pattern([this, right]);
+    };
+
+    /**
+     *  Matches when the observable sequence has an available value and projects the value.
+     *  
+     *  @param selector Selector that will be invoked for values in the source sequence.
+     *  @returns {Plan} Plan that produces the projected values, to be fed (with other plans) to the when operator. 
+     */    
+    observableProto.then = function (selector) {
+        return new Pattern([this]).then(selector);
+    };
+
+    /**
+     *  Joins together the results from several patterns.
+     *  
+     *  @param plans A series of plans (specified as an Array of as a series of arguments) created by use of the Then operator on patterns.
+     *  @returns {Observable} Observable sequence with the results form matching several patterns. 
+     */
+    Observable.when = function () {
+        var plans = argsOrArray(arguments, 0);
+        return new AnonymousObservable(function (observer) {
+            var activePlans = [],
+                externalSubscriptions = new Map(),
+                group,
+                i, len,
+                joinObserver,
+                joinValues,
+                outObserver;
+            outObserver = observerCreate(observer.onNext.bind(observer), function (exception) {
+                var values = externalSubscriptions.getValues();
+                for (var j = 0, jlen = values.length; j < jlen; j++) {
+                    values[j].onError(exception);
+                }
+                observer.onError(exception);
+            }, observer.onCompleted.bind(observer));
+            try {
+                for (i = 0, len = plans.length; i < len; i++) {
+                    activePlans.push(plans[i].activate(externalSubscriptions, outObserver, function (activePlan) {
+                        var idx = activePlans.indexOf(activePlan);
+                        activePlans.splice(idx, 1);
+                        if (activePlans.length === 0) {
+                            outObserver.onCompleted();
+                        }
+                    }));
+                }
+            } catch (e) {
+                observableThrow(e).subscribe(observer);
+            }
+            group = new CompositeDisposable();
+            joinValues = externalSubscriptions.getValues();
+            for (i = 0, len = joinValues.length; i < len; i++) {
+                joinObserver = joinValues[i];
+                joinObserver.subscribe();
+                group.add(joinObserver);
+            }
+            return group;
+        });
+    };
+
+    return Rx;
+}));

js/libs/rxjs/rx.joinpatterns.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){function d(a,b){return 1===a.length&&Array.isArray(a[b])?a[b]:s.call(a)}function e(a){this.patterns=a}function f(a,b){this.expression=a,this.selector=b}function g(a,b,c){var d=a.get(b);if(!d){var e=new u(b,c);return a.set(b,e),e}return d}function h(a,b,c){var d,e;for(this.joinObserverArray=a,this.onNext=b,this.onCompleted=c,this.joinObservers=new t,d=0;d<this.joinObserverArray.length;d++)e=this.joinObserverArray[d],this.joinObservers.set(e,e)}var i=c.Observable,j=i.prototype,k=c.AnonymousObservable,l=i.throwException,m=c.Observer.create,n=c.SingleAssignmentDisposable,o=c.CompositeDisposable,p=c.internals.AbstractObserver,q=c.helpers.noop,r=(c.internals.isEqual,c.internals.inherits),s=Array.prototype.slice,t=function(){function a(){this.keys=[],this.values=[]}return a.prototype["delete"]=function(a){var b=this.keys.indexOf(a);return-1!==b&&(this.keys.splice(b,1),this.values.splice(b,1)),-1!==b},a.prototype.get=function(a,b){var c=this.keys.indexOf(a);return-1!==c?this.values[c]:b},a.prototype.set=function(a,b){var c=this.keys.indexOf(a);-1!==c&&(this.values[c]=b),this.values[this.keys.push(a)-1]=b},a.prototype.size=function(){return this.keys.length},a.prototype.has=function(a){return-1!==this.keys.indexOf(a)},a.prototype.getKeys=function(){return this.keys.slice(0)},a.prototype.getValues=function(){return this.values.slice(0)},a}();e.prototype.and=function(a){var b=this.patterns.slice(0);return b.push(a),new e(b)},e.prototype.then=function(a){return new f(this,a)},f.prototype.activate=function(a,b,c){for(var d=this,e=[],f=0,i=this.expression.patterns.length;i>f;f++)e.push(g(a,this.expression.patterns[f],b.onError.bind(b)));var j=new h(e,function(){var a;try{a=d.selector.apply(d,arguments)}catch(c){return b.onError(c),void 0}b.onNext(a)},function(){for(var a=0,b=e.length;b>a;a++)e[a].removeActivePlan(j);c(j)});for(f=0,i=e.length;i>f;f++)e[f].addActivePlan(j);return j},h.prototype.dequeue=function(){for(var a=this.joinObservers.getValues(),b=0,c=a.length;c>b;b++)a[b].queue.shift()},h.prototype.match=function(){var a,b,c,d,e,f=!0;for(b=0,c=this.joinObserverArray.length;c>b;b++)if(0===this.joinObserverArray[b].queue.length){f=!1;break}if(f){for(a=[],d=!1,b=0,c=this.joinObserverArray.length;c>b;b++)a.push(this.joinObserverArray[b].queue[0]),"C"===this.joinObserverArray[b].queue[0].kind&&(d=!0);if(d)this.onCompleted();else{for(this.dequeue(),e=[],b=0;b<a.length;b++)e.push(a[b].value);this.onNext.apply(this,e)}}};var u=function(a){function b(b,c){a.call(this),this.source=b,this.onError=c,this.queue=[],this.activePlans=[],this.subscription=new n,this.isDisposed=!1}r(b,a);var c=b.prototype;return c.next=function(a){if(!this.isDisposed){if("E"===a.kind)return this.onError(a.exception),void 0;this.queue.push(a);for(var b=this.activePlans.slice(0),c=0,d=b.length;d>c;c++)b[c].match()}},c.error=q,c.completed=q,c.addActivePlan=function(a){this.activePlans.push(a)},c.subscribe=function(){this.subscription.setDisposable(this.source.materialize().subscribe(this))},c.removeActivePlan=function(a){var b=this.activePlans.indexOf(a);this.activePlans.splice(b,1),0===this.activePlans.length&&this.dispose()},c.dispose=function(){a.prototype.dispose.call(this),this.isDisposed||(this.isDisposed=!0,this.subscription.dispose())},b}(p);return j.and=function(a){return new e([this,a])},j.then=function(a){return new e([this]).then(a)},i.when=function(){var a=d(arguments,0);return new k(function(b){var c,d,e,f,g,h,i=[],j=new t;h=m(b.onNext.bind(b),function(a){for(var c=j.getValues(),d=0,e=c.length;e>d;d++)c[d].onError(a);b.onError(a)},b.onCompleted.bind(b));try{for(d=0,e=a.length;e>d;d++)i.push(a[d].activate(j,h,function(a){var b=i.indexOf(a);i.splice(b,1),0===i.length&&h.onCompleted()}))}catch(k){l(k).subscribe(b)}for(c=new o,g=j.getValues(),d=0,e=g.length;e>d;d++)f=g[d],f.subscribe(),c.add(f);return c})},c});

js/libs/rxjs/rx.node.js

@@ -0,0 +1,144 @@
+var Rx = require('./rx');
+require('./rx.aggregates');
+require('./rx.backpressure');
+require('./rx.async');
+require('./rx.binding');
+require('./rx.coincidence');
+require('./rx.experimental');
+require('./rx.joinpatterns');
+require('./rx.time');
+require('./rx.virtualtime');
+require('./rx.testing');
+
+// Add specific Node functions
+var EventEmitter = require('events').EventEmitter,
+    Observable = Rx.Observable;
+
+Rx.Node = {
+    /**
+     * @deprecated Use Rx.Observable.fromCallback from rx.async.js instead.
+     *
+     * Converts a callback function to an observable sequence. 
+     * 
+     * @param {Function} func Function to convert to an asynchronous function.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+     * @returns {Function} Asynchronous function.
+     */
+    fromCallback: function (func, scheduler, context, selector) {
+        return Observable.fromCallback(func, scheduler, context, selector);
+    },
+
+    /**
+     * @deprecated Use Rx.Observable.fromNodeCallback from rx.async.js instead.
+     *
+     * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
+     *
+     * @param {Function} func The function to call
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+     * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
+     */
+    fromNodeCallback: function (func, scheduler, context, selector) {
+        return Observable.fromNodeCallback(func, scheduler, context, selector);
+    },
+
+    /**
+     * @deprecated Use Rx.Observable.fromNodeCallback from rx.async.js instead.
+     *    
+     * Handles an event from the given EventEmitter as an observable sequence.
+     *
+     * @param {EventEmitter} eventEmitter The EventEmitter to subscribe to the given event.
+     * @param {String} eventName The event name to subscribe
+     * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+     * @returns {Observable} An observable sequence generated from the named event from the given EventEmitter.  The data will be returned as an array of arguments to the handler.
+     */
+    fromEvent: function (eventEmitter, eventName, selector) {
+        return Observable.fromEvent(eventEmitter, eventName, selector);
+    },
+
+    /**
+     * Converts the given observable sequence to an event emitter with the given event name. 
+     * The errors are handled on the 'error' event and completion on the 'end' event.
+     * @param {Observable} observable The observable sequence to convert to an EventEmitter.
+     * @param {String} eventName The event name to emit onNext calls.
+     * @returns {EventEmitter} An EventEmitter which emits the given eventName for each onNext call in addition to 'error' and 'end' events.  
+     *   You must call publish in order to invoke the subscription on the Observable sequuence.
+     */
+    toEventEmitter: function (observable, eventName) {
+        var e = new EventEmitter();
+
+        // Used to publish the events from the observable
+        e.publish = function () {
+            e.subscription = observable.subscribe(
+                function (x) {
+                    e.emit(eventName, x);
+                }, 
+                function (err) {
+                    e.emit('error', err);
+                },
+                function () {
+                    e.emit('end');
+                });
+        };
+
+        return e;
+    },
+
+    /**
+     * Converts a flowing stream to an Observable sequence.
+     * @param {Stream} stream A stream to convert to a observable sequence.
+     * @returns {Observable} An observable sequence which fires on each 'data' event as well as handling 'error' and 'end' events.
+     */
+    fromStream: function (stream) {
+        return Observable.create(function (observer) {
+            function dataHandler (data) {
+                observer.onNext(data);
+            }
+
+            function errorHandler (err) {
+                observer.onError(err);
+            }
+
+            function endHandler () {
+                observer.onCompleted();
+            }
+
+            stream.addListener('data', dataHandler);
+            stream.addListener('error', errorHandler);
+            stream.addListener('end', endHandler);
+            
+            return function () {
+                stream.removeListener('data', dataHandler);
+                stream.removeListener('error', errorHandler);
+                stream.removeListener('end', endHandler);
+            };
+        }).publish().refCount();
+    },
+
+    /**
+     * Writes an observable sequence to a stream
+     * @param {Observable} observable Observable sequence to write to a stream.
+     * @param {Stream} stream The stream to write to.
+     * @param {String} [encoding] The encoding of the item to write.
+     * @returns {Disposable} The subscription handle.
+     */
+    writeToStream: function (observable, stream, encoding) {
+        return observable.subscribe(
+            function (x) {
+                stream.write(String(x), encoding);
+            },
+            function (err) {
+                stream.emit('error', err);
+            }, function () {
+                // Hack check because STDIO is not closable
+                if (!stream._isStdio) {
+                    stream.end();
+                }
+            });
+    }
+};
+
+module.exports = Rx;

js/libs/rxjs/rx.testing.js

@@ -0,0 +1,500 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx.virtualtime', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    // Defaults
+    var Observer = Rx.Observer,
+        Observable = Rx.Observable,
+        Notification = Rx.Notification,
+        VirtualTimeScheduler = Rx.VirtualTimeScheduler,
+        Disposable = Rx.Disposable,
+        disposableEmpty = Disposable.empty,
+        disposableCreate = Disposable.create,
+        CompositeDisposable = Rx.CompositeDisposable,
+        SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
+        slice = Array.prototype.slice,
+        inherits = Rx.internals.inherits,
+        defaultComparer = Rx.internals.isEqual;
+
+    function argsOrArray(args, idx) {
+        return args.length === 1 && Array.isArray(args[idx]) ?
+            args[idx] :
+            slice.call(args);
+    }
+
+    /** 
+     * @private 
+     * @constructor
+     */
+    function OnNextPredicate(predicate) {
+        this.predicate = predicate;
+    };
+
+    /** 
+     * @private 
+     * @memberOf OnNextPredicate#
+     */    
+    OnNextPredicate.prototype.equals = function (other) {
+        if (other === this) { return true; }
+        if (other == null) { return false; }
+        if (other.kind !== 'N') { return false; }
+        return this.predicate(other.value);
+    };
+
+    /** 
+     * @private 
+     * @constructor
+     */
+    function OnErrorPredicate(predicate) {
+        this.predicate = predicate;
+    };
+
+    /** 
+     * @private 
+     * @memberOf OnErrorPredicate#
+     */       
+    OnErrorPredicate.prototype.equals = function (other) {
+        if (other === this) { return true; }
+        if (other == null) { return false; }
+        if (other.kind !== 'E') { return false; }
+        return this.predicate(other.exception);
+    };
+
+    /** 
+     * @static
+     * type Object
+     */
+    var ReactiveTest = Rx.ReactiveTest = {
+        /** Default virtual time used for creation of observable sequences in unit tests. */
+        created: 100,
+        /** Default virtual time used to subscribe to observable sequences in unit tests. */
+        subscribed: 200,
+        /** Default virtual time used to dispose subscriptions in unit tests. */
+        disposed: 1000,
+
+        /**
+         * Factory method for an OnNext notification record at a given time with a given value or a predicate function.
+         * 
+         * 1 - ReactiveTest.onNext(200, 42);
+         * 2 - ReactiveTest.onNext(200, function (x) { return x.length == 2; });
+         * 
+         * @param ticks Recorded virtual time the OnNext notification occurs.
+         * @param value Recorded value stored in the OnNext notification or a predicate.
+         * @return Recorded OnNext notification.
+         */
+        onNext: function (ticks, value) {
+            if (typeof value === 'function') {
+                return new Recorded(ticks, new OnNextPredicate(value));
+            }
+            return new Recorded(ticks, Notification.createOnNext(value));
+        },
+        /**
+         * Factory method for an OnError notification record at a given time with a given error.
+         * 
+         * 1 - ReactiveTest.onNext(200, new Error('error'));
+         * 2 - ReactiveTest.onNext(200, function (e) { return e.message === 'error'; });
+         * 
+         * @param ticks Recorded virtual time the OnError notification occurs.
+         * @param exception Recorded exception stored in the OnError notification.
+         * @return Recorded OnError notification. 
+         */      
+        onError: function (ticks, exception) {
+            if (typeof exception === 'function') {
+                return new Recorded(ticks, new OnErrorPredicate(exception));
+            }
+            return new Recorded(ticks, Notification.createOnError(exception));
+        },
+        /**
+         * Factory method for an OnCompleted notification record at a given time.
+         * 
+         * @param ticks Recorded virtual time the OnCompleted notification occurs.
+         * @return Recorded OnCompleted notification.
+         */
+        onCompleted: function (ticks) {
+            return new Recorded(ticks, Notification.createOnCompleted());
+        },
+        /**
+         * Factory method for a subscription record based on a given subscription and disposal time.
+         * 
+         * @param start Virtual time indicating when the subscription was created.
+         * @param end Virtual time indicating when the subscription was disposed.
+         * @return Subscription object.
+         */
+        subscribe: function (start, end) {
+            return new Subscription(start, end);
+        }
+    };
+
+    /**
+     * Creates a new object recording the production of the specified value at the given virtual time.
+     *
+     * @constructor
+     * @param {Number} time Virtual time the value was produced on.
+     * @param {Mixed} value Value that was produced.
+     * @param {Function} comparer An optional comparer.
+     */
+    var Recorded = Rx.Recorded = function (time, value, comparer) {
+        this.time = time;
+        this.value = value;
+        this.comparer = comparer || defaultComparer;
+    };
+
+    /**
+     * Checks whether the given recorded object is equal to the current instance.
+     *
+     * @param {Recorded} other Recorded object to check for equality.
+     * @returns {Boolean} true if both objects are equal; false otherwise.  
+     */  
+    Recorded.prototype.equals = function (other) {
+        return this.time === other.time && this.comparer(this.value, other.value);
+    };
+
+    /**
+     * Returns a string representation of the current Recorded value.
+     *
+     * @returns {String} String representation of the current Recorded value. 
+     */   
+    Recorded.prototype.toString = function () {
+        return this.value.toString() + '@' + this.time;
+    };
+
+    /**
+     * Creates a new subscription object with the given virtual subscription and unsubscription time.
+     * 
+     * @constructor
+     * @param {Number} subscribe Virtual time at which the subscription occurred.
+     * @param {Number} unsubscribe Virtual time at which the unsubscription occurred.
+     */
+    var Subscription = Rx.Subscription = function (start, end) {
+        this.subscribe = start;
+        this.unsubscribe = end || Number.MAX_VALUE;
+    };
+
+    /**
+     * Checks whether the given subscription is equal to the current instance.
+     * @param other Subscription object to check for equality.
+     * @returns {Boolean} true if both objects are equal; false otherwise.
+     */
+    Subscription.prototype.equals = function (other) {
+        return this.subscribe === other.subscribe && this.unsubscribe === other.unsubscribe;
+    };
+
+    /**
+     * Returns a string representation of the current Subscription value.
+     * @returns {String} String representation of the current Subscription value.
+     */
+    Subscription.prototype.toString = function () {
+        return '(' + this.subscribe + ', ' + this.unsubscribe === Number.MAX_VALUE ? 'Infinite' : this.unsubscribe + ')';
+    };
+
+    /** @private */
+    var MockDisposable = Rx.MockDisposable = function (scheduler) {
+        this.scheduler = scheduler;
+        this.disposes = [];
+        this.disposes.push(this.scheduler.clock);
+    };
+
+    /*
+     * @memberOf MockDisposable#
+     * @prviate
+     */
+    MockDisposable.prototype.dispose = function () {
+        this.disposes.push(this.scheduler.clock);
+    };
+
+    /** @private */
+    var MockObserver = (function (_super) {
+        inherits(MockObserver, _super);
+
+        /*
+         * @constructor
+         * @prviate
+         */
+        function MockObserver(scheduler) {
+            _super.call(this);
+            this.scheduler = scheduler;
+            this.messages = [];
+        }
+
+        var MockObserverPrototype = MockObserver.prototype;
+
+        /*
+         * @memberOf MockObserverPrototype#
+         * @prviate
+         */
+        MockObserverPrototype.onNext = function (value) {
+            this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnNext(value)));
+        };
+
+        /*
+         * @memberOf MockObserverPrototype#
+         * @prviate
+         */
+        MockObserverPrototype.onError = function (exception) {
+            this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnError(exception)));
+        };
+
+        /*
+         * @memberOf MockObserverPrototype#
+         * @prviate
+         */
+        MockObserverPrototype.onCompleted = function () {
+            this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnCompleted()));
+        };
+
+        return MockObserver;
+    })(Observer);
+
+    /** @private */    
+    var HotObservable = (function (_super) {
+
+        function subscribe(observer) {
+            var observable = this;
+            this.observers.push(observer);
+            this.subscriptions.push(new Subscription(this.scheduler.clock));
+            var index = this.subscriptions.length - 1;
+            return disposableCreate(function () {
+                var idx = observable.observers.indexOf(observer);
+                observable.observers.splice(idx, 1);
+                observable.subscriptions[index] = new Subscription(observable.subscriptions[index].subscribe, observable.scheduler.clock);
+            });
+        }
+
+        inherits(HotObservable, _super);
+
+        /**
+         * @private
+         * @constructor
+         */
+        function HotObservable(scheduler, messages) {
+            _super.call(this, subscribe);
+            var message, notification, observable = this;
+            this.scheduler = scheduler;
+            this.messages = messages;
+            this.subscriptions = [];
+            this.observers = [];
+            for (var i = 0, len = this.messages.length; i < len; i++) {
+                message = this.messages[i];
+                notification = message.value;
+                (function (innerNotification) {
+                    scheduler.scheduleAbsoluteWithState(null, message.time, function () {
+                        var obs = observable.observers.slice(0);
+
+                        for (var j = 0, jLen = obs.length; j < jLen; j++) {
+                            innerNotification.accept(obs[j]);
+                        }
+                        return disposableEmpty;
+                    });
+                })(notification);
+            }
+        }
+
+        return HotObservable;
+    })(Observable);
+
+    /** @private */
+    var ColdObservable = (function (_super) {
+
+        function subscribe(observer) {
+            var message, notification, observable = this;
+            this.subscriptions.push(new Subscription(this.scheduler.clock));
+            var index = this.subscriptions.length - 1;
+            var d = new CompositeDisposable();
+            for (var i = 0, len = this.messages.length; i < len; i++) {
+                message = this.messages[i];
+                notification = message.value;
+                (function (innerNotification) {
+                    d.add(observable.scheduler.scheduleRelativeWithState(null, message.time, function () {
+                        innerNotification.accept(observer);
+                        return disposableEmpty;
+                    }));
+                })(notification);
+            }
+            return disposableCreate(function () {
+                observable.subscriptions[index] = new Subscription(observable.subscriptions[index].subscribe, observable.scheduler.clock);
+                d.dispose();
+            });
+        }
+
+        inherits(ColdObservable, _super);
+
+        /**
+         * @private
+         * @constructor
+         */
+        function ColdObservable(scheduler, messages) {
+            _super.call(this, subscribe);
+            this.scheduler = scheduler;
+            this.messages = messages;
+            this.subscriptions = [];
+        }
+
+        return ColdObservable;
+    })(Observable);
+
+    /** Virtual time scheduler used for testing applications and libraries built using Reactive Extensions. */
+    Rx.TestScheduler = (function (_super) {
+        inherits(TestScheduler, _super);
+
+        function baseComparer(x, y) {
+            return x > y ? 1 : (x < y ? -1 : 0);
+        }
+
+        /** @constructor */
+        function TestScheduler() {
+            _super.call(this, 0, baseComparer);
+        }
+
+        /**
+         * Schedules an action to be executed at the specified virtual time.
+         * 
+         * @param state State passed to the action to be executed.
+         * @param dueTime Absolute virtual time at which to execute the action.
+         * @param action Action to be executed.
+         * @return Disposable object used to cancel the scheduled action (best effort).
+         */
+        TestScheduler.prototype.scheduleAbsoluteWithState = function (state, dueTime, action) {
+            if (dueTime <= this.clock) {
+                dueTime = this.clock + 1;
+            }
+            return _super.prototype.scheduleAbsoluteWithState.call(this, state, dueTime, action);
+        };
+        /**
+         * Adds a relative virtual time to an absolute virtual time value.
+         * 
+         * @param absolute Absolute virtual time value.
+         * @param relative Relative virtual time value to add.
+         * @return Resulting absolute virtual time sum value.
+         */
+        TestScheduler.prototype.add = function (absolute, relative) {
+            return absolute + relative;
+        };
+        /**
+         * Converts the absolute virtual time value to a DateTimeOffset value.
+         * 
+         * @param absolute Absolute virtual time value to convert.
+         * @return Corresponding DateTimeOffset value.
+         */
+        TestScheduler.prototype.toDateTimeOffset = function (absolute) {
+            return new Date(absolute).getTime();
+        };
+        /**
+         * Converts the TimeSpan value to a relative virtual time value.
+         * 
+         * @param timeSpan TimeSpan value to convert.
+         * @return Corresponding relative virtual time value.
+         */
+        TestScheduler.prototype.toRelative = function (timeSpan) {
+            return timeSpan;
+        };
+        /**
+         * Starts the test scheduler and uses the specified virtual times to invoke the factory function, subscribe to the resulting sequence, and dispose the subscription.
+         * 
+         * @param create Factory method to create an observable sequence.
+         * @param created Virtual time at which to invoke the factory to create an observable sequence.
+         * @param subscribed Virtual time at which to subscribe to the created observable sequence.
+         * @param disposed Virtual time at which to dispose the subscription.
+         * @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
+         */        
+        TestScheduler.prototype.startWithTiming = function (create, created, subscribed, disposed) {
+            var observer = this.createObserver(), source, subscription;
+            this.scheduleAbsoluteWithState(null, created, function () {
+                source = create();
+                return disposableEmpty;
+            });
+            this.scheduleAbsoluteWithState(null, subscribed, function () {
+                subscription = source.subscribe(observer);
+                return disposableEmpty;
+            });
+            this.scheduleAbsoluteWithState(null, disposed, function () {
+                subscription.dispose();
+                return disposableEmpty;
+            });
+            this.start();
+            return observer;
+        };
+        /**
+         * Starts the test scheduler and uses the specified virtual time to dispose the subscription to the sequence obtained through the factory function.
+         * Default virtual times are used for factory invocation and sequence subscription.
+         * 
+         * @param create Factory method to create an observable sequence.
+         * @param disposed Virtual time at which to dispose the subscription.
+         * @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
+         */        
+        TestScheduler.prototype.startWithDispose = function (create, disposed) {
+            return this.startWithTiming(create, ReactiveTest.created, ReactiveTest.subscribed, disposed);
+        };
+        /**
+         * Starts the test scheduler and uses default virtual times to invoke the factory function, to subscribe to the resulting sequence, and to dispose the subscription.
+         * 
+         * @param create Factory method to create an observable sequence.
+         * @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
+         */        
+        TestScheduler.prototype.startWithCreate = function (create) {
+            return this.startWithTiming(create, ReactiveTest.created, ReactiveTest.subscribed, ReactiveTest.disposed);
+        };
+        /**
+         * Creates a hot observable using the specified timestamped notification messages either as an array or arguments.
+         * 
+         * @param messages Notifications to surface through the created sequence at their specified absolute virtual times.
+         * @return Hot observable sequence that can be used to assert the timing of subscriptions and notifications.
+         */        
+        TestScheduler.prototype.createHotObservable = function () {
+            var messages = argsOrArray(arguments, 0);
+            return new HotObservable(this, messages);
+        };
+        /**
+         * Creates a cold observable using the specified timestamped notification messages either as an array or arguments.
+         * 
+         * @param messages Notifications to surface through the created sequence at their specified virtual time offsets from the sequence subscription time.
+         * @return Cold observable sequence that can be used to assert the timing of subscriptions and notifications.
+         */        
+        TestScheduler.prototype.createColdObservable = function () {
+            var messages = argsOrArray(arguments, 0);
+            return new ColdObservable(this, messages);
+        };
+        /**
+         * Creates an observer that records received notification messages and timestamps those.
+         * 
+         * @return Observer that can be used to assert the timing of received notifications.
+         */
+        TestScheduler.prototype.createObserver = function () {
+            return new MockObserver(this);
+        };
+
+        return TestScheduler;
+    })(VirtualTimeScheduler);
+
+    return Rx;
+}));

js/libs/rxjs/rx.virtualtime.js

@@ -0,0 +1,335 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    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;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+	// Aliases
+	var Scheduler = Rx.Scheduler,
+		PriorityQueue = Rx.internals.PriorityQueue,
+		ScheduledItem = Rx.internals.ScheduledItem,
+		SchedulePeriodicRecursive  = Rx.internals.SchedulePeriodicRecursive,
+		disposableEmpty = Rx.Disposable.empty,
+		inherits = Rx.internals.inherits,
+    defaultSubComparer = Rx.helpers.defaultSubComparer;
+
+    /** Provides a set of extension methods for virtual time scheduling. */
+    Rx.VirtualTimeScheduler = (function (_super) {
+
+        function notImplemented() {
+            throw new Error('Not implemented');
+        }
+
+        function localNow() {
+            return this.toDateTimeOffset(this.clock);
+        }
+
+        function scheduleNow(state, action) {
+            return this.scheduleAbsoluteWithState(state, this.clock, action);
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            return this.scheduleRelativeWithState(state, this.toRelative(dueTime), action);
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this.scheduleRelativeWithState(state, this.toRelative(dueTime - this.now()), action);
+        }
+
+        function invokeAction(scheduler, action) {
+            action();
+            return disposableEmpty;
+        }
+
+        inherits(VirtualTimeScheduler, _super);
+
+        /**
+         * Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer.
+         *
+         * @constructor
+         * @param {Number} initialClock Initial value for the clock.
+         * @param {Function} comparer Comparer to determine causality of events based on absolute time.
+         */
+        function VirtualTimeScheduler(initialClock, comparer) {
+            this.clock = initialClock;
+            this.comparer = comparer;
+            this.isEnabled = false;
+            this.queue = new PriorityQueue(1024);
+            _super.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        }
+
+        var VirtualTimeSchedulerPrototype = VirtualTimeScheduler.prototype;
+
+        /**
+         * Adds a relative time value to an absolute time value.
+         * @param {Number} absolute Absolute virtual time value.
+         * @param {Number} relative Relative virtual time value to add.
+         * @return {Number} Resulting absolute virtual time sum value.
+         */
+        VirtualTimeSchedulerPrototype.add = notImplemented;
+
+        /**
+         * Converts an absolute time to a number 
+         * @param {Any} The absolute time.
+         * @returns {Number} The absolute time in ms
+         */
+        VirtualTimeSchedulerPrototype.toDateTimeOffset = notImplemented;
+
+        /**
+         * Converts the TimeSpan value to a relative virtual time value.       
+         * @param {Number} timeSpan TimeSpan value to convert.
+         * @return {Number} Corresponding relative virtual time value.
+         */
+        VirtualTimeSchedulerPrototype.toRelative = notImplemented;
+
+        /**
+         * Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. The periodic task will be emulated using recursive scheduling.       
+         * @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).
+         */      
+        VirtualTimeSchedulerPrototype.schedulePeriodicWithState = function (state, period, action) {
+            var s = new SchedulePeriodicRecursive(this, state, period, action);
+            return s.start();
+        };
+
+        /**
+         * Schedules an action to be executed after dueTime.
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Number} dueTime Relative time after which to execute the action.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */            
+        VirtualTimeSchedulerPrototype.scheduleRelativeWithState = function (state, dueTime, action) {
+            var runAt = this.add(this.clock, dueTime);
+            return this.scheduleAbsoluteWithState(state, runAt, action);
+        };
+
+        /**
+         * Schedules an action to be executed at dueTime.      
+         * @param {Number} dueTime Relative time after which to execute the action.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */          
+        VirtualTimeSchedulerPrototype.scheduleRelative = function (dueTime, action) {
+            return this.scheduleRelativeWithState(action, dueTime, invokeAction);
+        };    
+
+        /** 
+         * Starts the virtual time scheduler. 
+         */
+        VirtualTimeSchedulerPrototype.start = function () {
+            var next;
+            if (!this.isEnabled) {
+                this.isEnabled = true;
+                do {
+                    next = this.getNext();
+                    if (next !== null) {
+                        if (this.comparer(next.dueTime, this.clock) > 0) {
+                            this.clock = next.dueTime;
+                        }
+                        next.invoke();
+                    } else {
+                        this.isEnabled = false;
+                    }
+                } while (this.isEnabled);
+            }
+        };
+
+        /** 
+         * Stops the virtual time scheduler.  
+         */
+        VirtualTimeSchedulerPrototype.stop = function () {
+            this.isEnabled = false;
+        };
+
+        /**
+         * Advances the scheduler's clock to the specified time, running all work till that point.
+         * @param {Number} time Absolute time to advance the scheduler's clock to.
+         */
+        VirtualTimeSchedulerPrototype.advanceTo = function (time) {
+            var next;
+            var dueToClock = this.comparer(this.clock, time);
+            if (this.comparer(this.clock, time) > 0) {
+                throw new Error(argumentOutOfRange);
+            }
+            if (dueToClock === 0) {
+                return;
+            }
+            if (!this.isEnabled) {
+                this.isEnabled = true;
+                do {
+                    next = this.getNext();
+                    if (next !== null && this.comparer(next.dueTime, time) <= 0) {
+                        if (this.comparer(next.dueTime, this.clock) > 0) {
+                            this.clock = next.dueTime;
+                        }
+                        next.invoke();
+                    } else {
+                        this.isEnabled = false;
+                    }
+                } while (this.isEnabled);
+                this.clock = time;
+            }
+        };
+
+        /**
+         * Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan.
+         * @param {Number} time Relative time to advance the scheduler's clock by.
+         */
+        VirtualTimeSchedulerPrototype.advanceBy = function (time) {
+            var dt = this.add(this.clock, time);
+            var dueToClock = this.comparer(this.clock, dt);
+            if (dueToClock > 0) {
+                throw new Error(argumentOutOfRange);
+            }
+            if (dueToClock === 0) {
+                return;
+            }
+            this.advanceTo(dt);
+        };        
+
+        /**
+         * Advances the scheduler's clock by the specified relative time.      
+         * @param {Number} time Relative time to advance the scheduler's clock by.
+         */
+        VirtualTimeSchedulerPrototype.sleep = function (time) {
+            var dt = this.add(this.clock, time);
+
+            if (this.comparer(this.clock, dt) >= 0) {
+                throw new Error(argumentOutOfRange);
+            }
+
+            this.clock = dt;
+        };
+
+        /**
+         * Gets the next scheduled item to be executed.          
+         * @returns {ScheduledItem} The next scheduled item.
+         */          
+        VirtualTimeSchedulerPrototype.getNext = function () {
+            var next;
+            while (this.queue.length > 0) {
+                next = this.queue.peek();
+                if (next.isCancelled()) {
+                    this.queue.dequeue();
+                } else {
+                    return next;
+                }
+            }
+            return null;
+        };
+
+        /**
+         * Schedules an action to be executed at dueTime.       
+         * @param {Scheduler} scheduler Scheduler to execute the action on.
+         * @param {Number} dueTime Absolute time at which to execute the action.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */           
+        VirtualTimeSchedulerPrototype.scheduleAbsolute = function (dueTime, action) {
+            return this.scheduleAbsoluteWithState(action, dueTime, invokeAction);
+        };
+
+        /**
+         * Schedules an action to be executed at dueTime.
+         * @param {Mixed} state State passed to the action to be executed.
+         * @param {Number} dueTime Absolute time at which to execute the action.
+         * @param {Function} action Action to be executed.
+         * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
+         */
+        VirtualTimeSchedulerPrototype.scheduleAbsoluteWithState = function (state, dueTime, action) {
+            var self = this,
+                run = function (scheduler, state1) {
+                    self.queue.remove(si);
+                    return action(scheduler, state1);
+                },
+                si = new ScheduledItem(self, state, run, dueTime, self.comparer);
+            self.queue.enqueue(si);
+            return si.disposable;
+        };
+
+        return VirtualTimeScheduler;
+    }(Scheduler));
+
+    /** Provides a virtual time scheduler that uses Date for absolute time and number for relative time. */
+    Rx.HistoricalScheduler = (function (_super) {
+        inherits(HistoricalScheduler, _super);
+
+        /**
+         * Creates a new historical scheduler with the specified initial clock value.
+         * 
+         * @constructor
+         * @param {Number} initialClock Initial value for the clock.
+         * @param {Function} comparer Comparer to determine causality of events based on absolute time.
+         */
+        function HistoricalScheduler(initialClock, comparer) {
+            var clock = initialClock == null ? 0 : initialClock;
+            var cmp = comparer || defaultSubComparer;
+            _super.call(this, clock, cmp);
+        }
+
+        var HistoricalSchedulerProto = HistoricalScheduler.prototype;
+
+        /**
+         * Adds a relative time value to an absolute time value.
+         * @param {Number} absolute Absolute virtual time value.
+         * @param {Number} relative Relative virtual time value to add.
+         * @return {Number} Resulting absolute virtual time sum value.
+         */
+        HistoricalSchedulerProto.add = function (absolute, relative) {
+            return absolute + relative;
+        };
+
+        /**
+         * @private
+         */
+        HistoricalSchedulerProto.toDateTimeOffset = function (absolute) {
+            return new Date(absolute).getTime();
+        };
+
+        /**
+         * Converts the TimeSpan value to a relative virtual time value.
+         * 
+         * @memberOf HistoricalScheduler         
+         * @param {Number} timeSpan TimeSpan value to convert.
+         * @return {Number} Corresponding relative virtual time value.
+         */
+        HistoricalSchedulerProto.toRelative = function (timeSpan) {
+            return timeSpan;
+        };
+
+        return HistoricalScheduler;    
+    }(Rx.VirtualTimeScheduler));
+    return Rx;
+}));

js/libs/rxjs/rx.virtualtime.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){var d=c.Scheduler,e=c.internals.PriorityQueue,f=c.internals.ScheduledItem,g=c.internals.SchedulePeriodicRecursive,h=c.Disposable.empty,i=c.internals.inherits,j=c.helpers.defaultSubComparer;return c.VirtualTimeScheduler=function(a){function b(){throw new Error("Not implemented")}function c(){return this.toDateTimeOffset(this.clock)}function d(a,b){return this.scheduleAbsoluteWithState(a,this.clock,b)}function j(a,b,c){return this.scheduleRelativeWithState(a,this.toRelative(b),c)}function k(a,b,c){return this.scheduleRelativeWithState(a,this.toRelative(b-this.now()),c)}function l(a,b){return b(),h}function m(b,f){this.clock=b,this.comparer=f,this.isEnabled=!1,this.queue=new e(1024),a.call(this,c,d,j,k)}i(m,a);var n=m.prototype;return n.add=b,n.toDateTimeOffset=b,n.toRelative=b,n.schedulePeriodicWithState=function(a,b,c){var d=new g(this,a,b,c);return d.start()},n.scheduleRelativeWithState=function(a,b,c){var d=this.add(this.clock,b);return this.scheduleAbsoluteWithState(a,d,c)},n.scheduleRelative=function(a,b){return this.scheduleRelativeWithState(b,a,l)},n.start=function(){var a;if(!this.isEnabled){this.isEnabled=!0;do a=this.getNext(),null!==a?(this.comparer(a.dueTime,this.clock)>0&&(this.clock=a.dueTime),a.invoke()):this.isEnabled=!1;while(this.isEnabled)}},n.stop=function(){this.isEnabled=!1},n.advanceTo=function(a){var b,c=this.comparer(this.clock,a);if(this.comparer(this.clock,a)>0)throw new Error(argumentOutOfRange);if(0!==c&&!this.isEnabled){this.isEnabled=!0;do b=this.getNext(),null!==b&&this.comparer(b.dueTime,a)<=0?(this.comparer(b.dueTime,this.clock)>0&&(this.clock=b.dueTime),b.invoke()):this.isEnabled=!1;while(this.isEnabled);this.clock=a}},n.advanceBy=function(a){var b=this.add(this.clock,a),c=this.comparer(this.clock,b);if(c>0)throw new Error(argumentOutOfRange);0!==c&&this.advanceTo(b)},n.sleep=function(a){var b=this.add(this.clock,a);if(this.comparer(this.clock,b)>=0)throw new Error(argumentOutOfRange);this.clock=b},n.getNext=function(){for(var a;this.queue.length>0;){if(a=this.queue.peek(),!a.isCancelled())return a;this.queue.dequeue()}return null},n.scheduleAbsolute=function(a,b){return this.scheduleAbsoluteWithState(b,a,l)},n.scheduleAbsoluteWithState=function(a,b,c){var d=this,e=function(a,b){return d.queue.remove(g),c(a,b)},g=new f(d,a,e,b,d.comparer);return d.queue.enqueue(g),g.disposable},m}(d),c.HistoricalScheduler=function(a){function b(b,c){var d=null==b?0:b,e=c||j;a.call(this,d,e)}i(b,a);var c=b.prototype;return c.add=function(a,b){return a+b},c.toDateTimeOffset=function(a){return new Date(a).getTime()},c.toRelative=function(a){return a},b}(c.VirtualTimeScheduler),c});