// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

(function (window, undefined) {

var freeExports = typeof exports == 'object' && exports,

freeModule = typeof module == 'object' && module && module.exports == freeExports && module,

freeGlobal = typeof global == 'object' && global;

if (freeGlobal.global === freeGlobal) {

window = freeGlobal;

}

/**

* @name Rx

* @type Object

*/

var Rx = { Internals: {} };

// Defaults

function noop() { }

function identity(x) { return x; }

function defaultNow() { return new Date().getTime(); }

function defaultComparer(x, y) { return isEqual(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);

}

}

/** Used to determine if values are of the language type Object */

var objectTypes = {

'boolean': false,

'function': true,

'object': true,

'number': false,

'string': false,

'undefined': false

};

/** `Object#toString` result shortcuts */

var argsClass = '[object Arguments]',

arrayClass = '[object Array]',

boolClass = '[object Boolean]',

dateClass = '[object Date]',

errorClass = '[object Error]',

funcClass = '[object Function]',

numberClass = '[object Number]',

objectClass = '[object Object]',

regexpClass = '[object RegExp]',

stringClass = '[object String]';

var toString = Object.prototype.toString,

hasOwnProperty = Object.prototype.hasOwnProperty,

supportsArgsClass = toString.call(arguments) == argsClass, // For less <IE9 && FF<4

suportNodeClass;

try {

suportNodeClass = !(toString.call(document) == objectClass && !({ 'toString': 0 } + ''));

} catch(e) {

suportNodeClass = true;

}

function isNode(value) {

// IE < 9 presents DOM nodes as `Object` objects except they have `toString`

// methods that are `typeof` "string" and still can coerce nodes to strings

return typeof value.toString != 'function' && typeof (value + '') == 'string';

}

function isArguments(value) {

return (value && typeof value == 'object') ? toString.call(value) == argsClass : false;

}

// fallback for browsers that can't detect `arguments` objects by [[Class]]

if (!supportsArgsClass) {

isArguments = function(value) {

return (value && typeof value == 'object') ? hasOwnProperty.call(value, 'callee') : false;

};

}

function isFunction(value) {

return typeof value == 'function';

}

// fallback for older versions of Chrome and Safari

if (isFunction(/x/)) {

isFunction = function(value) {

return typeof value == 'function' && toString.call(value) == funcClass;

};

}

var isEqual = Rx.Internals.isEqual = function (x, y) {

return deepEquals(x, y, [], []);

};

/** @private

* Used for deep comparison

**/

function deepEquals(a, b, stackA, stackB) {

var result;

// exit early for identical values

if (a === b) {

// treat `+0` vs. `-0` as not equal

return a !== 0 || (1 / a == 1 / b);

}

var type = typeof a,

otherType = typeof b;

// exit early for unlike primitive values

if (a === a &&

!(a && objectTypes[type]) &&

!(b && objectTypes[otherType])) {

return false;

}

// exit early for `null` and `undefined`, avoiding ES3's Function#call behavior

// http://es5.github.io/#x15.3.4.4

if (a == null || b == null) {

return a === b;

}

// compare [[Class]] names

var className = toString.call(a),

otherClass = toString.call(b);

if (className == argsClass) {

className = objectClass;

}

if (otherClass == argsClass) {

otherClass = objectClass;

}

if (className != otherClass) {

return false;

}

switch (className) {

case boolClass:

case dateClass:

// coerce dates and booleans to numbers, dates to milliseconds and booleans

// to `1` or `0`, treating invalid dates coerced to `NaN` as not equal

return +a == +b;

case numberClass:

// treat `NaN` vs. `NaN` as equal

return (a != +a)

? b != +b

// but treat `+0` vs. `-0` as not equal

: (a == 0 ? (1 / a == 1 / b) : a == +b);

case regexpClass:

case stringClass:

// coerce regexes to strings (http://es5.github.io/#x15.10.6.4)

// treat string primitives and their corresponding object instances as equal

return a == String(b);

}

var isArr = className == arrayClass;

if (!isArr) {

// exit for functions and DOM nodes

if (className != objectClass || (!suportNodeClass && (isNode(a) || isNode(b)))) {

return false;

}

// in older versions of Opera, `arguments` objects have `Array` constructors

var ctorA = !supportsArgsClass && isArguments(a) ? Object : a.constructor,

ctorB = !supportsArgsClass && isArguments(b) ? Object : b.constructor;

// non `Object` object instances with different constructors are not equal

if (ctorA != ctorB && !(

isFunction(ctorA) && ctorA instanceof ctorA &&

isFunction(ctorB) && ctorB instanceof ctorB

)) {

return false;

}

}

// assume cyclic structures are equal

// the algorithm for detecting cyclic structures is adapted from ES 5.1

// section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)

var length = stackA.length;

while (length--) {

if (stackA[length] == a) {

return stackB[length] == b;

}

}

var size = 0;

result = true;

// add `a` and `b` to the stack of traversed objects

stackA.push(a);

stackB.push(b);

// recursively compare objects and arrays (susceptible to call stack limits)

if (isArr) {

length = a.length;

size = b.length;

// compare lengths to determine if a deep comparison is necessary

result = size == a.length;

// deep compare the contents, ignoring non-numeric properties

while (size--) {

var index = length,

value = b[size];

if (!(result = deepEquals(a[size], value, stackA, stackB))) {

break;

}

}

return result;

}

// deep compare each object

for(var key in b) {

if (hasOwnProperty.call(b, key)) {

// count properties and deep compare each property value

size++;

return (result = hasOwnProperty.call(a, key) && deepEquals(a[key], b[key], stackA, stackB));

}

}

if (result) {

// ensure both objects have the same number of properties

for (var key in a) {

if (hasOwnProperty.call(a, key)) {

// `size` will be `-1` if `a` has more properties than `b`

return (result = --size > -1);

}

}

}

stackA.pop();

stackB.pop();

return result;

}

var slice = Array.prototype.slice;

function argsOrArray(args, idx) {

return args.length === 1 && Array.isArray(args[idx]) ?

args[idx] :

slice.call(args);

}

var hasProp = {}.hasOwnProperty;

/** @private */

var inherits = this.inherits = Rx.Internals.inherits = function (child, parent) {

function __() { this.constructor = child; }

__.prototype = parent.prototype;

child.prototype = new __();

};

/** @private */

var addProperties = Rx.Internals.addProperties = function (obj) {

var sources = slice.call(arguments, 1);

for (var i = 0, len = sources.length; i < len; i++) {

var source = sources[i];

for (var prop in source) {

obj[prop] = source[prop];

}

}

};

// Rx Utils

var addRef = Rx.Internals.addRef = function (xs, r) {

return new AnonymousObservable(function (observer) {

return new CompositeDisposable(r.getDisposable(), xs.subscribe(observer));

});

};

// Collection polyfills

function arrayInitialize(count, factory) {

var a = new Array(count);

for (var i = 0; i < count; i++) {

a[i] = factory();

}

return a;

}

// Utilities

if (!Function.prototype.bind) {

Function.prototype.bind = function (that) {

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 boxedString = Object("a"),

splitString = boxedString[0] != "a" || !(0 in boxedString);

if (!Array.prototype.every) {

Array.prototype.every = function every(fun /*, thisp */) {

var object = Object(this),

self = splitString && {}.toString.call(this) == "[object String]" ?

this.split("") :

object,

length = self.length >>> 0,

thisp = arguments[1];

if ({}.toString.call(fun) != "[object Function]") {

throw new TypeError(fun + " is not a function");

}

for (var i = 0; i < length; i++) {

if (i in self && !fun.call(thisp, self[i], i, object)) {

return false;

}

}

return true;

};

}

if (!Array.prototype.map) {

Array.prototype.map = function map(fun /*, thisp*/) {

var object = Object(this),

self = splitString && {}.toString.call(this) == "[object String]" ?

this.split("") :

object,

length = self.length >>> 0,

result = Array(length),

thisp = arguments[1];

if ({}.toString.call(fun) != "[object Function]") {

throw new TypeError(fun + " is not a function");

}

for (var i = 0; i < length; i++) {

if (i in self)

result[i] = fun.call(thisp, self[i], i, object);

}

return result;

};

}

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(searchElement) {

var t = Object(this);

var len = t.length >>> 0;

if (len === 0) {

return -1;

}

var n = 0;

if (arguments.length > 1) {

n = Number(arguments[1]);

if (n !== n) {

n = 0;

} else if (n !== 0 && n != Infinity && n !== -Infinity) {

n = (n > 0 || -1) * Math.floor(Math.abs(n));

}

}

if (n >= len) {

return -1;

}

var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);

for (; k < len; k++) {

if (k in t && t[k] === searchElement) {

return k;

}

}

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;

/**

* Represents a group of disposable resources that are disposed together.

*

* @constructor

*/

var CompositeDisposable = Rx.CompositeDisposable = function () {

this.disposables = argsOrArray(arguments, 0);

this.isDisposed = false;

this.length = this.disposables.length;

};

var CompositeDisposablePrototype = CompositeDisposable.prototype;

/**

* Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.

*

* @param {Mixed} item Disposable to add.

*/

CompositeDisposablePrototype.add = function (item) {

if (this.isDisposed) {

item.dispose();

} else {

this.disposables.push(item);

this.length++;

}

};

/**

* Removes and disposes the first occurrence of a disposable from the CompositeDisposable.

*

* @memberOf CompositeDisposable#

* @param {Mixed} item Disposable to remove.

* @returns {Boolean} true if found; false otherwise.

*/

CompositeDisposablePrototype.remove = function (item) {

var shouldDispose = false;

if (!this.isDisposed) {

var idx = this.disposables.indexOf(item);

if (idx !== -1) {

shouldDispose = true;

this.disposables.splice(idx, 1);

this.length--;

item.dispose();

}

}

return shouldDispose;

};

/**

* Disposes all disposables in the group and removes them from the group.

*

* @memberOf CompositeDisposable#

*/

CompositeDisposablePrototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

var currentDisposables = this.disposables.slice(0);

this.disposables = [];

this.length = 0;

for (var i = 0, len = currentDisposables.length; i < len; i++) {

currentDisposables[i].dispose();

}

}

};

/**

* Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable.

*

* @memberOf CompositeDisposable#

*/

CompositeDisposablePrototype.clear = function () {

var currentDisposables = this.disposables.slice(0);

this.disposables = [];

this.length = 0;

for (var i = 0, len = currentDisposables.length; i < len; i++) {

currentDisposables[i].dispose();

}

};

/**

* Determines whether the CompositeDisposable contains a specific disposable.

*

* @memberOf CompositeDisposable#

* @param {Mixed} item Disposable to search for.

* @returns {Boolean} true if the disposable was found; otherwise, false.

*/

CompositeDisposablePrototype.contains = function (item) {

return this.disposables.indexOf(item) !== -1;

};

/**

* Converts the existing CompositeDisposable to an array of disposables

*

* @memberOf CompositeDisposable#

* @returns {Array} An array of disposable objects.

*/

CompositeDisposablePrototype.toArray = function () {

return this.disposables.slice(0);

};

/**

* Provides a set of static methods for creating Disposables.

*

* @constructor

* @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.

*/

var Disposable = Rx.Disposable = function (action) {

this.isDisposed = false;

this.action = action || noop;

};

/**

* Performs the task of cleaning up resources.

*

* @memberOf Disposable#

*/

Disposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.action();

this.isDisposed = true;

}

};

