linq 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2903de0191e0f8a7c528d7b8afd3c44c627c98d
-  data.tar.gz: 3e0324b1aecd25dad38b5a8bb039bf5664f45c39
+  metadata.gz: 433c6112866c6b70dc18175617f1126d13530974
+  data.tar.gz: cc0a2182ddb7e24eb246a5b108156463762724fb
 SHA512:
-  metadata.gz: 476ec94dd8ecfb0fd8c11c8e6e1f4fa742d38308296bdda190e974082af60d871d5c9a33ee81a6d8d0b3adcd536e267b00915c031f011fedf98343e2e5685e71
-  data.tar.gz: 05df2a7eb5bc73a008c36fb8e0c0359e803e419baf72a5423a33f4cc45fec44db3b7fec88ea9446e18b1587b05e1e5d9e74c7202eb3eb6c20f18033549c40763
+  metadata.gz: d725ee4ddb35f3a0aa1ddbb746578e4baa125a4ca37e4fdd19606460a200c2023c8bdefaaa3cf75416fa01c911bcd3d282b45173e284ba557283f4c68001cf9c
+  data.tar.gz: 90eefd1d392a3d4ce51b034075c8a82ec37e51cb4aa9891b4d27df2c566f4df57a1971ed6f5bfed18475b559fd2f7cd103761f6b4f670d0dbb7fec559da42931

data/lib/linq/version.rb

@@ -1,3 +1,3 @@
 module Linq
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

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

