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

;(function (undefined) {

var objectTypes = {

'function': true,

'object': true

};

function checkGlobal(value) {

return (value && value.Object === Object) ? value : null;

}

var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType) ? exports : null;

var freeModule = (objectTypes[typeof module] && module && !module.nodeType) ? module : null;

var freeGlobal = checkGlobal(freeExports && freeModule && typeof global === 'object' && global);

var freeSelf = checkGlobal(objectTypes[typeof self] && self);

var freeWindow = checkGlobal(objectTypes[typeof window] && window);

var moduleExports = (freeModule && freeModule.exports === freeExports) ? freeExports : null;

var thisGlobal = checkGlobal(objectTypes[typeof this] && this);

var root = freeGlobal || ((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) || freeSelf || thisGlobal || Function('return this')();

var Rx = {

internals: {},

config: {

Promise: root.Promise

},

helpers: { }

};

// Defaults

var noop = Rx.helpers.noop = function () { },

identity = Rx.helpers.identity = function (x) { return x; },

defaultNow = Rx.helpers.defaultNow = Date.now,

defaultComparer = Rx.helpers.defaultComparer = function (x, y) { return isEqual(x, y); },

defaultSubComparer = Rx.helpers.defaultSubComparer = function (x, y) { return x > y ? 1 : (x < y ? -1 : 0); },

defaultKeySerializer = Rx.helpers.defaultKeySerializer = function (x) { return x.toString(); },

defaultError = Rx.helpers.defaultError = function (err) { throw err; },

isPromise = Rx.helpers.isPromise = function (p) { return !!p && typeof p.subscribe !== 'function' && typeof p.then === 'function'; },

isFunction = Rx.helpers.isFunction = (function () {

var isFn = function (value) {

return typeof value == 'function' || false;

}

// fallback for older versions of Chrome and Safari

if (isFn(/x/)) {

isFn = function(value) {

return typeof value == 'function' && toString.call(value) == '[object Function]';

};

}

return isFn;

}());

function cloneArray(arr) { for(var a = [], i = 0, len = arr.length; i < len; i++) { a.push(arr[i]); } return a;}

var errorObj = {e: {}};

function tryCatcherGen(tryCatchTarget) {

return function tryCatcher() {

try {

return tryCatchTarget.apply(this, arguments);

} catch (e) {

errorObj.e = e;

return errorObj;

}

};

}

var tryCatch = Rx.internals.tryCatch = function tryCatch(fn) {

if (!isFunction(fn)) { throw new TypeError('fn must be a function'); }

return tryCatcherGen(fn);

};

function thrower(e) {

throw e;

}

Rx.config.longStackSupport = false;

var hasStacks = false, stacks = tryCatch(function () { throw new Error(); })();

hasStacks = !!stacks.e && !!stacks.e.stack;

// All code after this point will be filtered from stack traces reported by RxJS

var rStartingLine = captureLine(), rFileName;

var STACK_JUMP_SEPARATOR = 'From previous event:';

function makeStackTraceLong(error, observable) {

// If possible, transform the error stack trace by removing Node and RxJS

// cruft, then concatenating with the stack trace of `observable`.

if (hasStacks &&

observable.stack &&

typeof error === 'object' &&

error !== null &&

error.stack &&

error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1

) {

var stacks = [];

for (var o = observable; !!o; o = o.source) {

if (o.stack) {

stacks.unshift(o.stack);

}

}

stacks.unshift(error.stack);

var concatedStacks = stacks.join('\n' + STACK_JUMP_SEPARATOR + '\n');

error.stack = filterStackString(concatedStacks);

}

}

function filterStackString(stackString) {

var lines = stackString.split('\n'), desiredLines = [];

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

var line = lines[i];

if (!isInternalFrame(line) && !isNodeFrame(line) && line) {

desiredLines.push(line);

}

}

return desiredLines.join('\n');

}

function isInternalFrame(stackLine) {

var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);

if (!fileNameAndLineNumber) {

return false;

}

var fileName = fileNameAndLineNumber[0], lineNumber = fileNameAndLineNumber[1];

return fileName === rFileName &&

lineNumber >= rStartingLine &&

lineNumber <= rEndingLine;

}

function isNodeFrame(stackLine) {

return stackLine.indexOf('(module.js:') !== -1 ||

stackLine.indexOf('(node.js:') !== -1;

}