/**

* Creates a disposable object that invokes the specified action when disposed.

*

* @static

* @memberOf Disposable

* @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.

* @return {Disposable} The disposable object that runs the given action upon disposal.

*/

var disposableCreate = Disposable.create = function (action) { return new Disposable(action); };

/**

* Gets the disposable that does nothing when disposed.

*

* @static

* @memberOf Disposable

*/

var disposableEmpty = Disposable.empty = { dispose: noop };

/**

* Represents a disposable resource which only allows a single assignment of its underlying disposable resource.

* If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an Error.

*

* @constructor

*/

var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = function () {

this.isDisposed = false;

this.current = null;

};

var SingleAssignmentDisposablePrototype = SingleAssignmentDisposable.prototype;

/**

* Gets or sets the underlying disposable. After disposal, the result of getting this method is undefined.

*

* @memberOf SingleAssignmentDisposable#

* @param {Disposable} [value] The new underlying disposable.

* @returns {Disposable} The underlying disposable.

*/

SingleAssignmentDisposablePrototype.disposable = function (value) {

return !value ? this.getDisposable() : this.setDisposable(value);

};

/**

* Gets the underlying disposable. After disposal, the result of getting this method is undefined.

*

* @memberOf SingleAssignmentDisposable#

* @returns {Disposable} The underlying disposable.

*/