@@ -0,0 +1,3024 @@
+/**
+* @preserve Copyright (c) Microsoft Corporation.  All rights reserved.
+* This code is licensed by Microsoft Corporation under the terms
+* of the Microsoft Reference Source License (MS-RSL).
+* http://referencesource.microsoft.com/referencesourcelicense.aspx.
+*/
+
+(function (window, undefined) {
+    var freeExports = typeof exports == 'object' && exports &&
+        (typeof global == 'object' && global && global == global.global && (window = global), exports);
+
+    var root = { Internals: {} };
+    
+    // Defaults
+    function noop() { }
+    function identity(x) { return x; }
+    function defaultNow() { return new Date().getTime(); }
+    function defaultComparer(x, y) { return x === y; }
+    function defaultSubComparer(x, y) { return x - y; }
+    function defaultKeySerializer(x) { return x.toString(); }
+    function defaultError(err) { throw err; }
+
+    // Errors
+    var sequenceContainsNoElements = 'Sequence contains no elements.';
+    var argumentOutOfRange = 'Argument out of range';
+    var objectDisposed = 'Object has been disposed';
+    function checkDisposed() {
+        if (this.isDisposed) {
+            throw new Error(objectDisposed);
+        }
+    }
+    
+    // Utilities
+    if (!Function.prototype.bind) {
+        Function.prototype.bind = function (thisp) {
+            var target = this,
+                args = slice.call(arguments, 1);
+            var bound = function () {
+                if (this instanceof bound) {
+                    function F() { }
+                    F.prototype = target.prototype;
+                    var self = new F();
+                    var result = target.apply(self, args.concat(slice.call(arguments)));
+                    if (Object(result) === result) {
+                        return result;
+                    }
+                    return self;
+                } else {
+                    return target.apply(that, args.concat(slice.call(arguments)));
+                }
+            };
+
+            return bound;
+        };
+    }
+    var slice = Array.prototype.slice;
+    function argsOrArray(args, idx) {
+        return args.length === 1 && Array.isArray(args[idx]) ?
+            args[idx] :
+            slice.call(args);
+    }
+    var hasProp = {}.hasOwnProperty;
+    var inherits = root.Internals.inherits = function (child, parent) {
+        for (var key in parent) {
+            if (key !== 'prototype' && hasProp.call(parent, key)) child[key] = parent[key];
+        }
+        function ctor() { this.constructor = child; }
+        ctor.prototype = parent.prototype;
+        child.prototype = new ctor();
+        child.super_ = parent.prototype;
+        return child;
+    };
+    var addProperties = root.Internals.addProperties = function (obj) {
+        var sources = slice.call(arguments, 1);
+        for (var i = 0, len = sources.length; i < len; i++) {
+            var source = sources[i];
+            for (var prop in source) {
+                obj[prop] = source[prop];
+            }
+        }
+    };
+
+    // Rx Utils
+    var addRef = root.Internals.addRef = function (xs, r) {
+        return new AnonymousObservable(function (observer) {
+            return new CompositeDisposable(r.getDisposable(), xs.subscribe(observer));
+        });
+    };
+
+    // Collection polyfills
+    function arrayInitialize(count, factory) {
+        var a = new Array(count);
+        for (var i = 0; i < count; i++) {
+            a[i] = factory();
+        }
+        return a;
+    }
+    if (!Array.prototype.every) {
+        Array.prototype.every = function (predicate) {
+            var t = new Object(this);
+            for (var i = 0, len = t.length >>> 0; i < len; i++) {
+                if (i in t && !predicate.call(arguments[1], t[i], i, t)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+    }
+    if (!Array.prototype.map) {
+        Array.prototype.map = function (selector) {
+            var results = [], t = new Object(this);
+            for (var i = 0, len = t.length >>> 0; i < len; i++) {
+                if (i in t) {
+                    results.push(selector.call(arguments[1], t[i], i, t));
+                }
+            }
+            return results;
+        };
+    }
+    if (!Array.prototype.filter) {
+        Array.prototype.filter = function (predicate) {
+            var results = [], item, t = new Object(this);
+            for (var i = 0, len = t.length >>> 0; i < len; i++) {
+                item = t[i];
+                if (i in t && predicate.call(arguments[1], item, i, t)) {
+                    results.push(item);
+                }
+            }
+            return results;
+        };
+    }
+    if (!Array.isArray) {
+        Array.isArray = function (arg) {
+            return Object.prototype.toString.call(arg) == '[object Array]';
+        };
+    }
+    if (!Array.prototype.indexOf) {
+        Array.prototype.indexOf = function indexOf(item) {
+            var self = new Object(this), length = self.length >>> 0;
+            if (!length) {
+                return -1;
+            }
+            var i = 0;
+            if (arguments.length > 1) {
+                i = arguments[1];
+            }
+            i = i >= 0 ? i : Math.max(0, length + i);
+            for (; i < length; i++) {
+                if (i in self && self[i] === item) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+    }
+
+    // Collections
+    var IndexedItem = function (id, value) {
+        this.id = id;
+        this.value = value;
+    };
+
+    IndexedItem.prototype.compareTo = function (other) {
+        var c = this.value.compareTo(other.value);
+        if (c === 0) {
+            c = this.id - other.id;
+        }
+        return c;
+    };
+
+    // Priority Queue for Scheduling
+    var PriorityQueue = function (capacity) {
+        this.items = new Array(capacity);
+        this.length = 0;
+    };
+    var priorityProto = PriorityQueue.prototype;
+    priorityProto.isHigherPriority = function (left, right) {
+        return this.items[left].compareTo(this.items[right]) < 0;
+    };
+    priorityProto.percolate = function (index) {
+        if (index >= this.length || index < 0) {
+            return;
+        }
+        var parent = index - 1 >> 1;
+        if (parent < 0 || parent === index) {
+            return;
+        }
+        if (this.isHigherPriority(index, parent)) {
+            var temp = this.items[index];
+            this.items[index] = this.items[parent];
+            this.items[parent] = temp;
+            this.percolate(parent);
+        }
+    };
+    priorityProto.heapify = function (index) {
+        if (index === undefined) {
+            index = 0;
+        }
+        if (index >= this.length || index < 0) {
+            return;
+        }
+        var left = 2 * index + 1,
+            right = 2 * index + 2,
+            first = index;
+        if (left < this.length && this.isHigherPriority(left, first)) {
+            first = left;
+        }
+        if (right < this.length && this.isHigherPriority(right, first)) {
+            first = right;
+        }
+        if (first !== index) {
+            var temp = this.items[index];
+            this.items[index] = this.items[first];
+            this.items[first] = temp;
+            this.heapify(first);
+        }
+    };
+    priorityProto.peek = function () {
+        return this.items[0].value;
+    };
+    priorityProto.removeAt = function (index) {
+        this.items[index] = this.items[--this.length];
+        delete this.items[this.length];
+        this.heapify();
+    };
+    priorityProto.dequeue = function () {
+        var result = this.peek();
+        this.removeAt(0);
+        return result;
+    };
+    priorityProto.enqueue = function (item) {
+        var index = this.length++;
+        this.items[index] = new IndexedItem(PriorityQueue.count++, item);
+        this.percolate(index);
+    };
+    priorityProto.remove = function (item) {
+        for (var i = 0; i < this.length; i++) {
+            if (this.items[i].value === item) {
+                this.removeAt(i);
+                return true;
+            }
+        }
+        return false;
+    };
+    PriorityQueue.count = 0;
+    var CompositeDisposable = root.CompositeDisposable = function () {
+        this.disposables = argsOrArray(arguments, 0);
+        this.isDisposed = false;
+        this.length = this.disposables.length;
+    };
+    CompositeDisposable.prototype.add = function (item) {
+        if (this.isDisposed) {
+            item.dispose();
+        } else {
+            this.disposables.push(item);
+            this.length++;
+        }
+    };
+    CompositeDisposable.prototype.remove = function (item) {
+        var shouldDispose = false;
+        if (!this.isDisposed) {
+            var idx = this.disposables.indexOf(item);
+            if (idx !== -1) {
+                shouldDispose = true;
+                this.disposables.splice(idx, 1);
+                this.length--;
+                item.dispose();
+            }
+
+        }
+        return shouldDispose;
+    };
+    CompositeDisposable.prototype.dispose = function () {
+        if (!this.isDisposed) {
+            this.isDisposed = true;
+            var currentDisposables = this.disposables.slice(0);
+            this.disposables = [];
+            this.length = 0;
+
+            for (var i = 0, len = currentDisposables.length; i < len; i++) {
+                currentDisposables[i].dispose();
+            }
+        }
+    };
+    CompositeDisposable.prototype.clear = function () {
+        var currentDisposables = this.disposables.slice(0);
+        this.disposables = [];
+        this.length = 0;
+        for (var i = 0, len = currentDisposables.length; i < len; i++) {
+            currentDisposables[i].dispose();
+        }
+    };
+    CompositeDisposable.prototype.contains = function (item) {
+        return this.disposables.indexOf(item) !== -1;
+    };
+    CompositeDisposable.prototype.toArray = function () {
+        return this.disposables.slice(0);
+    };
+    
+    // Main disposable class
+    var Disposable = root.Disposable = function (action) {
+        this.isDisposed = false;
+        this.action = action;
+    };
+    Disposable.prototype.dispose = function () {
+        if (!this.isDisposed) {
+            this.action();
+            this.isDisposed = true;
+        }
+    };
+
+    var disposableCreate = Disposable.create = function (action) { return new Disposable(action); },
+        disposableEmpty = Disposable.empty = { dispose: noop };
+
+    // Single assignment
+    var SingleAssignmentDisposable = root.SingleAssignmentDisposable = function () {
+        this.isDisposed = false;
+        this.current = null;
+    };
+    SingleAssignmentDisposable.prototype.disposable = function (value) {
+        return !value ? this.getDisposable() : this.setDisposable(value);
+    };
+    SingleAssignmentDisposable.prototype.getDisposable = function () {
+        return this.current;
+    };
+    SingleAssignmentDisposable.prototype.setDisposable = function (value) {
+        if (this.current) {
+            throw new Error('Disposable has already been assigned');
+        }
+        var shouldDispose = this.isDisposed;
+        if (!shouldDispose) {
+            this.current = value;
+        }
+        if (shouldDispose && value) {
+            value.dispose();
+        }
+    };
+    SingleAssignmentDisposable.prototype.dispose = function () {
+        var old;
+        if (!this.isDisposed) {
+            this.isDisposed = true;
+            old = this.current;
+            this.current = null;
+        }
+        if (old) {
+            old.dispose();
+        }
+    };
+
+    // Multiple assignment disposable
+    var SerialDisposable = root.SerialDisposable = function () {
+        this.isDisposed = false;
+        this.current = null;
+    };
+    SerialDisposable.prototype.getDisposable = function () {
+        return this.current;
+    };
+    SerialDisposable.prototype.setDisposable = function (value) {
+        var shouldDispose = this.isDisposed, old;
+        if (!shouldDispose) {
+            old = this.current;
+            this.current = value;
+        }
+        if (old) {
+            old.dispose();
+        }
+        if (shouldDispose && value) {
+            value.dispose();
+        }
+    };
+    SerialDisposable.prototype.disposable = function (value) {
+        if (!value) {
+            return this.getDisposable();
+        } else {
+            this.setDisposable(value);
+        }
+    };
+    SerialDisposable.prototype.dispose = function () {
+        var old;
+        if (!this.isDisposed) {
+            this.isDisposed = true;
+            old = this.current;
+            this.current = null;
+        }
+        if (old) {
+            old.dispose();
+        }
+    };
+
+    var RefCountDisposable = root.RefCountDisposable = (function () {
+
+        function InnerDisposable(disposable) {
+            this.disposable = disposable;
+            this.disposable.count++;
+            this.isInnerDisposed = false;
+        }
+
+        InnerDisposable.prototype.dispose = function () {
+            if (!this.disposable.isDisposed) {
+                if (!this.isInnerDisposed) {
+                    this.isInnerDisposed = true;
+                    this.disposable.count--;
+                    if (this.disposable.count === 0 && this.disposable.isPrimaryDisposed) {
+                        this.disposable.isDisposed = true;
+                        this.disposable.underlyingDisposable.dispose();
+                    }
+                }
+            }
+        };
+
+        function RefCountDisposable(disposable) {
+            this.underlyingDisposable = disposable;
+            this.isDisposed = false;
+            this.isPrimaryDisposed = false;
+            this.count = 0;
+        }
+
+        RefCountDisposable.prototype.dispose = function () {
+            if (!this.isDisposed) {
+                if (!this.isPrimaryDisposed) {
+                    this.isPrimaryDisposed = true;
+                    if (this.count === 0) {
+                        this.isDisposed = true;
+                        this.underlyingDisposable.dispose();
+                    }
+                }
+            }
+        };
+        RefCountDisposable.prototype.getDisposable = function () {
+            return this.isDisposed ? disposableEmpty : new InnerDisposable(this);
+        };
+
+        return RefCountDisposable;
+    })();
+
+    function ScheduledDisposable(scheduler, disposable) {
+        this.scheduler = scheduler, this.disposable = disposable, this.isDisposed = false;
+    }
+    ScheduledDisposable.prototype.dispose = function () {
+        var parent = this;
+        this.scheduler.schedule(function () {
+            if (!parent.isDisposed) {
+                parent.isDisposed = true;
+                parent.disposable.dispose();
+            }
+        });
+    };
+
+    function ScheduledItem(scheduler, state, action, dueTime, comparer) {
+        this.scheduler = scheduler;
+        this.state = state;
+        this.action = action;
+        this.dueTime = dueTime;
+        this.comparer = comparer || defaultSubComparer;
+        this.disposable = new SingleAssignmentDisposable();
+    }
+    ScheduledItem.prototype.invoke = function () {
+        this.disposable.disposable(this.invokeCore());
+    };
+    ScheduledItem.prototype.compareTo = function (other) {
+        return this.comparer(this.dueTime, other.dueTime);
+    };
+    ScheduledItem.prototype.isCancelled = function () {
+        return this.disposable.isDisposed;
+    };
+    ScheduledItem.prototype.invokeCore = function () {
+        return this.action(this.scheduler, this.state);
+    };
+
+    var Scheduler = root.Scheduler = (function () {
+        function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) {
+            this.now = now;
+            this._schedule = schedule;
+            this._scheduleRelative = scheduleRelative;
+            this._scheduleAbsolute = scheduleAbsolute;
+        }
+
+        function invokeRecImmediate(scheduler, pair) {
+            var state = pair.first, action = pair.second, group = new CompositeDisposable(),
+            recursiveAction = function (state1) {
+                action(state1, function (state2) {
+                    var isAdded = false, isDone = false,
+                    d = scheduler.scheduleWithState(state2, function (scheduler1, state3) {
+                        if (isAdded) {
+                            group.remove(d);
+                        } else {
+                            isDone = true;
+                        }
+                        recursiveAction(state3);
+                        return disposableEmpty;
+                    });
+                    if (!isDone) {
+                        group.add(d);
+                        isAdded = true;
+                    }
+                });
+            };
+            recursiveAction(state);
+            return group;
+        }
+
+        function invokeRecDate(scheduler, pair, method) {
+            var state = pair.first, action = pair.second, group = new CompositeDisposable(),
+            recursiveAction = function (state1) {
+                action(state1, function (state2, dueTime1) {
+                    var isAdded = false, isDone = false,
+                    d = scheduler[method].call(scheduler, state2, dueTime1, function (scheduler1, state3) {
+                        if (isAdded) {
+                            group.remove(d);
+                        } else {
+                            isDone = true;
+                        }
+                        recursiveAction(state3);
+                        return disposableEmpty;
+                    });
+                    if (!isDone) {
+                        group.add(d);
+                        isAdded = true;
+                    }
+                });
+            };
+            recursiveAction(state);
+            return group;
+        }
+
+        function invokeAction(scheduler, action) {
+            action();
+            return disposableEmpty;
+        }
+
+        var schedulerProto = Scheduler.prototype;
+        schedulerProto.catchException = function (handler) {
+            return new CatchScheduler(this, handler);
+        };
+        
+        schedulerProto.schedulePeriodic = function (period, action) {
+            return this.schedulePeriodicWithState(null, period, function () {
+                action();
+            });
+        };
+
+        schedulerProto.schedulePeriodicWithState = function (state, period, action) {
+            var s = state, id = window.setInterval(function () {
+                s = action(s);
+            }, period);
+            return disposableCreate(function () {
+                window.clearInterval(id);
+            });
+        };
+
+        schedulerProto.schedule = function (action) {
+            return this._schedule(action, invokeAction);
+        };
+
+        schedulerProto.scheduleWithState = function (state, action) {
+            return this._schedule(state, action);
+        };
+
+        schedulerProto.scheduleWithRelative = function (dueTime, action) {
+            return this._scheduleRelative(action, dueTime, invokeAction);
+        };
+
+        schedulerProto.scheduleWithRelativeAndState = function (state, dueTime, action) {
+            return this._scheduleRelative(state, dueTime, action);
+        };
+
+        schedulerProto.scheduleWithAbsolute = function (dueTime, action) {
+            return this._scheduleAbsolute(action, dueTime, invokeAction);
+        };
+
+        schedulerProto.scheduleWithAbsoluteAndState = function (state, dueTime, action) {
+            return this._scheduleAbsolute(state, dueTime, action);
+        };
+
+        schedulerProto.scheduleRecursive = function (action) {
+            return this.scheduleRecursiveWithState(action, function (_action, self) {
+                _action(function () {
+                    self(_action);
+                });
+            });
+        };
+
+        schedulerProto.scheduleRecursiveWithState = function (state, action) {
+            return this.scheduleWithState({ first: state, second: action }, function (s, p) {
+                return invokeRecImmediate(s, p);
+            });
+        };
+
+        schedulerProto.scheduleRecursiveWithRelative = function (dueTime, action) {
+            return this.scheduleRecursiveWithRelativeAndState(action, dueTime, function (_action, self) {
+                _action(function (dt) {
+                    self(_action, dt);
+                });
+            });
+        };
+
+        schedulerProto.scheduleRecursiveWithRelativeAndState = function (state, dueTime, action) {
+            return this._scheduleRelative({ first: state, second: action }, dueTime, function (s, p) {
+                return invokeRecDate(s, p, 'scheduleWithRelativeAndState');
+            });
+        };
+
+        schedulerProto.scheduleRecursiveWithAbsolute = function (dueTime, action) {
+            return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, function (_action, self) {
+                _action(function (dt) {
+                    self(_action, dt);
+                });
+            });
+        };
+
+        schedulerProto.scheduleRecursiveWithAbsoluteAndState = function (state, dueTime, action) {
+            return this._scheduleAbsolute({ first: state, second: action }, dueTime, function (s, p) {
+                return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
+            });
+        };
+
+        Scheduler.now = defaultNow;
+        Scheduler.normalize = function (timeSpan) {
+            if (timeSpan < 0) {
+                timeSpan = 0;
+            }
+            return timeSpan;
+        };
+
+        return Scheduler;
+    }());
+    
+    // Immediate Scheduler
+    var schedulerNoBlockError = 'Scheduler is not allowed to block the thread';
+    var immediateScheduler = Scheduler.immediate = (function () {
+
+        function scheduleNow(state, action) {
+            return action(this, state);
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            if (dueTime > 0) throw new Error(schedulerNoBlockError);
+            return action(this, state);
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+        }
+
+        return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+    }());
+
+    // Current Thread Scheduler
+    var currentThreadScheduler = Scheduler.currentThread = (function () {
+        var queue;
+
+        function Trampoline() {
+            queue = new PriorityQueue(4);
+        }
+
+        Trampoline.prototype.dispose = function () {
+            queue = null;
+        };
+
+        Trampoline.prototype.run = function () {
+            var item;
+            while (queue.length > 0) {
+                item = queue.dequeue();
+                if (!item.isCancelled()) {
+                    while (item.dueTime - Scheduler.now() > 0) {
+                    }
+                    if (!item.isCancelled()) {
+                        item.invoke();
+                    }
+                }
+            }
+        };
+
+        function scheduleNow(state, action) {
+            return this.scheduleWithRelativeAndState(state, 0, action);
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            var dt = this.now() + Scheduler.normalize(dueTime),
+                    si = new ScheduledItem(this, state, action, dt),
+                    t;
+            if (!queue) {
+                t = new Trampoline();
+                try {
+                    queue.enqueue(si);
+                    t.run();
+                } finally {
+                    t.dispose();
+                }
+            } else {
+                queue.enqueue(si);
+            }
+            return si.disposable;
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+        }
+
+        var currentScheduler = new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        currentScheduler.scheduleRequired = function () { return queue === null; };
+        currentScheduler.ensureTrampoline = function (action) {
+            if (queue === null) {
+                return this.schedule(action);
+            } else {
+                return action();
+            }
+        };
+
+        return currentScheduler;
+    }());
+
+    var SchedulePeriodicRecursive = (function () {
+        function tick(command, recurse) {
+            recurse(0, this._period);
+            try {
+                this._state = this._action(this._state);
+            } catch (e) {
+                this._cancel.dispose();
+                throw e;
+            }
+        }
+
+        function SchedulePeriodicRecursive(scheduler, state, period, action) {
+            this._scheduler = scheduler;
+            this._state = state;
+            this._period = period;
+            this._action = action;
+        }
+
+        SchedulePeriodicRecursive.prototype.start = function () {
+            var d = new SingleAssignmentDisposable();
+            this._cancel = d;
+            d.setDisposable(this._scheduler.scheduleRecursiveWithRelativeAndState(0, this._period, tick.bind(this)));
+
+            return d;
+        };
+
+        return SchedulePeriodicRecursive;
+    }());
+
+    // Virtual Scheduler
+    root.VirtualTimeScheduler = (function () {
+
+        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, Scheduler);
+
+        function VirtualTimeScheduler(initialClock, comparer) {
+            this.clock = initialClock;
+            this.comparer = comparer;
+            this.isEnabled = false;
+            this.queue = new PriorityQueue(1024);
+            VirtualTimeScheduler.super_.constructor.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        }
+
+        addProperties(VirtualTimeScheduler.prototype, {
+            schedulePeriodicWithState: function (state, period, action) {
+                var s = new SchedulePeriodicRecursive(this, state, period, action);
+                return s.start();
+            },
+            scheduleRelativeWithState: function (state, dueTime, action) {
+                var runAt = this.add(this.clock, dueTime);
+                return this.scheduleAbsoluteWithState(state, runAt, action);
+            },
+            scheduleRelative: function (dueTime, action) {
+                return this.scheduleRelativeWithState(action, dueTime, invokeAction);
+            },
+            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);
+                }
+            },
+            stop: function () {
+                this.isEnabled = false;
+            },
+            advanceTo: function (time) {
+                var next;
+                if (this.comparer(this.clock, time) >= 0) {
+                    throw new Error(argumentOutOfRange);
+                }
+                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;
+                }
+            },
+            advanceBy: function (time) {
+                var dt = this.add(this.clock, time);
+                if (this.comparer(this.clock, dt) >= 0) {
+                    throw new Error(argumentOutOfRange);
+                }
+                return this.advanceTo(dt);
+            },
+            sleep: function (time) {
+                var dt = this.add(this.clock, time);
+
+                if (this.comparer(this.clock, dt) >= 0) {
+                    throw new Error(argumentOutOfRange);
+                }
+
+                this.clock = dt;
+            },
+            getNext: function () {
+                var next;
+                while (this.queue.length > 0) {
+                    next = this.queue.peek();
+                    if (next.isCancelled()) {
+                        this.queue.dequeue();
+                    } else {
+                        return next;
+                    }
+                }
+                return null;
+            },
+            scheduleAbsolute: function (dueTime, action) {
+                return this.scheduleAbsoluteWithState(action, dueTime, invokeAction);
+            },
+            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;
+    }());
+
+    // Timeout Scheduler
+    var timeoutScheduler = Scheduler.timeout = (function () {
+
+        // Optimize for speed
+        var reqAnimFrame = window.requestAnimationFrame ||
+            window.webkitRequestAnimationFrame ||
+            window.mozRequestAnimationFrame ||
+            window.oRequestAnimationFrame ||
+            window.msRequestAnimationFrame,
+        clearAnimFrame = window.cancelAnimationFrame ||
+            window.webkitCancelAnimationFrame ||
+            window.mozCancelAnimationFrame ||
+            window.oCancelAnimationFrame ||
+            window.msCancelAnimationFrame;
+
+        var scheduleMethod, clearMethod;
+        if (typeof window.process !== 'undefined' && typeof window.process.nextTick === 'function') {
+            scheduleMethod = window.process.nextTick;
+            clearMethod = noop;
+        } else if (typeof window.setImmediate === 'function') {
+            scheduleMethod = window.setImmediate;
+            clearMethod = window.clearImmediate;
+        } else if (typeof reqAnimFrame === 'function') {
+            scheduleMethod = reqAnimFrame;
+            clearMethod = clearAnimFrame;
+        } else {
+            scheduleMethod = function (action) { return window.setTimeout(action, 0); };
+            clearMethod = window.clearTimeout;
+        }
+
+        function scheduleNow(state, action) {
+            var scheduler = this;
+            var disposable = new SingleAssignmentDisposable();
+            var id = scheduleMethod(function () {
+                disposable.setDisposable(action(scheduler, state));
+            });
+            return new CompositeDisposable(disposable, disposableCreate(function () {
+                clearMethod(id);
+            }));
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            var scheduler = this;
+            var dt = Scheduler.normalize(dueTime);
+            if (dt === 0) {
+                return scheduler.scheduleWithState(state, action);
+            }
+            var disposable = new SingleAssignmentDisposable();
+            var id = window.setTimeout(function () {
+                disposable.setDisposable(action(scheduler, state));
+            }, dt);
+            return new CompositeDisposable(disposable, disposableCreate(function () {
+                window.clearTimeout(id);
+            }));
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action);
+        }
+
+        return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+    })();
+
+    // CatchScheduler
+    var CatchScheduler = (function () {
+
+        function localNow() {
+            return this._scheduler.now();
+        }
+
+        function scheduleNow(state, action) {
+            return this._scheduler.scheduleWithState(state, this._wrap(action));
+        }
+
+        function scheduleRelative(state, dueTime, action) {
+            return this._scheduler.scheduleWithRelativeAndState(state, dueTime, this._wrap(action));
+        }
+
+        function scheduleAbsolute(state, dueTime, action) {
+            return this._scheduler.scheduleWithAbsoluteAndState(state, dueTime, this._wrap(action));
+        }
+
+        inherits(CatchScheduler, Scheduler);
+        function CatchScheduler(scheduler, handler) {
+            this._scheduler = scheduler;
+            this._handler = handler;
+            this._recursiveOriginal = null;
+            this._recursiveWrapper = null;
+            CatchScheduler.super_.constructor.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute);
+        }
+
+        CatchScheduler.prototype._clone = function (scheduler) {
+            return new CatchScheduler(scheduler, this._handler);
+        };
+
+        CatchScheduler.prototype._wrap = function (action) {
+            var parent = this;
+            return function (self, state) {
+                try {
+                    return action(parent._getRecursiveWrapper(self), state);
+                } catch (e) {
+                    if (!parent._handler(e)) { throw e; }
+                    return disposableEmpty;
+                }
+            };
+        };
+
+        CatchScheduler.prototype._getRecursiveWrapper = function (scheduler) {
+            if (!this._recursiveOriginal !== scheduler) {
+                this._recursiveOriginal = scheduler;
+                var wrapper = this._clone(scheduler);
+                wrapper._recursiveOriginal = scheduler;
+                wrapper._recursiveWrapper = wrapper;
+                this._recursiveWrapper = wrapper;
+            }
+            return this._recursiveWrapper;
+        };
+
+        CatchScheduler.prototype.schedulePeriodicWithState = function (state, period, action) {
+            var self = this, failed = false, d = new SingleAssignmentDisposable();
+
+            d.setDisposable(this._scheduler.schedulePeriodicWithState(state, period, function (state1) {
+                if (failed) { return null; }
+                try {
+                    return action(state1);
+                } catch (e) {
+                    failed = true;
+                    if (!self._handler(e)) { throw e; }
+                    d.dispose();
+                    return null;
+                }
+            }));
+
+            return d;
+        };
+
+        return CatchScheduler;
+    }());
+
+    // Notifications
+
+    var Notification = root.Notification = (function () {
+        function Notification() { }
+
+        addProperties(Notification.prototype, {
+            accept: function (observerOrOnNext, onError, onCompleted) {
+                if (arguments.length > 1 || typeof observerOrOnNext === 'function') {
+                    return this._accept(observerOrOnNext, onError, onCompleted);
+                } else {
+                    return this._acceptObservable(observerOrOnNext);
+                }
+            },
+            toObservable: function (scheduler) {
+                var notification = this;
+                scheduler = scheduler || immediateScheduler;
+                return new AnonymousObservable(function (observer) {
+                    return scheduler.schedule(function () {
+                        notification._acceptObservable(observer);
+                        if (notification.kind === 'N') {
+                            observer.onCompleted();
+                        }
+                    });
+                });
+            },
+            hasValue: false,
+            equals: function (other) {
+                var otherString = other == null ? '' : other.toString();
+                return this.toString() === otherString;
+            }
+        });
+
+        return Notification;
+    })();
+
+    var notificationCreateOnNext = Notification.createOnNext = (function () {
+        inherits(ON, Notification);
+        function ON(value) {
+            this.value = value;
+            this.hasValue = true;
+            this.kind = 'N';
+        }
+
+        addProperties(ON.prototype, {
+            _accept: function (onNext) {
+                return onNext(this.value);
+            },
+            _acceptObservable: function (observer) {
+                return observer.onNext(this.value);
+            },
+            toString: function () {
+                return 'OnNext(' + this.value + ')';
+            }
+        });
+
+        return function (next) {
+            return new ON(next);
+        };
+    }());
+
+    var notificationCreateOnError = Notification.createOnError = (function () {
+        inherits(OE, Notification);
+        function OE(exception) {
+            this.exception = exception;
+            this.kind = 'E';
+        }
+
+        addProperties(OE.prototype, {
+            _accept: function (onNext, onError) {
+                return onError(this.exception);
+            },
+            _acceptObservable: function (observer) {
+                return observer.onError(this.exception);
+            },
+            toString: function () {
+                return 'OnError(' + this.exception + ')';
+            }
+        });
+
+        return function (error) {
+            return new OE(error);
+        };
+    }());
+
+    var notificationCreateOnCompleted = Notification.createOnCompleted = (function () {
+        inherits(OC, Notification);
+        function OC() {
+            this.kind = 'C';
+        }
+
+        addProperties(OC.prototype, {
+            _accept: function (onNext, onError, onCompleted) {
+                return onCompleted();
+            },
+            _acceptObservable: function (observer) {
+                return observer.onCompleted();
+            },
+            toString: function () {
+                return 'OnCompleted()';
+            }
+        });
+
+        return function () {
+            return new OC();
+        };
+    }());
+
+    // Enumerator
+
+    var Enumerator = root.Internals.Enumerator = function (moveNext, getCurrent, dispose) {
+        this.moveNext = moveNext;
+        this.getCurrent = getCurrent;
+        this.dispose = dispose;
+    };
+    var enumeratorCreate = Enumerator.create = function (moveNext, getCurrent, dispose) {
+        var done = false;
+        dispose || (dispose = noop);
+        return new Enumerator(function () {
+            if (done) {
+                return false;
+            }
+            var result = moveNext();
+            if (!result) {
+                done = true;
+                dispose();
+            }
+            return result;
+        }, function () { return getCurrent(); }, function () {
+            if (!done) {
+                dispose();
+                done = true;
+            }
+        });
+    };
+    
+    // Enumerable
+    var Enumerable = root.Internals.Enumerable = (function () {
+        function Enumerable(getEnumerator) {
+            this.getEnumerator = getEnumerator;
+        }
+
+        Enumerable.prototype.concat = function () {
+            var sources = this;
+            return new AnonymousObservable(function (observer) {
+                var e = sources.getEnumerator(), isDisposed = false, subscription = new SerialDisposable();
+                var cancelable = immediateScheduler.scheduleRecursive(function (self) {
+                    var current, ex, hasNext = false;
+                    if (!isDisposed) {
+                        try {
+                            hasNext = e.moveNext();
+                            if (hasNext) {
+                                current = e.getCurrent();
+                            } else {
+                                e.dispose();
+                            }
+                        } catch (exception) {
+                            ex = exception;
+                            e.dispose();
+                        }
+                    } else {
+                        return;
+                    }
+                    if (ex) {
+                        observer.onError(ex);
+                        return;
+                    }
+                    if (!hasNext) {
+                        observer.onCompleted();
+                        return;
+                    }
+                    var d = new SingleAssignmentDisposable();
+                    subscription.setDisposable(d);
+                    d.setDisposable(current.subscribe(
+                        observer.onNext.bind(observer),
+                        observer.onError.bind(observer),
+                        function () { self(); })
+                    );
+                });
+                return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+                    isDisposed = true;
+                    e.dispose();
+                }));
+            });
+        };
+
+        Enumerable.prototype.catchException = function () {
+            var sources = this;
+            return new AnonymousObservable(function (observer) {
+                var e = sources.getEnumerator(), isDisposed = false, lastException;
+                var subscription = new SerialDisposable();
+                var cancelable = immediateScheduler.scheduleRecursive(function (self) {
+                    var current, ex, hasNext;
+                    hasNext = false;
+                    if (!isDisposed) {
+                        try {
+                            hasNext = e.moveNext();
+                            if (hasNext) {
+                                current = e.getCurrent();
+                            }
+                        } catch (exception) {
+                            ex = exception;
+                        }
+                    } else {
+                        return;
+                    }
+                    if (ex) {
+                        observer.onError(ex);
+                        return;
+                    }
+                    if (!hasNext) {
+                        if (lastException) {
+                            observer.onError(lastException);
+                        } else {
+                            observer.onCompleted();
+                        }
+                        return;
+                    }
+                    var d = new SingleAssignmentDisposable();
+                    subscription.setDisposable(d);
+                    d.setDisposable(current.subscribe(
+                        observer.onNext.bind(observer),
+                        function (exn) {
+                            lastException = exn;
+                            self();
+                        },
+                        observer.onCompleted.bind(observer)));
+                });
+                return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+                    isDisposed = true;
+                }));
+            });
+        };
+
+        return Enumerable;
+    }());
+
+    // Enumerable properties
+    var enumerableRepeat = Enumerable.repeat = function (value, repeatCount) {
+        if (repeatCount === undefined) {
+            repeatCount = -1;
+        }
+        return new Enumerable(function () {
+            var current, left = repeatCount;
+            return enumeratorCreate(function () {
+                if (left === 0) {
+                    return false;
+                }
+                if (left > 0) {
+                    left--;
+                }
+                current = value;
+                return true;
+            }, function () { return current; });
+        });
+    };
+    var enumerableFor = Enumerable.forEach = function (source, selector) {
+        selector || (selector = identity);
+        return new Enumerable(function () {
+            var current, index = -1;
+            return enumeratorCreate(
+                function () {
+                    if (++index < source.length) {
+                        current = selector(source[index], index);
+                        return true;
+                    }
+                    return false;
+                },
+                function () { return current; }
+            );
+        });
+    };
+
+    // Observer
+    var Observer = root.Observer = function () { };
+    Observer.prototype.toNotifier = function () {
+        var observer = this;
+        return function (n) {
+            return n.accept(observer);
+        };
+    };
+    Observer.prototype.asObserver = function () {
+        return new AnonymousObserver(this.onNext.bind(this), this.onError.bind(this), this.onCompleted.bind(this));
+    };
+    Observer.prototype.checked = function () { return new CheckedObserver(this); };
+
+    var observerCreate = Observer.create = function (onNext, onError, onCompleted) {
+        onNext || (onNext = noop);
+        onError || (onError = defaultError);
+        onCompleted || (onCompleted = noop);
+        return new AnonymousObserver(onNext, onError, onCompleted);
+    };
+
+    Observer.fromNotifier = function (handler) {
+        return new AnonymousObserver(function (x) {
+            return handler(notificationCreateOnNext(x));
+        }, function (exception) {
+            return handler(notificationCreateOnError(exception));
+        }, function () {
+            return handler(notificationCreateOnCompleted());
+        });
+    };
+    
+    // Abstract Observer
+    var AbstractObserver = root.Internals.AbstractObserver = (function () {
+        inherits(AbstractObserver, Observer);
+        function AbstractObserver() {
+            this.isStopped = false;
+        }
+
+        AbstractObserver.prototype.onNext = function (value) {
+            if (!this.isStopped) {
+                this.next(value);
+            }
+        };
+        AbstractObserver.prototype.onError = function (error) {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.error(error);
+            }
+        };
+        AbstractObserver.prototype.onCompleted = function () {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.completed();
+            }
+        };
+        AbstractObserver.prototype.dispose = function () {
+            this.isStopped = true;
+        };
+        AbstractObserver.prototype.fail = function () {
+            if (!this.isStopped) {
+                this.isStopped = true;
+                this.error(true);
+                return true;
+            }
+
+            return false;
+        };
+
+        return AbstractObserver;
+    }());
+
+    var AnonymousObserver = root.AnonymousObserver = (function () {
+        inherits(AnonymousObserver, AbstractObserver);
+        function AnonymousObserver(onNext, onError, onCompleted) {
+            AnonymousObserver.super_.constructor.call(this);
+            this._onNext = onNext;
+            this._onError = onError;
+            this._onCompleted = onCompleted;
+        }
+        AnonymousObserver.prototype.next = function (value) {
+            this._onNext(value);
+        };
+        AnonymousObserver.prototype.error = function (exception) {
+            this._onError(exception);
+        };
+        AnonymousObserver.prototype.completed = function () {
+            this._onCompleted();
+        };
+        return AnonymousObserver;
+    }());
+
+    var CheckedObserver = (function () {
+        inherits(CheckedObserver, Observer);
+        function CheckedObserver(observer) {
+            this._observer = observer;
+            this._state = 0; // 0 - idle, 1 - busy, 2 - done
+        }
+
+        CheckedObserver.prototype.onNext = function (value) {
+            this.checkAccess();
+            try {
+                this._observer.onNext(value);
+            } finally {
+                this._state = 0;
+            }
+        };
+
+        CheckedObserver.prototype.onError = function (err) {
+            this.checkAccess();
+            try {
+                this._observer.onError(err);
+            } finally {
+                this._state = 2;
+            }
+        };
+
+        CheckedObserver.prototype.onCompleted = function () {
+            this.checkAccess();
+            try {
+                this._observer.onCompleted();
+            } finally {
+                this._state = 2;
+            }
+        };
+
+        CheckedObserver.prototype.checkAccess = function () {
+            if (this._state === 1) { throw new Error('Re-entrancy detected'); }
+            if (this._state === 2) { throw new Error('Observer completed'); }
+            if (this._state === 0) { this._state = 1; }
+        };
+
+        return CheckedObserver;
+    }());
+
+    var ScheduledObserver = root.Internals.ScheduledObserver = (function () {
+        inherits(ScheduledObserver, AbstractObserver);
+        function ScheduledObserver(scheduler, observer) {
+            ScheduledObserver.super_.constructor.call(this);
+            this.scheduler = scheduler;
+            this.observer = observer;
+            this.isAcquired = false;
+            this.hasFaulted = false;
+            this.queue = [];
+            this.disposable = new SerialDisposable();
+        }
+
+        ScheduledObserver.prototype.next = function (value) {
+            var self = this;
+            this.queue.push(function () {
+                self.observer.onNext(value);
+            });
+        };
+        ScheduledObserver.prototype.error = function (exception) {
+            var self = this;
+            this.queue.push(function () {
+                self.observer.onError(exception);
+            });
+        };
+        ScheduledObserver.prototype.completed = function () {
+            var self = this;
+            this.queue.push(function () {
+                self.observer.onCompleted();
+            });
+        };
+        ScheduledObserver.prototype.ensureActive = function () {
+            var isOwner = false, parent = this;
+            if (!this.hasFaulted && this.queue.length > 0) {
+                isOwner = !this.isAcquired;
+                this.isAcquired = true;
+            }
+            if (isOwner) {
+                this.disposable.setDisposable(this.scheduler.scheduleRecursive(function (self) {
+                    var work;
+                    if (parent.queue.length > 0) {
+                        work = parent.queue.shift();
+                    } else {
+                        parent.isAcquired = false;
+                        return;
+                    }
+                    try {
+                        work();
+                    } catch (ex) {
+                        parent.queue = [];
+                        parent.hasFaulted = true;
+                        throw ex;
+                    }
+                    self();
+                }));
+            }
+        };
+        ScheduledObserver.prototype.dispose = function () {
+            ScheduledObserver.super_.dispose.call(this);
+            this.disposable.dispose();
+        };
+
+        return ScheduledObserver;
+    }());
+
+    var ObserveOnObserver = (function () {
+        inherits(ObserveOnObserver, ScheduledObserver);
+        function ObserveOnObserver() {
+            ObserveOnObserver.super_.constructor.apply(this, arguments);
+        }
+        ObserveOnObserver.prototype.next = function (value) {
+            ObserveOnObserver.super_.next.call(this, value);
+            this.ensureActive();
+        };
+        ObserveOnObserver.prototype.error = function (e) {
+            ObserveOnObserver.super_.error.call(this, e);
+            this.ensureActive();
+        };
+        ObserveOnObserver.prototype.completed = function () {
+            ObserveOnObserver.super_.completed.call(this);
+            this.ensureActive();
+        };
+
+        return ObserveOnObserver;
+    })();
+
+    var observableProto;
+    var Observable = root.Observable = (function () {
+
+        function Observable(subscribe) {
+            this._subscribe = subscribe;
+        }
+
+        observableProto = Observable.prototype;
+
+        observableProto.finalValue = function () {
+            var source = this;
+            return new AnonymousObservable(function (observer) {
+                var hasValue = false, value;
+                return source.subscribe(function (x) {
+                    hasValue = true;
+                    value = x;
+                }, observer.onError.bind(observer), function () {
+                    if (!hasValue) {
+                        observer.onError(new Error(sequenceContainsNoElements));
+                    } else {
+                        observer.onNext(value);
+                        observer.onCompleted();
+                    }
+                });
+            });
+        };
+
+        observableProto.subscribe = function (observerOrOnNext, onError, onCompleted) {
+            var subscriber;
+            if (arguments.length === 0 || arguments.length > 1 || typeof observerOrOnNext === 'function') {
+                subscriber = observerCreate(observerOrOnNext, onError, onCompleted);
+            } else {
+                subscriber = observerOrOnNext;
+            }
+            return this._subscribe(subscriber);
+        };
+
+        observableProto.toArray = function () {
+            function accumulator(list, i) {
+                list.push(i);
+                return list.slice(0);
+            }
+            return this.scan([], accumulator).startWith([]).finalValue();
+        }
+
+        return Observable;
+    })();
+
+    Observable.start = function (func, scheduler, context) {
+        return observableToAsync(func, scheduler)();
+    };
+
+    var observableToAsync = Observable.toAsync = function (func, scheduler, context) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = slice.call(arguments, 0), 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();
+        };
+    };    
+    observableProto.observeOn = function (scheduler) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(new ObserveOnObserver(scheduler, observer));
+        });
+    };
+
+    observableProto.subscribeOn = function (scheduler) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var m = new SingleAssignmentDisposable(), d = new SerialDisposable();
+            d.setDisposable(m);
+            m.setDisposable(scheduler.schedule(function () {
+                d.setDisposable(new ScheduledDisposable(scheduler, source.subscribe(observer)));
+            }));
+            return d;
+        });
+    };
+    
+    Observable.create = function (subscribe) {
+        return new AnonymousObservable(function (o) {
+            return disposableCreate(subscribe(o));
+        });
+    };
+
+    Observable.createWithDisposable = function (subscribe) {
+        return new AnonymousObservable(subscribe);
+    };
+
+    var observableDefer = Observable.defer = function (observableFactory) {
+        return new AnonymousObservable(function (observer) {
+            var result;
+            try {
+                result = observableFactory();
+            } catch (e) {
+                return observableThrow(e).subscribe(observer);
+            }
+            return result.subscribe(observer);
+        });
+    };
+
+    var observableEmpty = Observable.empty = function (scheduler) {
+        scheduler || (scheduler = immediateScheduler);
+        return new AnonymousObservable(function (observer) {
+            return scheduler.schedule(function () {
+                observer.onCompleted();
+            });
+        });
+    };
+
+    var observableFromArray = Observable.fromArray = function (array, scheduler) {
+        scheduler || (scheduler = currentThreadScheduler);
+        return new AnonymousObservable(function (observer) {
+            var count = 0;
+            return scheduler.scheduleRecursive(function (self) {
+                if (count < array.length) {
+                    observer.onNext(array[count++]);
+                    self();
+                } else {
+                    observer.onCompleted();
+                }
+            });
+        });
+    };
+
+    Observable.generate = function (initialState, condition, iterate, resultSelector, scheduler) {
+        scheduler || (scheduler = currentThreadScheduler);
+        return new AnonymousObservable(function (observer) {
+            var first = true, state = initialState;
+            return scheduler.scheduleRecursive(function (self) {
+                var hasResult, result;
+                try {
+                    if (first) {
+                        first = false;
+                    } else {
+                        state = iterate(state);
+                    }
+                    hasResult = condition(state);
+                    if (hasResult) {
+                        result = resultSelector(state);
+                    }
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                if (hasResult) {
+                    observer.onNext(result);
+                    self();
+                } else {
+                    observer.onCompleted();
+                }
+            });
+        });
+    };
+
+    var observableNever = Observable.never = function () {
+        return new AnonymousObservable(function () {
+            return disposableEmpty;
+        });
+    };
+
+    Observable.range = function (start, count, scheduler) {
+        scheduler || (scheduler = currentThreadScheduler);
+        return new AnonymousObservable(function (observer) {
+            return scheduler.scheduleRecursiveWithState(0, function (i, self) {
+                if (i < count) {
+                    observer.onNext(start + i);
+                    self(i + 1);
+                } else {
+                    observer.onCompleted();
+                }
+            });
+        });
+    };
+
+    Observable.repeat = function (value, repeatCount, scheduler) {
+        scheduler || (scheduler = currentThreadScheduler);
+        if (repeatCount == undefined) {
+            repeatCount = -1;
+        }
+        return observableReturn(value, scheduler).repeat(repeatCount);
+    };
+
+    var observableReturn = Observable.returnValue = function (value, scheduler) {
+        scheduler || (scheduler = immediateScheduler);
+        return new AnonymousObservable(function (observer) {
+            return scheduler.schedule(function () {
+                observer.onNext(value);
+                observer.onCompleted();
+            });
+        });
+    };
+
+    var observableThrow = Observable.throwException = function (exception, scheduler) {
+        scheduler || (scheduler = immediateScheduler);
+        return new AnonymousObservable(function (observer) {
+            return scheduler.schedule(function () {
+                observer.onError(exception);
+            });
+        });
+    };
+
+    Observable.using = function (resourceFactory, observableFactory) {
+        return new AnonymousObservable(function (observer) {
+            var disposable = disposableEmpty, resource, source;
+            try {
+                resource = resourceFactory();
+                if (resource) {
+                    disposable = resource;
+                }
+                source = observableFactory(resource);
+            } catch (exception) {
+                return new CompositeDisposable(observableThrow(exception).subscribe(observer), disposable);
+            }
+            return new CompositeDisposable(source.subscribe(observer), disposable);
+        });
+    };                        
+    observableProto.amb = function (rightSource) {
+        var leftSource = this;
+        return new AnonymousObservable(function (observer) {
+
+            var choice,
+                leftSubscription = new SingleAssignmentDisposable(),
+                rightSubscription = new SingleAssignmentDisposable();
+
+            function choiceL() {
+                if (!choice) {
+                    choice = 'L';
+                    rightSubscription.dispose();
+                }
+            }
+
+            function choiceR() {
+                if (!choice) {
+                    choice = 'R';
+                    leftSubscription.dispose();
+                }
+            }
+
+            leftSubscription.setDisposable(leftSource.subscribe(function (left) {
+                choiceL();
+                if (choice === 'L') {
+                    observer.onNext(left);
+                }
+            }, function (err) {
+                choiceL();
+                if (choice === 'L') {
+                    observer.onError(err);
+                }
+            }, function () {
+                choiceL();
+                if (choice === 'L') {
+                    observer.onCompleted();
+                }
+            }));
+
+            rightSubscription.setDisposable(rightSource.subscribe(function (right) {
+                choiceR();
+                if (choice === 'R') {
+                    observer.onNext(right);
+                }
+            }, function (err) {
+                choiceR();
+                if (choice === 'R') {
+                    observer.onError(err);
+                }
+            }, function () {
+                choiceR();
+                if (choice === 'R') {
+                    observer.onCompleted();
+                }
+            }));
+
+            return new CompositeDisposable(leftSubscription, rightSubscription);
+        });
+    };
+
+    Observable.amb = function () {
+        var acc = observableNever(),
+            items = argsOrArray(arguments, 0);
+        function func(previous, current) {
+            return previous.amb(current);
+        }
+        for (var i = 0, len = items.length; i < len; i++) {
+            acc = func(acc, items[i]);
+        }
+        return acc;
+    };
+
+    function observableCatchHandler(source, handler) {
+        return new AnonymousObservable(function (observer) {
+            var d1 = new SingleAssignmentDisposable(), subscription = new SerialDisposable();
+            subscription.setDisposable(d1);
+            d1.setDisposable(source.subscribe(observer.onNext.bind(observer), function (exception) {
+                var d, result;
+                try {
+                    result = handler(exception);
+                } catch (ex) {
+                    observer.onError(ex);
+                    return;
+                }
+                d = new SingleAssignmentDisposable();
+                subscription.setDisposable(d);
+                d.setDisposable(result.subscribe(observer));
+            }, observer.onCompleted.bind(observer)));
+            return subscription;
+        });
+    }
+
+    observableProto.catchException = function (handlerOrSecond) {
+        if (typeof handlerOrSecond === 'function') {
+            return observableCatchHandler(this, handlerOrSecond);
+        }
+        return observableCatch([this, handlerOrSecond]);
+    };
+
+    var observableCatch = Observable.catchException = function () {
+        var items = argsOrArray(arguments, 0);
+        return enumerableFor(items).catchException();
+    };
+
+    observableProto.combineLatest = function () {
+        var parent = this, args = slice.call(arguments), resultSelector = args.pop();
+        args.unshift(this);
+        return new AnonymousObservable(function (observer) {
+            var falseFactory = function () { return false; },
+                n = args.length,
+                hasValue = arrayInitialize(n, falseFactory),
+                hasValueAll = false,
+                isDone = arrayInitialize(n, falseFactory),
+                values = new Array(n);
+
+            function next(i) {
+                var res;
+                hasValue[i] = true;
+                if (hasValueAll || (hasValueAll = hasValue.every(function (x) { return x; }))) {
+                    try {
+                        res = resultSelector.apply(parent, values);
+                    } catch (ex) {
+                        observer.onError(ex);
+                        return;
+                    }
+                    observer.onNext(res);
+                } else if (isDone.filter(function (x, j) { return j !== i; }).every(function (x) { return x; })) {
+                    observer.onCompleted();
+                }
+            }
+
+            function done (i) {
+                isDone[i] = true;
+                if (isDone.every(function (x) { return x; })) {
+                    observer.onCompleted();
+                }
+            }
+
+            var subscriptions = new Array(n);
+            for (var idx = 0; idx < n; idx++) {
+                (function (i) {
+                    subscriptions[i] = new SingleAssignmentDisposable();
+                    subscriptions[i].setDisposable(args[i].subscribe(function (x) {
+                        values[i] = x;
+                        next(i);
+                    }, observer.onError.bind(observer), function () {
+                        done(i);
+                    }));
+                })(idx);
+            }
+
+            return new CompositeDisposable(subscriptions);
+        });
+    };
+
+    observableProto.concat = function () {
+        var items = slice.call(arguments, 0);
+        items.unshift(this);
+        return observableConcat.apply(this, items);
+    };
+
+    var observableConcat = Observable.concat = function () {
+        var sources = argsOrArray(arguments, 0);
+        return enumerableFor(sources).concat();
+    };    
+
+    observableProto.concatObservable = function () {
+        return this.merge(1);
+    };
+
+    observableProto.merge = function (maxConcurrentOrOther) {
+        if (typeof maxConcurrentOrOther !== 'number') {
+            return observableMerge(this, maxConcurrentOrOther);
+        }
+        var sources = this;
+        return new AnonymousObservable(function (observer) {
+            var activeCount = 0,
+                group = new CompositeDisposable(),
+                isStopped = false,
+                q = [],
+                subscribe = function (xs) {
+                    var subscription = new SingleAssignmentDisposable();
+                    group.add(subscription);
+                    subscription.setDisposable(xs.subscribe(observer.onNext.bind(observer), observer.onError.bind(observer), function () {
+                        var s;
+                        group.remove(subscription);
+                        if (q.length > 0) {
+                            s = q.shift();
+                            subscribe(s);
+                        } else {
+                            activeCount--;
+                            if (isStopped && activeCount === 0) {
+                                observer.onCompleted();
+                            }
+                        }
+                    }));
+                };
+            group.add(sources.subscribe(function (innerSource) {
+                if (activeCount < maxConcurrentOrOther) {
+                    activeCount++;
+                    subscribe(innerSource);
+                } else {
+                    q.push(innerSource);
+                }
+            }, observer.onError.bind(observer), function () {
+                isStopped = true;
+                if (activeCount === 0) {
+                    observer.onCompleted();
+                }
+            }));
+            return group;
+        });
+    };
+
+    var observableMerge = Observable.merge = function () {
+        var scheduler, sources;
+        if (!arguments[0]) {
+            scheduler = immediateScheduler;
+            sources = slice.call(arguments, 1);
+        } else if (arguments[0].now) {
+            scheduler = arguments[0];
+            sources = slice.call(arguments, 1);
+        } else {
+            scheduler = immediateScheduler;
+            sources = slice.call(arguments, 0);
+        }
+        if (Array.isArray(sources[0])) {
+            sources = sources[0];
+        }
+        return observableFromArray(sources, scheduler).mergeObservable();
+    };    
+
+    observableProto.mergeObservable = function () {
+        var sources = this;
+        return new AnonymousObservable(function (observer) {
+            var group = new CompositeDisposable(),
+                isStopped = false,
+                m = new SingleAssignmentDisposable();
+            group.add(m);
+            m.setDisposable(sources.subscribe(function (innerSource) {
+                var innerSubscription = new SingleAssignmentDisposable();
+                group.add(innerSubscription);
+                innerSubscription.setDisposable(innerSource.subscribe(function (x) {
+                    observer.onNext(x);
+                }, observer.onError.bind(observer), function () {
+                    group.remove(innerSubscription);
+                    if (isStopped && group.length === 1) {
+                        observer.onCompleted();
+                    }
+                }));
+            }, observer.onError.bind(observer), function () {
+                isStopped = true;
+                if (group.length === 1) {
+                    observer.onCompleted();
+                }
+            }));
+            return group;
+        });
+    };
+
+    observableProto.onErrorResumeNext = function (second) {
+        if (!second) {
+            throw new Error('Second observable is required');
+        }
+        return onErrorResumeNext([this, second]);
+    };
+
+    var onErrorResumeNext = Observable.onErrorResumeNext = function () {
+        var sources = argsOrArray(arguments, 0);
+        return new AnonymousObservable(function (observer) {
+            var pos = 0, subscription = new SerialDisposable(),
+            cancelable = immediateScheduler.scheduleRecursive(function (self) {
+                var current, d;
+                if (pos < sources.length) {
+                    current = sources[pos++];
+                    d = new SingleAssignmentDisposable();
+                    subscription.setDisposable(d);
+                    d.setDisposable(current.subscribe(observer.onNext.bind(observer), function () {
+                        self();
+                    }, function () {
+                        self();
+                    }));
+                } else {
+                    observer.onCompleted();
+                }
+            });
+            return new CompositeDisposable(subscription, cancelable);
+        });
+    };
+
+    observableProto.skipUntil = function (other) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var isOpen = false;
+            var disposables = new CompositeDisposable(source.subscribe(function (left) {
+                if (isOpen) {
+                    observer.onNext(left);
+                }
+            }, observer.onError.bind(observer), function () {
+                if (isOpen) {
+                    observer.onCompleted();
+                }
+            }));
+
+            var rightSubscription = new SingleAssignmentDisposable();
+            disposables.add(rightSubscription);
+            rightSubscription.setDisposable(other.subscribe(function () {
+                isOpen = true;
+                rightSubscription.dispose();
+            }, observer.onError.bind(observer), function () {
+                rightSubscription.dispose();
+            }));
+
+            return disposables;
+        });
+    };
+
+    observableProto.switchLatest = function () {
+        var sources = this;
+        return new AnonymousObservable(function (observer) {
+            var hasLatest = false,
+                innerSubscription = new SerialDisposable(),
+                isStopped = false,
+                latest = 0,
+                subscription = sources.subscribe(function (innerSource) {
+                    var d = new SingleAssignmentDisposable(), id = ++latest;
+                    hasLatest = true;
+                    innerSubscription.setDisposable(d);
+                    d.setDisposable(innerSource.subscribe(function (x) {
+                        if (latest === id) {
+                            observer.onNext(x);
+                        }
+                    }, function (e) {
+                        if (latest === id) {
+                            observer.onError(e);
+                        }
+                    }, function () {
+                        if (latest === id) {
+                            hasLatest = false;
+                            if (isStopped) {
+                                observer.onCompleted();
+                            }
+                        }
+                    }));
+                }, observer.onError.bind(observer), function () {
+                    isStopped = true;
+                    if (!hasLatest) {
+                        observer.onCompleted();
+                    }
+                });
+            return new CompositeDisposable(subscription, innerSubscription);
+        });
+    };
+
+    observableProto.takeUntil = function (other) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return new CompositeDisposable(
+                source.subscribe(observer),
+                other.subscribe(observer.onCompleted.bind(observer), observer.onError.bind(observer), noop)
+            );
+        });
+    };
+
+    function zipArray(second, resultSelector) {
+        var first = this;
+        return new AnonymousObservable(function (observer) {
+            var index = 0, len = second.length;
+            return first.subscribe(function (left) {
+                if (index < len) {
+                    var right = second[index++], result;
+                    try {
+                        result = resultSelector(left, right);
+                    } catch (e) {
+                        observer.onError(e);
+                        return;
+                    }
+                    observer.onNext(result);
+                } else {
+                    observer.onCompleted();
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    }    
+
+    observableProto.zip = function () {
+        if (Array.isArray(arguments[0])) {
+            return zipArray.apply(this, arguments);
+        }
+        var parent = this, sources = slice.call(arguments), resultSelector = sources.pop();
+        sources.unshift(parent);
+        return new AnonymousObservable(function (observer) {
+            var n = sources.length,
+              queues = arrayInitialize(n, function () { return []; }),
+              isDone = arrayInitialize(n, function () { return false; });
+            var next = function (i) {
+                var res, queuedValues;
+                if (queues.every(function (x) { return x.length > 0; })) {
+                    try {
+                        queuedValues = queues.map(function (x) { return x.shift(); });
+                        res = resultSelector.apply(parent, queuedValues);
+                    } catch (ex) {
+                        observer.onError(ex);
+                        return;
+                    }
+                    observer.onNext(res);
+                } else if (isDone.filter(function (x, j) { return j !== i; }).every(function (x) { return x; })) {
+                    observer.onCompleted();
+                }
+            };
+
+            function done(i) {
+                isDone[i] = true;
+                if (isDone.every(function (x) { return x; })) {
+                    observer.onCompleted();
+                }
+            }
+
+            var subscriptions = new Array(n);
+            for (var idx = 0; idx < n; idx++) {
+                (function (i) {
+                    subscriptions[i] = new SingleAssignmentDisposable();
+                    subscriptions[i].setDisposable(sources[i].subscribe(function (x) {
+                        queues[i].push(x);
+                        next(i);
+                    }, observer.onError.bind(observer), function () {
+                        done(i);
+                    }));
+                })(idx);
+            }
+
+            return new CompositeDisposable(subscriptions);
+        });
+    };
+    observableProto.asObservable = function () {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(observer);
+        });
+    };
+
+    observableProto.bufferWithCount = function (count, skip) {
+        if (skip === undefined) {
+            skip = count;
+        }
+        return this.windowWithCount(count, skip).selectMany(function (x) {
+            return x.toArray();
+        }).where(function (x) {
+            return x.length > 0;
+        });
+    };
+
+    observableProto.dematerialize = function () {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(function (x) {
+                return x.accept(observer);
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.distinctUntilChanged = function (keySelector, comparer) {
+        var source = this;
+        keySelector || (keySelector = identity);
+        comparer || (comparer = defaultComparer);
+        return new AnonymousObservable(function (observer) {
+            var hasCurrentKey = false, currentKey;
+            return source.subscribe(function (value) {
+                var comparerEquals = false, key;
+                try {
+                    key = keySelector(value);
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                if (hasCurrentKey) {
+                    try {
+                        comparerEquals = comparer(currentKey, key);
+                    } catch (exception) {
+                        observer.onError(exception);
+                        return;
+                    }
+                }
+                if (!hasCurrentKey || !comparerEquals) {
+                    hasCurrentKey = true;
+                    currentKey = key;
+                    observer.onNext(value);
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.doAction = function (observerOrOnNext, onError, onCompleted) {
+        var source = this, onNextFunc;
+        if (typeof observerOrOnNext === 'function') {
+            onNextFunc = observerOrOnNext;
+        } else {
+            onNextFunc = observerOrOnNext.onNext.bind(observerOrOnNext);
+            onError = observerOrOnNext.onError.bind(observerOrOnNext);
+            onCompleted = observerOrOnNext.onCompleted.bind(observerOrOnNext);
+        }
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(function (x) {
+                try {
+                    onNextFunc(x);
+                } catch (e) {
+                    observer.onError(e);
+                }
+                observer.onNext(x);
+            }, function (exception) {
+                if (!onError) {
+                    observer.onError(exception);
+                } else {
+                    try {
+                        onError(exception);
+                    } catch (e) {
+                        observer.onError(e);
+                    }
+                    observer.onError(exception);
+                }
+            }, function () {
+                if (!onCompleted) {
+                    observer.onCompleted();
+                } else {
+                    try {
+                        onCompleted();
+                    } catch (e) {
+                        observer.onError(e);
+                    }
+                    observer.onCompleted();
+                }
+            });
+        });
+    };
+
+    observableProto.finallyAction = function (action) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var subscription = source.subscribe(observer);
+            return disposableCreate(function () {
+                try {
+                    subscription.dispose();
+                } finally {
+                    action();
+                }
+            });
+        });
+    };
+
+    observableProto.ignoreElements = function () {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(noop, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.materialize = function () {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            return source.subscribe(function (value) {
+                observer.onNext(notificationCreateOnNext(value));
+            }, function (exception) {
+                observer.onNext(notificationCreateOnError(exception));
+                observer.onCompleted();
+            }, function () {
+                observer.onNext(notificationCreateOnCompleted());
+                observer.onCompleted();
+            });
+        });
+    };
+
+    observableProto.repeat = function (repeatCount) {
+        return enumerableRepeat(this, repeatCount).concat();
+    };
+
+    observableProto.retry = function (retryCount) {
+        return enumerableRepeat(this, retryCount).catchException();
+    };
+
+    observableProto.scan = function () {
+        var seed, hasSeed = false, accumulator;
+        if (arguments.length === 2) {
+            seed = arguments[0];
+            accumulator = arguments[1];
+            hasSeed = true;
+        } else {
+            accumulator = arguments[0];
+        }
+        var source = this;
+        return observableDefer(function () {
+            var hasAccumulation = false, accumulation;
+            return source.select(function (x) {
+                if (hasAccumulation) {
+                    accumulation = accumulator(accumulation, x);
+                } else {
+                    accumulation = hasSeed ? accumulator(seed, x) : x;
+                    hasAccumulation = true;
+                }
+                return accumulation;
+            });
+        });
+    };
+
+    observableProto.skipLast = function (count) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var q = [];
+            return source.subscribe(function (x) {
+                q.push(x);
+                if (q.length > count) {
+                    observer.onNext(q.shift());
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.startWith = function () {
+        var values, scheduler, start = 0;
+        if (arguments.length > 0 && arguments[0] != null && arguments[0].now !== undefined) {
+            scheduler = arguments[0];
+            start = 1;
+        } else {
+            scheduler = immediateScheduler;
+        }
+        values = slice.call(arguments, start);
+        return enumerableFor([observableFromArray(values, scheduler), this]).concat();
+    };
+
+    observableProto.takeLast = function (count, scheduler) {
+        return this.takeLastBuffer(count).selectMany(function (xs) { return observableFromArray(xs, scheduler); });
+    };
+
+    observableProto.takeLastBuffer = function (count) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var q = [];
+            return source.subscribe(function (x) {
+                q.push(x);
+                if (q.length > count) {
+                    q.shift();
+                }
+            }, observer.onError.bind(observer), function () {
+                observer.onNext(q);
+                observer.onCompleted();
+            });
+        });
+    };
+
+    observableProto.windowWithCount = function (count, skip) {
+        var source = this;
+        if (count <= 0) {
+            throw new Error(argumentOutOfRange);
+        }
+        if (skip === undefined) {
+            skip = count;
+        }
+        if (skip <= 0) {
+            throw new Error(argumentOutOfRange);
+        }
+        return new AnonymousObservable(function (observer) {
+            var m = new SingleAssignmentDisposable(),
+                refCountDisposable = new RefCountDisposable(m),
+                n = 0,
+                q = [],
+                createWindow = function () {
+                    var s = new Subject();
+                    q.push(s);
+                    observer.onNext(addRef(s, refCountDisposable));
+                };
+            createWindow();
+            m.setDisposable(source.subscribe(function (x) {
+                var s;
+                for (var i = 0, len = q.length; i < len; i++) {
+                    q[i].onNext(x);
+                }
+                var c = n - count + 1;
+                if (c >= 0 && c % skip === 0) {
+                    s = q.shift();
+                    s.onCompleted();
+                }
+                n++;
+                if (n % skip === 0) {
+                    createWindow();
+                }
+            }, function (exception) {
+                while (q.length > 0) {
+                    q.shift().onError(exception);
+                }
+                observer.onError(exception);
+            }, function () {
+                while (q.length > 0) {
+                    q.shift().onCompleted();
+                }
+                observer.onCompleted();
+            }));
+            return refCountDisposable;
+        });
+    };
+
+    observableProto.defaultIfEmpty = function (defaultValue) {
+        var source = this;
+        if (defaultValue === undefined) {
+            defaultValue = null;
+        }
+        return new AnonymousObservable(function (observer) {
+            var found = false;
+            return source.subscribe(function (x) {
+                found = true;
+                observer.onNext(x);
+            }, observer.onError.bind(observer), function () {
+                if (!found) {
+                    observer.onNext(defaultValue);
+                }
+                observer.onCompleted();
+            });
+        });
+    };
+
+   observableProto.distinct = function (keySelector, keySerializer) {
+        var source = this;
+        keySelector || (keySelector = identity);
+        keySerializer || (keySerializer = defaultKeySerializer);
+        return new AnonymousObservable(function (observer) {
+            var hashSet = {};
+            return source.subscribe(function (x) {
+                var key, serializedKey, otherKey, hasMatch = false;
+                try {
+                    key = keySelector(x);
+                    serializedKey = keySerializer(key);
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                for (otherKey in hashSet) {
+                    if (serializedKey === otherKey) {
+                        hasMatch = true;
+                        break;
+                    }
+                }
+                if (!hasMatch) {
+                    hashSet[serializedKey] = null;
+                    observer.onNext(x);
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.groupBy = function (keySelector, elementSelector, keySerializer) {
+        return this.groupByUntil(keySelector, elementSelector, function () {
+            return observableNever();
+        }, keySerializer);
+    };
+
+    observableProto.groupByUntil = function (keySelector, elementSelector, durationSelector, keySerializer) {
+        var source = this;
+        elementSelector || (elementSelector = identity);
+        keySerializer || (keySerializer = defaultKeySerializer);
+        return new AnonymousObservable(function (observer) {
+            var map = {},
+                groupDisposable = new CompositeDisposable(),
+                refCountDisposable = new RefCountDisposable(groupDisposable);
+            groupDisposable.add(source.subscribe(function (x) {
+                var duration, durationGroup, element, expire, fireNewMapEntry, group, key, serializedKey, md, writer, w;
+                try {
+                    key = keySelector(x);
+                    serializedKey = keySerializer(key);
+                } catch (e) {
+                    for (w in map) {
+                        map[w].onError(e);
+                    }
+                    observer.onError(e);
+                    return;
+                }
+                fireNewMapEntry = false;
+                try {
+                    writer = map[serializedKey];
+                    if (!writer) {
+                        writer = new Subject();
+                        map[serializedKey] = writer;
+                        fireNewMapEntry = true;
+                    }
+                } catch (e) {
+                    for (w in map) {
+                        map[w].onError(e);
+                    }
+                    observer.onError(e);
+                    return;
+                }
+                if (fireNewMapEntry) {
+                    group = new GroupedObservable(key, writer, refCountDisposable);
+                    durationGroup = new GroupedObservable(key, writer);
+                    try {
+                        duration = durationSelector(durationGroup);
+                    } catch (e) {
+                        for (w in map) {
+                            map[w].onError(e);
+                        }
+                        observer.onError(e);
+                        return;
+                    }
+                    observer.onNext(group);
+                    md = new SingleAssignmentDisposable();
+                    groupDisposable.add(md);
+                    expire = function () {
+                        if (map[serializedKey] !== undefined) {
+                            delete map[serializedKey];
+                            writer.onCompleted();
+                        }
+                        groupDisposable.remove(md);
+                    };
+                    md.setDisposable(duration.take(1).subscribe(function () { }, function (exn) {
+                        for (w in map) {
+                            map[w].onError(exn);
+                        }
+                        observer.onError(exn);
+                    }, function () {
+                        expire();
+                    }));
+                }
+                try {
+                    element = elementSelector(x);
+                } catch (e) {
+                    for (w in map) {
+                        map[w].onError(e);
+                    }
+                    observer.onError(e);
+                    return;
+                }
+                writer.onNext(element);
+            }, function (ex) {
+                for (var w in map) {
+                    map[w].onError(ex);
+                }
+                observer.onError(ex);
+            }, function () {
+                for (var w in map) {
+                    map[w].onCompleted();
+                }
+                observer.onCompleted();
+            }));
+            return refCountDisposable;
+        });
+    };
+
+    observableProto.select = function (selector) {
+        var parent = this;
+        return new AnonymousObservable(function (observer) {
+            var count = 0;
+            return parent.subscribe(function (value) {
+                var result;
+                try {
+                    result = selector(value, count++);
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                observer.onNext(result);
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    function selectMany(selector) {
+        return this.select(selector).mergeObservable();
+    }
+
+    observableProto.selectMany = function (selector, resultSelector) {
+        if (resultSelector) {
+            return this.selectMany(function (x) {
+                return selector(x).select(function (y) {
+                    return resultSelector(x, y);
+                });
+            });
+        }
+        if (typeof selector === 'function') {
+            return selectMany.call(this, selector);
+        }
+        return selectMany.call(this, function () {
+            return selector;
+        });
+    };
+
+    observableProto.skip = function (count) {
+        if (count < 0) {
+            throw new Error(argumentOutOfRange);
+        }
+        var observable = this;
+        return new AnonymousObservable(function (observer) {
+            var remaining = count;
+            return observable.subscribe(function (x) {
+                if (remaining <= 0) {
+                    observer.onNext(x);
+                } else {
+                    remaining--;
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.skipWhile = function (predicate) {
+        var source = this;
+        return new AnonymousObservable(function (observer) {
+            var i = 0, running = false;
+            return source.subscribe(function (x) {
+                if (!running) {
+                    try {
+                        running = !predicate(x, i++);
+                    } catch (e) {
+                        observer.onError(e);
+                        return;
+                    }
+                }
+                if (running) {
+                    observer.onNext(x);
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.take = function (count, scheduler) {
+        if (count < 0) {
+            throw new Error(argumentOutOfRange);
+        }
+        if (count === 0) {
+            return observableEmpty(scheduler);
+        }
+        var observable = this;
+        return new AnonymousObservable(function (observer) {
+            var remaining = count;
+            return observable.subscribe(function (x) {
+                if (remaining > 0) {
+                    remaining--;
+                    observer.onNext(x);
+                    if (remaining === 0) {
+                        observer.onCompleted();
+                    }
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.takeWhile = function (predicate) {
+        var observable = this;
+        return new AnonymousObservable(function (observer) {
+            var i = 0, running = true;
+            return observable.subscribe(function (x) {
+                if (running) {
+                    try {
+                        running = predicate(x, i++);
+                    } catch (e) {
+                        observer.onError(e);
+                        return;
+                    }
+                    if (running) {
+                        observer.onNext(x);
+                    } else {
+                        observer.onCompleted();
+                    }
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+
+    observableProto.where = function (predicate) {
+        var parent = this;
+        return new AnonymousObservable(function (observer) {
+            var count = 0;
+            return parent.subscribe(function (value) {
+                var shouldRun;
+                try {
+                    shouldRun = predicate(value, count++);
+                } catch (exception) {
+                    observer.onError(exception);
+                    return;
+                }
+                if (shouldRun) {
+                    observer.onNext(value);
+                }
+            }, observer.onError.bind(observer), observer.onCompleted.bind(observer));
+        });
+    };
+    var AnonymousObservable = root.Internals.AnonymousObservable = (function () {
+        inherits(AnonymousObservable, Observable);
+        function AnonymousObservable(subscribe) {
+
+            var s = function (observer) {
+                var autoDetachObserver = new AutoDetachObserver(observer);
+                if (currentThreadScheduler.scheduleRequired()) {
+                    currentThreadScheduler.schedule(function () {
+                        try {
+                            autoDetachObserver.disposable(subscribe(autoDetachObserver));
+                        } catch (e) {
+                            if (!autoDetachObserver.fail(e)) {
+                                throw e;
+                            } 
+                        }
+                    });
+                } else {
+                    try {
+                        autoDetachObserver.disposable(subscribe(autoDetachObserver));
+                    } catch (e) {
+                        if (!autoDetachObserver.fail(e)) {
+                            throw e;
+                        }
+                    }
+                }
+
+                return autoDetachObserver;
+            };
+            AnonymousObservable.super_.constructor.call(this, s);
+        }
+
+        return AnonymousObservable;
+    }());
+
+    var AutoDetachObserver = (function () {
+
+        inherits(AutoDetachObserver, AbstractObserver);
+        function AutoDetachObserver(observer) {
+            AutoDetachObserver.super_.constructor.call(this);
+            this.observer = observer;
+            this.m = new SingleAssignmentDisposable();
+        }
+
+        AutoDetachObserver.prototype.next = function (value) {
+            var noError = false;
+            try {
+                this.observer.onNext(value);
+                noError = true;
+            } finally {
+                if (!noError) {
+                    this.dispose();
+                }
+            }
+        };
+        AutoDetachObserver.prototype.error = function (exn) {
+            try {
+                this.observer.onError(exn);
+            } finally {
+                this.dispose();
+            }
+        };
+        AutoDetachObserver.prototype.completed = function () {
+            try {
+                this.observer.onCompleted();
+            } finally {
+                this.dispose();
+            }
+        };
+        AutoDetachObserver.prototype.disposable = function (value) {
+            return this.m.disposable(value);
+        };
+        AutoDetachObserver.prototype.dispose = function () {
+            AutoDetachObserver.super_.dispose.call(this);
+            this.m.dispose();
+        };
+
+        return AutoDetachObserver;
+    }());
+
+    var GroupedObservable = (function () {
+        function subscribe(observer) {
+            return this.underlyingObservable.subscribe(observer);
+        }
+
+        inherits(GroupedObservable, Observable);
+        function GroupedObservable(key, underlyingObservable, mergedDisposable) {
+            GroupedObservable.super_.constructor.call(this, subscribe);
+            this.key = key;
+            this.underlyingObservable = !mergedDisposable ?
+                underlyingObservable :
+                new AnonymousObservable(function (observer) {
+                    return new CompositeDisposable(mergedDisposable.getDisposable(), underlyingObservable.subscribe(observer));
+                });
+        }
+        return GroupedObservable;
+    }());
+
+    var InnerSubscription = function (subject, observer) {
+        this.subject = subject;
+        this.observer = observer;
+    };
+    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;
+        }
+    };
+
+    var Subject = root.Subject = (function () {
+        function subscribe(observer) {
+            checkDisposed.call(this);
+            if (!this.isStopped) {
+                this.observers.push(observer);
+                return new InnerSubscription(this, observer);
+            }
+            if (this.exception) {
+                observer.onError(this.exception);
+                return disposableEmpty;
+            }
+            observer.onCompleted();
+            return disposableEmpty;
+        }
+
+        inherits(Subject, Observable);
+        function Subject() {
+            Subject.super_.constructor.call(this, subscribe);
+            this.isDisposed = false,
+            this.isStopped = false,
+            this.observers = [];
+        }
+
+        addProperties(Subject.prototype, Observer, {
+            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 = [];
+                }
+            },
+            onError: function (exception) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    this.exception = exception;
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onError(exception);
+                    }
+
+                    this.observers = [];
+                }
+            },
+            onNext: function (value) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onNext(value);
+                    }
+                }
+            },
+            dispose: function () {
+                this.isDisposed = true;
+                this.observers = null;
+            }
+        });
+
+        Subject.create = function (observer, observable) {
+            return new AnonymousSubject(observer, observable);
+        };
+
+        return Subject;
+    }());
+
+    var AsyncSubject = root.AsyncSubject = (function () {
+
+        function subscribe(observer) {
+            checkDisposed.call(this);
+            if (!this.isStopped) {
+                this.observers.push(observer);
+                return new InnerSubscription(this, observer);
+            }
+            var ex = this.exception;
+            var hv = this.hasValue;
+            var v = this.value;
+            if (ex) {
+                observer.onError(ex);
+            } else if (hv) {
+                observer.onNext(v);
+                observer.onCompleted();
+            } else {
+                observer.onCompleted();
+            }
+            return disposableEmpty;
+        }
+
+        inherits(AsyncSubject, Observable);
+        function AsyncSubject() {
+            AsyncSubject.super_.constructor.call(this, subscribe);
+
+            this.isDisposed = false,
+            this.isStopped = false,
+            this.value = null,
+            this.hasValue = false,
+            this.observers = [],
+            this.exception = null;
+        }
+
+        addProperties(AsyncSubject.prototype, Observer, {
+            onCompleted: function () {
+                var o, i, len;
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    var v = this.value;
+                    var hv = this.hasValue;
+
+                    if (hv) {
+                        for (i = 0, len = os.length; i < len; i++) {
+                            o = os[i];
+                            o.onNext(v);
+                            o.onCompleted();
+                        }
+                    } else {
+                        for (i = 0, len = os.length; i < len; i++) {
+                            os[i].onCompleted();
+                        }
+                    }
+
+                    this.observers = [];
+                }
+            },
+            onError: function (exception) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    var os = this.observers.slice(0);
+                    this.isStopped = true;
+                    this.exception = exception;
+
+                    for (var i = 0, len = os.length; i < len; i++) {
+                        os[i].onError(exception);
+                    }
+
+                    this.observers = [];
+                }
+            },
+            onNext: function (value) {
+                checkDisposed.call(this);
+                if (!this.isStopped) {
+                    this.value = value;
+                    this.hasValue = true;
+                }
+            },
+            dispose: function () {
+                this.isDisposed = true;
+                this.observers = null;
+                this.exception = null;
+                this.value = null;
+            }
+        });
+
+        return AsyncSubject;
+    }());
+
+    var AnonymousSubject = (function () {
+        function subscribe(observer) {
+            return this.observable.subscribe(observer);
+        }
+
+        inherits(AnonymousSubject, Observable);
+        function AnonymousSubject(observer, observable) {
+            AnonymousSubject.super_.constructor.call(this, subscribe);
+            this.observer = observer;
+            this.observable = observable;
+        }
+
+        addProperties(AnonymousSubject.prototype, Observer, {
+            onCompleted: function () {
+                this.observer.onCompleted();
+            },
+            onError: function (exception) {
+                this.observer.onError(exception);
+            },
+            onNext: function (value) {
+                this.observer.onNext(value);
+            }
+        });
+
+        return AnonymousSubject;
+    }());
+
+    // Check for AMD
+    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+        window.Rx = root;
+        return define(function () {
+            return root;
+        });
+    } else if (freeExports) {
+        if (typeof module == 'object' && module && module.exports == freeExports) {
+            module.exports = root;
+        } else {
+            freeExports = root;
+        }
+    } else {
+        window.Rx = root;
+    }
+}(this));