function captureLine() {

if (!hasStacks) { return; }

try {

throw new Error();

} catch (e) {

var lines = e.stack.split('\n');

var firstLine = lines[0].indexOf('@') > 0 ? lines[1] : lines[2];

var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);

if (!fileNameAndLineNumber) { return; }

rFileName = fileNameAndLineNumber[0];

return fileNameAndLineNumber[1];

}

}

function getFileNameAndLineNumber(stackLine) {

// Named functions: 'at functionName (filename:lineNumber:columnNumber)'

var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);

if (attempt1) { return [attempt1[1], Number(attempt1[2])]; }

// Anonymous functions: 'at filename:lineNumber:columnNumber'

var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);

if (attempt2) { return [attempt2[1], Number(attempt2[2])]; }

// Firefox style: 'function@filename:lineNumber or @filename:lineNumber'

var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);

if (attempt3) { return [attempt3[1], Number(attempt3[2])]; }

}

var EmptyError = Rx.EmptyError = function() {

this.message = 'Sequence contains no elements.';

Error.call(this);

};

EmptyError.prototype = Object.create(Error.prototype);

EmptyError.prototype.name = 'EmptyError';

var ObjectDisposedError = Rx.ObjectDisposedError = function() {

this.message = 'Object has been disposed';

Error.call(this);

};

ObjectDisposedError.prototype = Object.create(Error.prototype);

ObjectDisposedError.prototype.name = 'ObjectDisposedError';

var ArgumentOutOfRangeError = Rx.ArgumentOutOfRangeError = function () {

this.message = 'Argument out of range';

Error.call(this);

};

ArgumentOutOfRangeError.prototype = Object.create(Error.prototype);

ArgumentOutOfRangeError.prototype.name = 'ArgumentOutOfRangeError';

var NotSupportedError = Rx.NotSupportedError = function (message) {

this.message = message || 'This operation is not supported';

Error.call(this);

};

NotSupportedError.prototype = Object.create(Error.prototype);

NotSupportedError.prototype.name = 'NotSupportedError';

var NotImplementedError = Rx.NotImplementedError = function (message) {

this.message = message || 'This operation is not implemented';

Error.call(this);

};

NotImplementedError.prototype = Object.create(Error.prototype);

NotImplementedError.prototype.name = 'NotImplementedError';

var notImplemented = Rx.helpers.notImplemented = function () {

throw new NotImplementedError();

};

var notSupported = Rx.helpers.notSupported = function () {

throw new NotSupportedError();

};

// Shim in iterator support

var $iterator$ = (typeof Symbol === 'function' && Symbol.iterator) ||

'_es6shim_iterator_';

// Bug for mozilla version

if (root.Set && typeof new root.Set()['@@iterator'] === 'function') {

$iterator$ = '@@iterator';

}

var doneEnumerator = Rx.doneEnumerator = { done: true, value: undefined };

var isIterable = Rx.helpers.isIterable = function (o) {

return o[$iterator$] !== undefined;

}

var isArrayLike = Rx.helpers.isArrayLike = function (o) {

return o && o.length !== undefined;

}

Rx.helpers.iterator = $iterator$;

var bindCallback = Rx.internals.bindCallback = function (func, thisArg, argCount) {

if (typeof thisArg === 'undefined') { return func; }

switch(argCount) {

case 0:

return function() {

return func.call(thisArg)

};

case 1:

return function(arg) {

return func.call(thisArg, arg);

}

case 2:

return function(value, index) {

return func.call(thisArg, value, index);

};

case 3:

return function(value, index, collection) {

return func.call(thisArg, value, index, collection);

};

}

return function() {

return func.apply(thisArg, arguments);

};

};

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

var dontEnums = ['toString',

'toLocaleString',

'valueOf',

'hasOwnProperty',

'isPrototypeOf',

'propertyIsEnumerable',

'constructor'],

dontEnumsLength = dontEnums.length;

