docs: function iterate( rtl, breakOnFalse ) {
  		var range = this.range;
  
  		// Return null if we have reached the end.
  		if ( this._.end )
  			return null;
  
  		// This is the first call. Initialize it.
  		if ( !this._.start ) {
  			this._.start = 1;
  
  			// A collapsed range must return null at first call.
  			if ( range.collapsed ) {
  				this.end();
  				return null;
  			}
  
  			// Move outside of text node edges.
  			range.optimize();
  		}
  
  		var node,
  			startCt = range.startContainer,
  			endCt = range.endContainer,
  			startOffset = range.startOffset,
  			endOffset = range.endOffset,
  			guard,
  			userGuard = this.guard,
  			type = this.type,
  			getSourceNodeFn = ( rtl ? 'getPreviousSourceNode' : 'getNextSourceNode' );
  
  		// Create the LTR guard function, if necessary.
  		if ( !rtl && !this._.guardLTR ) {
  			// The node that stops walker from moving up.
  			var limitLTR = endCt.type == CKEDITOR.NODE_ELEMENT ? endCt : endCt.getParent();
  
  			// The node that stops the walker from going to next.
  			var blockerLTR = endCt.type == CKEDITOR.NODE_ELEMENT ? endCt.getChild( endOffset ) : endCt.getNext();
  
  			this._.guardLTR = function( node, movingOut ) {
  				return ( ( !movingOut || !limitLTR.equals( node ) ) && ( !blockerLTR || !node.equals( blockerLTR ) ) && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || !node.equals( range.root ) ) );
  			};
  		}
  
  		// Create the RTL guard function, if necessary.
  		if ( rtl && !this._.guardRTL ) {
  			// The node that stops walker from moving up.
  			var limitRTL = startCt.type == CKEDITOR.NODE_ELEMENT ? startCt : startCt.getParent();
  
  			// The node that stops the walker from going to next.
  			var blockerRTL = startCt.type == CKEDITOR.NODE_ELEMENT ? startOffset ? startCt.getChild( startOffset - 1 ) : null : startCt.getPrevious();
  
  			this._.guardRTL = function( node, movingOut ) {
  				return ( ( !movingOut || !limitRTL.equals( node ) ) && ( !blockerRTL || !node.equals( blockerRTL ) ) && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || !node.equals( range.root ) ) );
  			};
  		}
  
  		// Define which guard function to use.
  		var stopGuard = rtl ? this._.guardRTL : this._.guardLTR;
  
  		// Make the user defined guard function participate in the process,
  		// otherwise simply use the boundary guard.
  		if ( userGuard ) {
  			guard = function( node, movingOut ) {
  				if ( stopGuard( node, movingOut ) === false )
  					return false;
  
  				return userGuard( node, movingOut );
  			};
  		} else {
  			guard = stopGuard;
  		}
  
  		if ( this.current )
  			node = this.current[ getSourceNodeFn ]( false, type, guard );
  		else {
  			// Get the first node to be returned.
  			if ( rtl ) {
  				node = endCt;
  
  				if ( node.type == CKEDITOR.NODE_ELEMENT ) {
  					if ( endOffset > 0 )
  						node = node.getChild( endOffset - 1 );
  					else
  						node = ( guard( node, true ) === false ) ? null : node.getPreviousSourceNode( true, type, guard );
  				}
  			} else {
  				node = startCt;
  
  				if ( node.type == CKEDITOR.NODE_ELEMENT ) {
  					if ( !( node = node.getChild( startOffset ) ) )
  						node = ( guard( startCt, true ) === false ) ? null : startCt.getNextSourceNode( true, type, guard );
  				}
  			}
  
  			if ( node && guard( node ) === false )
  				node = null;
  		}
  
  		while ( node && !this._.end ) {
  			this.current = node;
  
  			if ( !this.evaluator || this.evaluator( node ) !== false ) {
  				if ( !breakOnFalse )
  					return node;
  			} else if ( breakOnFalse && this.evaluator ) {
  				return false;
  			}
  
  			node = node[ getSourceNodeFn ]( false, type, guard );
  		}
  
  		this.end();
  		return this.current = null;
  	}