docs: function accessFocusSpaceCmd( that, insertAfter ) {
  		return {
  			canUndo: true,
  			modes: { wysiwyg: 1 },
  			exec: ( function() {
  
  				// Inserts line (accessNode) at the position by taking target node as a reference.
  				function doAccess( target ) {
  					// Remove old hotNode under certain circumstances.
  					var hotNodeChar = ( env.ie && env.version < 9 ? ' ' : WHITE_SPACE ),
  						removeOld = that.hotNode &&							// Old hotNode must exist.
  							that.hotNode.getText() == hotNodeChar &&		// Old hotNode hasn't been changed.
  							that.element.equals( that.hotNode ) &&			// Caret is inside old hotNode.
  							that.lastCmdDirection === !!insertAfter;		// Command is executed in the same direction.
  
  					accessFocusSpace( that, function( accessNode ) {
  						if ( removeOld && that.hotNode )
  							that.hotNode.remove();
  
  						accessNode[ insertAfter ? 'insertAfter' : 'insertBefore' ]( target );
  
  						// Make this element distinguishable. Also remember the direction
  						// it's been inserted into document.
  						accessNode.setAttributes( {
  							'data-cke-magicline-hot': 1,
  							'data-cke-magicline-dir': !!insertAfter
  						} );
  
  						// Save last direction of the command (is insertAfter?).
  						that.lastCmdDirection = !!insertAfter;
  					} );
  
  					if ( !env.ie && that.enterMode != CKEDITOR.ENTER_BR )
  						that.hotNode.scrollIntoView();
  
  					// Detach the line if was visible (previously triggered by mouse).
  					that.line.detach();
  				}
  
  				return function( editor ) {
  					var selected = editor.getSelection().getStartElement(),
  						limit;
  
  					// (#9833) Go down to the closest non-inline element in DOM structure
  					// since inline elements don't participate in in magicline.
  					selected = selected.getAscendant( DTD_BLOCK, 1 );
  
  					// Stop if selected is a child of a tabu-list element.
  					if ( isInTabu( that, selected ) )
  						return;
  
  					// Sometimes it may happen that there's no parent block below selected element
  					// or, for example, getAscendant reaches editable or editable parent.
  					// We must avoid such pathological cases.
  					if ( !selected || selected.equals( that.editable ) || selected.contains( that.editable ) )
  						return;
  
  					// Executing the command directly in nested editable should
  					// access space before/after it.
  					if ( ( limit = getClosestEditableLimit( selected ) ) && limit.getAttribute( 'contenteditable' ) == 'false' )
  						selected = limit;
  
  					// That holds element from mouse. Replace it with the
  					// element under the caret.
  					that.element = selected;
  
  					// (3.) Handle the following cases where selected neighbour
  					// is a trigger inaccessible for the caret AND:
  					//	- Is first/last-child
  					//	OR
  					//	- Has a sibling, which is also a trigger.
  					var neighbor = getNonEmptyNeighbour( that, selected, !insertAfter ),
  						neighborSibling;
  
  					// Check for a neighbour that belongs to triggers.
  					// Consider only non-accessible elements (they cannot have any children)
  					// since they cannot be given a caret inside, to run the command
  					// the regular way (1. & 2.).
  					if ( isHtml( neighbor ) && neighbor.is( that.triggers ) && neighbor.is( DTD_NONACCESSIBLE ) &&
  							(
  									// Check whether neighbor is first/last-child.
  									!getNonEmptyNeighbour( that, neighbor, !insertAfter )
  								||
  									// Check for a sibling of a neighbour that also is a trigger.
  									(
  										( neighborSibling = getNonEmptyNeighbour( that, neighbor, !insertAfter ) ) &&
  										isHtml( neighborSibling ) &&
  										neighborSibling.is( that.triggers )
  									)
  							)
  						) {
  						doAccess( neighbor );
  						return;
  					}
  
  					// Look for possible target element DOWN "selected" DOM branch (towards editable)
  					// that belong to that.triggers
  					var target = getAscendantTrigger( that, selected );
  
  					// No HTML target -> no access.
  					if ( !isHtml( target ) )
  						return;
  
  					// (1.) Target is first/last child -> access.
  					if ( !getNonEmptyNeighbour( that, target, !insertAfter ) ) {
  						doAccess( target );
  						return;
  					}
  
  					var sibling = getNonEmptyNeighbour( that, target, !insertAfter );
  
  					// (2.) Target has a sibling that belongs to that.triggers -> access.
  					if ( sibling && isHtml( sibling ) && sibling.is( that.triggers ) ) {
  						doAccess( target );
  						return;
  					}
  				};
  			} )()
  		};
  	}