/** `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

supportNodeClass,

errorProto = Error.prototype,

objectProto = Object.prototype,

stringProto = String.prototype,

propertyIsEnumerable = objectProto.propertyIsEnumerable;

try {

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

} catch (e) {

supportNodeClass = true;

}

var nonEnumProps = {};

nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };

nonEnumProps[boolClass] = nonEnumProps[stringClass] = { 'constructor': true, 'toString': true, 'valueOf': true };

nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { 'constructor': true, 'toString': true };

nonEnumProps[objectClass] = { 'constructor': true };

var support = {};

(function () {

var ctor = function() { this.x = 1; },

props = [];

ctor.prototype = { 'valueOf': 1, 'y': 1 };

for (var key in new ctor) { props.push(key); }

for (key in arguments) { }

// Detect if `name` or `message` properties of `Error.prototype` are enumerable by default.

support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name');

// Detect if `prototype` properties are enumerable by default.

support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype');

// Detect if `arguments` object indexes are non-enumerable

support.nonEnumArgs = key != 0;

// Detect if properties shadowing those on `Object.prototype` are non-enumerable.

support.nonEnumShadows = !/valueOf/.test(props);

}(1));

var isObject = Rx.internals.isObject = function(value) {

var type = typeof value;

return value && (type == 'function' || type == 'object') || false;

};

function keysIn(object) {

var result = [];

if (!isObject(object)) {

return result;

}

if (support.nonEnumArgs && object.length && isArguments(object)) {

object = slice.call(object);

}

var skipProto = support.enumPrototypes && typeof object == 'function',

skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error);

for (var key in object) {

if (!(skipProto && key == 'prototype') &&

!(skipErrorProps && (key == 'message' || key == 'name'))) {

result.push(key);

}

}

if (support.nonEnumShadows && object !== objectProto) {

var ctor = object.constructor,

index = -1,

length = dontEnumsLength;

if (object === (ctor && ctor.prototype)) {

var className = object === stringProto ? stringClass : object === errorProto ? errorClass : toString.call(object),

nonEnum = nonEnumProps[className];

}

while (++index < length) {

key = dontEnums[index];

if (!(nonEnum && nonEnum[key]) && hasOwnProperty.call(object, key)) {

result.push(key);

}

}

}

return result;

}

function internalFor(object, callback, keysFunc) {

var index = -1,

props = keysFunc(object),

length = props.length;

while (++index < length) {

var key = props[index];

if (callback(object[key], key, object) === false) {

break;

}

}

return object;

}

function internalForIn(object, callback) {

return internalFor(object, callback, keysIn);

}

function isNode(value) {

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

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

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

}

var isArguments = function(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;

};

}

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

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

};

/** @private

* Used for deep comparison

**/

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

// exit early for identical values

if (a === b) {

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

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

}

var type = typeof a,

otherType = typeof b;

// exit early for unlike primitive values

if (a === a && (a == null || b == null ||

(type != 'function' && type != 'object' && otherType != 'function' && otherType != 'object'))) {

return false;

}

// compare [[Class]] names

var className = toString.call(a),

otherClass = toString.call(b);

if (className == argsClass) {

className = objectClass;

}

if (otherClass == argsClass) {

otherClass = objectClass;

}

if (className != otherClass) {

return false;

}

switch (className) {

case boolClass:

case dateClass:

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

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

return +a == +b;

case numberClass:

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

return (a != +a) ?

b != +b :

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

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

case regexpClass:

case stringClass:

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

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

return a == String(b);

}

var isArr = className == arrayClass;

if (!isArr) {

// exit for functions and DOM nodes

if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) {

return false;

}

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

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

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

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

if (ctorA != ctorB &&

!(hasOwnProperty.call(a, 'constructor') && hasOwnProperty.call(b, 'constructor')) &&

!(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&

('constructor' in a && 'constructor' in b)

) {

return false;

}

}

// assume cyclic structures are equal

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

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

var initedStack = !stackA;

stackA || (stackA = []);

stackB || (stackB = []);

var length = stackA.length;

while (length--) {

if (stackA[length] == a) {

return stackB[length] == b;

}

}

var size = 0;

var result = true;

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

stackA.push(a);

stackB.push(b);

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

if (isArr) {

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

length = a.length;

size = b.length;

result = size == length;

if (result) {

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

while (size--) {

var index = length,

value = b[size];

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

break;

}

}

}

}

else {

// deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`

// which, in this case, is more costly

internalForIn(b, function(value, key, b) {

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

// count the number of properties.

size++;

// deep compare each property value.

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

}

});

if (result) {

// ensure both objects have the same number of properties

internalForIn(a, function(value, key, a) {

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

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

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

}

});

}

}

stackA.pop();

stackB.pop();

return result;

}

var hasProp = {}.hasOwnProperty,

slice = Array.prototype.slice;

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

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

__.prototype = parent.prototype;

child.prototype = new __();

};

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

for(var sources = [], i = 1, len = arguments.length; i < len; i++) { sources.push(arguments[i]); }

for (var idx = 0, ln = sources.length; idx < ln; idx++) {

var source = sources[idx];

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 BinaryDisposable(r.getDisposable(), xs.subscribe(observer));

});

};

