text:   (function (schedulerProto) {
  
      function invokeRecImmediate(scheduler, pair) {
        var state = pair[0], action = pair[1], group = new CompositeDisposable();
  
        function recursiveAction(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[0], action = pair[1], group = new CompositeDisposable();
        function recursiveAction(state1) {
          action(state1, function (state2, dueTime1) {
            var isAdded = false, isDone = false,
            d = scheduler[method](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 scheduleInnerRecursive(action, self) {
        action(function(dt) { self(action, dt); });
      }
  
      /**
       * 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, scheduleInnerRecursive);
      };
  
      /**
       * 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([state, action], invokeRecImmediate);
      };
  
      /**
       * 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, scheduleInnerRecursive);
      };
  
      /**
       * 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([state, 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) {
        return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, scheduleInnerRecursive);
      };
  
      /**
       * Schedules an action to be executed recursively at a specified absolute 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 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.scheduleRecursiveWithAbsoluteAndState = function (state, dueTime, action) {
        return this._scheduleAbsolute([state, action], dueTime, function (s, p) {
          return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
        });
      };
    }(Scheduler.prototype));
  