SingleAssignmentDisposablePrototype.getDisposable = function () {

return this.current;

};

/**

* Sets the underlying disposable.

*

* @memberOf SingleAssignmentDisposable#

* @param {Disposable} value The new underlying disposable.

*/

SingleAssignmentDisposablePrototype.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();

}

};

/**

* Disposes the underlying disposable.

*

* @memberOf SingleAssignmentDisposable#

*/

SingleAssignmentDisposablePrototype.dispose = function () {

var old;

if (!this.isDisposed) {

this.isDisposed = true;

old = this.current;

this.current = null;

}

if (old) {

old.dispose();

}

};

/**

* Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource.

*

* @constructor

*/

var SerialDisposable = Rx.SerialDisposable = function () {

this.isDisposed = false;

this.current = null;

};

/**

* Gets the underlying disposable.

* @return The underlying disposable</returns>

*/

SerialDisposable.prototype.getDisposable = function () {

return this.current;

};

/**

* Sets the underlying disposable.

*

* @memberOf SerialDisposable#

* @param {Disposable} value The new underlying disposable.

*/

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();

}

};

/**

* Gets or sets the underlying disposable.

* If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object.

*

* @memberOf SerialDisposable#

* @param {Disposable} [value] The new underlying disposable.

* @returns {Disposable} The underlying disposable.

*/

