text:   /** 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 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 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);
      };
  
      /** Gets the current time according to the local machine's system clock. */
      Scheduler.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;
  