function arrayInitialize(count, factory) {

var a = new Array(count);

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

a[i] = factory();

}

return a;

}

/**

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

* @constructor

*/

var CompositeDisposable = Rx.CompositeDisposable = function () {

var args = [], i, len;

if (Array.isArray(arguments[0])) {

args = arguments[0];

len = args.length;

} else {

len = arguments.length;

args = new Array(len);

for(i = 0; i < len; i++) { args[i] = arguments[i]; }

}

this.disposables = args;

this.isDisposed = false;

this.length = args.length;

};

var CompositeDisposablePrototype = CompositeDisposable.prototype;

/**

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

* @param {Mixed} item Disposable to add.

*/

CompositeDisposablePrototype.add = function (item) {

if (this.isDisposed) {

item.dispose();

} else {

this.disposables.push(item);

this.length++;

}

};

/**

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

* @param {Mixed} item Disposable to remove.

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

*/

CompositeDisposablePrototype.remove = function (item) {

var shouldDispose = false;

if (!this.isDisposed) {

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

if (idx !== -1) {

shouldDispose = true;

this.disposables.splice(idx, 1);

this.length--;

item.dispose();

}

}

return shouldDispose;

};

/**

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

*/

CompositeDisposablePrototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

var len = this.disposables.length, currentDisposables = new Array(len);

for(var i = 0; i < len; i++) { currentDisposables[i] = this.disposables[i]; }

this.disposables = [];

this.length = 0;

for (i = 0; i < len; i++) {

currentDisposables[i].dispose();

}

}

};

/**

* Provides a set of static methods for creating Disposables.

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

*/

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

this.isDisposed = false;

this.action = action || noop;

};

/** Performs the task of cleaning up resources. */

Disposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.action();

this.isDisposed = true;

}

};

/**

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

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

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

*/

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

/**

* Gets the disposable that does nothing when disposed.

*/

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

/**

* Validates whether the given object is a disposable

* @param {Object} Object to test whether it has a dispose method

* @returns {Boolean} true if a disposable object, else false.

*/

var isDisposable = Disposable.isDisposable = function (d) {

return d && isFunction(d.dispose);

};

var checkDisposed = Disposable.checkDisposed = function (disposable) {

if (disposable.isDisposed) { throw new ObjectDisposedError(); }

};

var disposableFixup = Disposable._fixup = function (result) {

return isDisposable(result) ? result : disposableEmpty;

};

// Single assignment

var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = function () {

this.isDisposed = false;

this.current = null;

};

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;

!shouldDispose && (this.current = value);

shouldDispose && value && value.dispose();

};

SingleAssignmentDisposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

var old = this.current;

this.current = null;

old && old.dispose();

}

};

// Multiple assignment disposable

var SerialDisposable = Rx.SerialDisposable = function () {

this.isDisposed = false;

this.current = null;

};

SerialDisposable.prototype.getDisposable = function () {

return this.current;

};

SerialDisposable.prototype.setDisposable = function (value) {

var shouldDispose = this.isDisposed;

if (!shouldDispose) {

var old = this.current;

this.current = value;

}

old && old.dispose();

shouldDispose && value && value.dispose();

};

SerialDisposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

var old = this.current;

this.current = null;

}

old && old.dispose();

};

var BinaryDisposable = Rx.BinaryDisposable = function (first, second) {

this._first = first;

this._second = second;

this.isDisposed = false;

};

BinaryDisposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

var old1 = this._first;

this._first = null;

old1 && old1.dispose();

var old2 = this._second;

this._second = null;

old2 && old2.dispose();

}

};

var NAryDisposable = Rx.NAryDisposable = function (disposables) {

this._disposables = disposables;

this.isDisposed = false;

};

NAryDisposable.prototype.dispose = function () {

if (!this.isDisposed) {

this.isDisposed = true;

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

this._disposables[i].dispose();

}

this._disposables.length = 0;

}

};

/**

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

*/

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

function InnerDisposable(disposable) {

this.disposable = disposable;

this.disposable.count++;

this.isInnerDisposed = false;

}

InnerDisposable.prototype.dispose = function () {

if (!this.disposable.isDisposed && !this.isInnerDisposed) {

this.isInnerDisposed = true;

this.disposable.count--;

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

this.disposable.isDisposed = true;

this.disposable.underlyingDisposable.dispose();

}

}

};

/**

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

* @constructor

* @param {Disposable} disposable Underlying disposable.

*/

