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

;(function (undefined) {

var objectTypes = {

'boolean': false,

'function': true,

'object': true,

'number': false,

'string': false,

'undefined': false

};

var root = (objectTypes[typeof window] && window) || this,

freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports,

freeModule = objectTypes[typeof module] && module && !module.nodeType && module,

moduleExports = freeModule && freeModule.exports === freeExports && freeExports,

freeGlobal = objectTypes[typeof global] && global;

if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {

root = freeGlobal;

}

var Rx = { Internals: {} };

// Defaults

function noop() { }

function identity(x) { return x; }

var defaultNow = (function () { return !!Date.now ? Date.now : function () { return +new Date; }; }());

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

}

}

/** `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) == stringClass ?

this.split("") :

object,

length = self.length >>> 0,

thisp = arguments[1];

if ({}.toString.call(fun) != funcClass) {

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) == stringClass ?

this.split("") :

object,

length = self.length >>> 0,

result = Array(length),

thisp = arguments[1];

if ({}.toString.call(fun) != funcClass) {

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) == arrayClass;

};

}

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 = Rx.Internals.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.

* @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 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.

*/

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.

* @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

* @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. */

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

var BooleanDisposable = (function () {

function BooleanDisposable (isSingle) {

this.isSingle = isSingle;

this.isDisposed = false;

this.current = null;

}

var booleanDisposablePrototype = BooleanDisposable.prototype;

/**

* Gets the underlying disposable.

* @return The underlying disposable.

*/

booleanDisposablePrototype.getDisposable = function () {

return this.current;

};

/**

* Sets the underlying disposable.

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

*/

booleanDisposablePrototype.setDisposable = function (value) {

if (this.current && this.isSingle) {

throw new Error('Disposable has already been assigned');

}

var shouldDispose = this.isDisposed, old;

if (!shouldDispose) {

old = this.current;

this.current = value;

}

if (old) {

old.dispose();

}

if (shouldDispose && value) {

value.dispose();

}

};

/**

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

*/

booleanDisposablePrototype.dispose = function () {

var old;

if (!this.isDisposed) {

this.isDisposed = true;

old = this.current;

this.current = null;

}

if (old) {

old.dispose();

}

};

return BooleanDisposable;

}());

/**

* 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.

*/

var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = (function (super_) {

inherits(SingleAssignmentDisposable, super_);

function SingleAssignmentDisposable() {

super_.call(this, true);

}

return SingleAssignmentDisposable;

}(BooleanDisposable));

/**

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

*/

var SerialDisposable = Rx.SerialDisposable = (function (super_) {

inherits(SerialDisposable, super_);

function SerialDisposable() {

super_.call(this, false);

}

return SerialDisposable;

}(BooleanDisposable));

/**

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

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

*/

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.

* @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 this.action(this.scheduler, this.state);

};

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

var Scheduler = Rx.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;

/**

* 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.

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

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

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

*/

schedulerProto.schedulePeriodic = function (period, action) {

return this.schedulePeriodicWithState(null, period, function () {

action();

});

};

/**

* 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.

* @param {Mixed} state Initial state passed to the action upon the first iteration.

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

* @param {Function} action Action to be executed, potentially updating the state.

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

*/

schedulerProto.schedulePeriodicWithState = function (state, period, action) {

var s = state, id = setInterval(function () {

s = action(s);

}, period);

return disposableCreate(function () {

clearInterval(id);

});

};

/**

* Schedules an action to be executed.

* @param {Function} action Action to execute.

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

*/

schedulerProto.schedule = function (action) {

return this._schedule(action, invokeAction);

};

/**

* 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.scheduleWithState = function (state, action) {

return this._schedule(state, action);

};

/**

* Schedules an action to be executed after the specified relative due time.

* @param {Function} action Action to execute.

* @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.scheduleWithRelative = function (dueTime, action) {

return this._scheduleRelative(action, dueTime, invokeAction);

};

/**

* Schedules an action to be executed after dueTime.

* @param {Mixed} 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.scheduleWithRelativeAndState = function (state, dueTime, action) {

return this._scheduleRelative(state, dueTime, action);

};

/**

* Schedules an action to be executed at the specified absolute due time.

* @param {Function} action Action to execute.

* @param {Number} dueTime Absolute time at which to execute the action.

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

*/

schedulerProto.scheduleWithAbsolute = function (dueTime, action) {

return this._scheduleAbsolute(action, dueTime, invokeAction);

};

/**

* Schedules an action to be executed at dueTime.

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

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

* @param {Number}dueTime Absolute time at which to execute the action.

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

*/

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

return this._scheduleAbsolute(state, dueTime, action);

};

/**

* Schedules an action to be executed recursively.

* @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action.

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

*/

schedulerProto.scheduleRecursive = function (action) {

return this.scheduleRecursiveWithState(action, function (_action, self) {

_action(function () {

self(_action);

});

});

};

/**

* 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).

*/

schedulerProto.scheduleRecursiveWithState = function (state, action) {

return this.scheduleWithState({ first: state, second: action }, function (s, p) {

return invokeRecImmediate(s, p);

});

};

/**

* Schedules an action to be executed recursively after a specified relative due time.

* @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time.

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

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

*/

schedulerProto.scheduleRecursiveWithRelative = function (dueTime, action) {

return this.scheduleRecursiveWithRelativeAndState(action, dueTime, function (_action, self) {

_action(function (dt) {

self(_action, dt);

});

});

};

/**

* Schedules an action to be executed recursively after a specified relative due time.

* @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 the recursive due time and invocation state.

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

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

*/

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

return this._scheduleRelative({ first: state, second: action }, dueTime, function (s, p) {

return invokeRecDate(s, p, 'scheduleWithRelativeAndState');

});

};

/**

* Schedules an action to be executed recursively at a specified absolute due time.

* @param {Function} action Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time.

* @param {Number}dueTime Absolute time at which to execute the action for the first time.

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

*/

schedulerProto.scheduleRecursiveWithAbsolute = function (dueTime, action) {