SerialDisposable.prototype.disposable = function (value) {

if (!value) {

return this.getDisposable();

} else {

this.setDisposable(value);

}

};

/**

* Disposes the underlying disposable as well as all future replacements.

*

* @memberOf SerialDisposable#

*/

SerialDisposable.prototype.dispose = function () {

var old;

if (!this.isDisposed) {

this.isDisposed = true;

old = this.current;

this.current = null;

}

if (old) {

old.dispose();

}

};

/**

* Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed.

*/

var RefCountDisposable = Rx.RefCountDisposable = (function () {

/**

* @constructor

* @private

*/

function InnerDisposable(disposable) {

this.disposable = disposable;

this.disposable.count++;

this.isInnerDisposed = false;

}

/** @private */

InnerDisposable.prototype.dispose = function () {

if (!this.disposable.isDisposed) {

if (!this.isInnerDisposed) {

this.isInnerDisposed = true;

this.disposable.count--;

if (this.disposable.count === 0 && this.disposable.isPrimaryDisposed) {

this.disposable.isDisposed = true;

this.disposable.underlyingDisposable.dispose();

}

}

}

};

/**

* Initializes a new instance of the RefCountDisposable with the specified disposable.

*

* @constructor

* @param {Disposable} disposable Underlying disposable.

*/

function RefCountDisposable(disposable) {

this.underlyingDisposable = disposable;

this.isDisposed = false;

this.isPrimaryDisposed = false;

this.count = 0;

}

/**

* Disposes the underlying disposable only when all dependent disposables have been disposed

*

* @memberOf RefCountDisposable#

*/

RefCountDisposable.prototype.dispose = function () {

if (!this.isDisposed) {

if (!this.isPrimaryDisposed) {

this.isPrimaryDisposed = true;

if (this.count === 0) {

this.isDisposed = true;

this.underlyingDisposable.dispose();

}

}

}

};

/**

* Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable.

*

* @memberOf RefCountDisposable#

* @returns {Disposable} A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime.H

*/

RefCountDisposable.prototype.getDisposable = function () {

return this.isDisposed ? disposableEmpty : new InnerDisposable(this);

};

return RefCountDisposable;

})();

