// 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) {

var len = arr.length, a = new Array(len);

for(var i = 0; i < len; i++) { a[i] = 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 && 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;

var argsTag = '[object Arguments]',

arrayTag = '[object Array]',

boolTag = '[object Boolean]',

dateTag = '[object Date]',

errorTag = '[object Error]',

funcTag = '[object Function]',

mapTag = '[object Map]',

numberTag = '[object Number]',

objectTag = '[object Object]',

regexpTag = '[object RegExp]',

setTag = '[object Set]',

stringTag = '[object String]',

weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',

float32Tag = '[object Float32Array]',

float64Tag = '[object Float64Array]',

int8Tag = '[object Int8Array]',

int16Tag = '[object Int16Array]',

int32Tag = '[object Int32Array]',

uint8Tag = '[object Uint8Array]',

uint8ClampedTag = '[object Uint8ClampedArray]',

uint16Tag = '[object Uint16Array]',

uint32Tag = '[object Uint32Array]';

var typedArrayTags = {};

typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

typedArrayTags[uint32Tag] = true;

typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

typedArrayTags[dateTag] = typedArrayTags[errorTag] =

typedArrayTags[funcTag] = typedArrayTags[mapTag] =

typedArrayTags[numberTag] = typedArrayTags[objectTag] =

typedArrayTags[regexpTag] = typedArrayTags[setTag] =

typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

var objectProto = Object.prototype,

hasOwnProperty = objectProto.hasOwnProperty,

objToString = objectProto.toString,

MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;

var keys = Object.keys || (function() {

var hasOwnProperty = Object.prototype.hasOwnProperty,

hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),

dontEnums = [

'toString',

'toLocaleString',

'valueOf',

'hasOwnProperty',

'isPrototypeOf',

'propertyIsEnumerable',

'constructor'

],

dontEnumsLength = dontEnums.length;

return function(obj) {

if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {

throw new TypeError('Object.keys called on non-object');

}

var result = [], prop, i;

for (prop in obj) {

if (hasOwnProperty.call(obj, prop)) {

result.push(prop);

}

}

if (hasDontEnumBug) {

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

if (hasOwnProperty.call(obj, dontEnums[i])) {

result.push(dontEnums[i]);

}

}

}

return result;

};

}());

function equalObjects(object, other, equalFunc, isLoose, stackA, stackB) {

var objProps = keys(object),

objLength = objProps.length,

othProps = keys(other),

othLength = othProps.length;

if (objLength !== othLength && !isLoose) {

return false;

}

var index = objLength, key;

while (index--) {

key = objProps[index];

if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {

return false;

}

}

var skipCtor = isLoose;

while (++index < objLength) {

key = objProps[index];

var objValue = object[key],

othValue = other[key],

result;

if (!(result === undefined ? equalFunc(objValue, othValue, isLoose, stackA, stackB) : result)) {

return false;

}

skipCtor || (skipCtor = key === 'constructor');

}

if (!skipCtor) {

var objCtor = object.constructor,

othCtor = other.constructor;

if (objCtor !== othCtor &&

('constructor' in object && 'constructor' in other) &&

!(typeof objCtor === 'function' && objCtor instanceof objCtor &&

typeof othCtor === 'function' && othCtor instanceof othCtor)) {

return false;

}

}

return true;

}

function equalByTag(object, other, tag) {

switch (tag) {

case boolTag:

case dateTag:

return +object === +other;

case errorTag:

return object.name === other.name && object.message === other.message;

case numberTag:

return (object !== +object) ?

other !== +other :

object === +other;

case regexpTag:

case stringTag:

return object === (other + '');

}

return false;

}

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

var type = typeof value;

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

};

function isObjectLike(value) {

return !!value && typeof value === 'object';

}

function isLength(value) {

return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;

}

var isHostObject = (function() {

try {

Object({ 'toString': 0 } + '');

} catch(e) {

return function() { return false; };

}

return function(value) {

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

};

}());

function isTypedArray(value) {

return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];

}

var isArray = Array.isArray || function(value) {

return isObjectLike(value) && isLength(value.length) && objToString.call(value) === arrayTag;

};

function arraySome (array, predicate) {

var index = -1,

length = array.length;

while (++index < length) {

if (predicate(array[index], index, array)) {

return true;

}

}

return false;

}

function equalArrays(array, other, equalFunc, isLoose, stackA, stackB) {

var index = -1,

arrLength = array.length,

othLength = other.length;

if (arrLength !== othLength && !(isLoose && othLength > arrLength)) {

return false;

}

// Ignore non-index properties.

while (++index < arrLength) {

var arrValue = array[index],

othValue = other[index],

result;

if (result !== undefined) {

if (result) {

continue;

}

return false;

}

// Recursively compare arrays (susceptible to call stack limits).

if (isLoose) {

if (!arraySome(other, function(othValue) {

return arrValue === othValue || equalFunc(arrValue, othValue, isLoose, stackA, stackB);

})) {

return false;

}

} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, isLoose, stackA, stackB))) {

return false;

}

}

return true;

}

function baseIsEqualDeep(object, other, equalFunc, isLoose, stackA, stackB) {

var objIsArr = isArray(object),

othIsArr = isArray(other),

objTag = arrayTag,

othTag = arrayTag;

if (!objIsArr) {

objTag = objToString.call(object);

if (objTag === argsTag) {

objTag = objectTag;

} else if (objTag !== objectTag) {

objIsArr = isTypedArray(object);

}

}

if (!othIsArr) {

othTag = objToString.call(other);

if (othTag === argsTag) {

othTag = objectTag;

}

}

var objIsObj = objTag === objectTag && !isHostObject(object),

othIsObj = othTag === objectTag && !isHostObject(other),

isSameTag = objTag === othTag;

if (isSameTag && !(objIsArr || objIsObj)) {

return equalByTag(object, other, objTag);

}

if (!isLoose) {

var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),

othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

if (objIsWrapped || othIsWrapped) {

return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, isLoose, stackA, stackB);

}

}

if (!isSameTag) {

return false;

}

// Assume cyclic values are equal.

// For more information on detecting circular references see https://es5.github.io/#JO.

stackA || (stackA = []);

stackB || (stackB = []);

var length = stackA.length;

while (length--) {

if (stackA[length] === object) {

return stackB[length] === other;

}

}

// Add `object` and `other` to the stack of traversed objects.

stackA.push(object);

stackB.push(other);

var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, isLoose, stackA, stackB);

stackA.pop();

stackB.pop();

return result;

}

function baseIsEqual(value, other, isLoose, stackA, stackB) {

if (value === other) {

return true;

}

if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {

return value !== value && other !== other;

}

return baseIsEqualDeep(value, other, baseIsEqual, isLoose, stackA, stackB);

}

var isEqual = Rx.internals.isEqual = function (value, other) {

return baseIsEqual(value, other);

};

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];

} 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;

})();

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;

}