function RefCountDisposable(disposable) {

this.underlyingDisposable = disposable;

this.isDisposed = false;

this.isPrimaryDisposed = false;

this.count = 0;

}

/**

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

*/

RefCountDisposable.prototype.dispose = function () {

if (!this.isDisposed && !this.isPrimaryDisposed) {

this.isPrimaryDisposed = true;

if (this.count === 0) {

this.isDisposed = true;

this.underlyingDisposable.dispose();

}

}

};

/**

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

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

*/

RefCountDisposable.prototype.getDisposable = function () {

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

};

return RefCountDisposable;

})();

function ScheduledDisposable(scheduler, disposable) {

this.scheduler = scheduler;

this.disposable = disposable;

this.isDisposed = false;

}

function scheduleItem(s, self) {

if (!self.isDisposed) {

self.isDisposed = true;

self.disposable.dispose();

}

}

ScheduledDisposable.prototype.dispose = function () {

this.scheduler.schedule(this, scheduleItem);

};

var ScheduledItem = Rx.internals.ScheduledItem = function (scheduler, state, action, dueTime, comparer) {

this.scheduler = scheduler;

this.state = state;

this.action = action;

this.dueTime = dueTime;

this.comparer = comparer || defaultSubComparer;

this.disposable = new SingleAssignmentDisposable();

}

ScheduledItem.prototype.invoke = function () {

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

};

ScheduledItem.prototype.compareTo = function (other) {

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

};

ScheduledItem.prototype.isCancelled = function () {

return this.disposable.isDisposed;

};

ScheduledItem.prototype.invokeCore = function () {

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

};

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

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

function Scheduler() { }

/** Determines whether the given object is a scheduler */

Scheduler.isScheduler = function (s) {

return s instanceof Scheduler;

};

var schedulerProto = Scheduler.prototype;

/**

* Schedules an action to be executed.

* @param state State passed to the action to be executed.

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

* @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

*/

schedulerProto.schedule = function (state, action) {

throw new NotImplementedError();

};

/**

* Schedules an action to be executed after dueTime.

* @param state State passed to the action to be executed.

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

* @param {Number} dueTime Relative time after which to execute the action.

* @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

*/

schedulerProto.scheduleFuture = function (state, dueTime, action) {

var dt = dueTime;

dt instanceof Date && (dt = dt - this.now());

dt = Scheduler.normalize(dt);

if (dt === 0) { return this.schedule(state, action); }

return this._scheduleFuture(state, dt, action);

};

schedulerProto._scheduleFuture = function (state, dueTime, action) {

throw new NotImplementedError();

};

/** Gets the current time according to the local machine's system clock. */

Scheduler.now = defaultNow;

/** Gets the current time according to the local machine's system clock. */

Scheduler.prototype.now = defaultNow;

/**

* Normalizes the specified TimeSpan value to a positive value.

* @param {Number} timeSpan The time span value to normalize.

* @returns {Number} The specified TimeSpan value if it is zero or positive; otherwise, 0

*/

Scheduler.normalize = function (timeSpan) {

timeSpan < 0 && (timeSpan = 0);

return timeSpan;

};

return Scheduler;

}());

var normalizeTime = Scheduler.normalize, isScheduler = Scheduler.isScheduler;

(function (schedulerProto) {

function invokeRecImmediate(scheduler, pair) {

var state = pair[0], action = pair[1], group = new CompositeDisposable();

action(state, innerAction);

return group;

function innerAction(state2) {

var isAdded = false, isDone = false;

var d = scheduler.schedule(state2, scheduleWork);

if (!isDone) {

group.add(d);

isAdded = true;

}

function scheduleWork(_, state3) {

if (isAdded) {

group.remove(d);

} else {

isDone = true;

}

action(state3, innerAction);

return disposableEmpty;

}

}

}

function invokeRecDate(scheduler, pair) {

var state = pair[0], action = pair[1], group = new CompositeDisposable();

action(state, innerAction);

return group;

function innerAction(state2, dueTime1) {

var isAdded = false, isDone = false;

var d = scheduler.scheduleFuture(state2, dueTime1, scheduleWork);

if (!isDone) {

group.add(d);

isAdded = true;

}

function scheduleWork(_, state3) {

if (isAdded) {

group.remove(d);

} else {

isDone = true;

}

action(state3, innerAction);

return disposableEmpty;

}

}

}

/**

* Schedules an action to be executed recursively.

* @param {Mixed} state State passed to the action to be executed.

* @param {Function} action Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state.

* @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

*/