/**

* @constructor

* @private

*/

function ScheduledDisposable(scheduler, disposable) {

this.scheduler = scheduler, this.disposable = disposable, this.isDisposed = false;

}

/**

* @private

* @memberOf ScheduledDisposable#

*/

ScheduledDisposable.prototype.dispose = function () {

var parent = this;

this.scheduler.schedule(function () {

if (!parent.isDisposed) {

parent.isDisposed = true;

parent.disposable.dispose();

}

});

};

/**

* @private

* @constructor

*/

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();

}

/**

* @private

* @memberOf ScheduledItem#

*/

ScheduledItem.prototype.invoke = function () {

this.disposable.disposable(this.invokeCore());

};

/**

* @private

* @memberOf ScheduledItem#

*/

ScheduledItem.prototype.compareTo = function (other) {

return this.comparer(this.dueTime, other.dueTime);

};

/**

* @private

* @memberOf ScheduledItem#

*/

ScheduledItem.prototype.isCancelled = function () {

return this.disposable.isDisposed;

};

/**

* @private

* @memberOf ScheduledItem#

*/

ScheduledItem.prototype.invokeCore = function () {

return this.action(this.scheduler, this.state);

};

/** Provides a set of static properties to access commonly used schedulers. */

var Scheduler = Rx.Scheduler = (function () {

/**

* @constructor

* @private

*/

function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) {

this.now = now;

this._schedule = schedule;

this._scheduleRelative = scheduleRelative;

this._scheduleAbsolute = scheduleAbsolute;

}

function invokeRecImmediate(scheduler, pair) {

var state = pair.first, action = pair.second, group = new CompositeDisposable(),

recursiveAction = function (state1) {

action(state1, function (state2) {

var isAdded = false, isDone = false,

d = scheduler.scheduleWithState(state2, function (scheduler1, state3) {

if (isAdded) {

group.remove(d);

} else {

isDone = true;

}

recursiveAction(state3);

return disposableEmpty;

});

if (!isDone) {

group.add(d);

isAdded = true;

}

});

};

recursiveAction(state);

return group;

}

function invokeRecDate(scheduler, pair, method) {

var state = pair.first, action = pair.second, group = new CompositeDisposable(),

recursiveAction = function (state1) {

action(state1, function (state2, dueTime1) {

var isAdded = false, isDone = false,

d = scheduler[method].call(scheduler, state2, dueTime1, function (scheduler1, state3) {

if (isAdded) {

group.remove(d);

} else {

isDone = true;

}

recursiveAction(state3);

return disposableEmpty;

});

if (!isDone) {

group.add(d);

isAdded = true;

}

});

};

recursiveAction(state);

return group;

}

function invokeAction(scheduler, action) {

action();

return disposableEmpty;

}

var schedulerProto = Scheduler.prototype;

/**

* Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions.

*

* @memberOf Scheduler#

* @param {Function} handler Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false.

* @returns {Scheduler} Wrapper around the original scheduler, enforcing exception handling.

*/

schedulerProto.catchException = function (handler) {

return new CatchScheduler(this, handler);

};

/**

* Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. The periodic task will be scheduled using window.setInterval for the base implementation.

*

* @memberOf Scheduler#

* @param {Number} period Period for running the work periodically.

* @param {Function} action Action to be executed.