Validation initiale

[perso/Immae/Projets/packagist/ludivine-ckeditor-component.git] / sources / core / dom / range.js

/**
 * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
 * For licensing, see LICENSE.md or http://ckeditor.com/license
 */

/**
 * Represents a delimited piece of content in a DOM Document.
 * It is contiguous in the sense that it can be characterized as selecting all
 * of the content between a pair of boundary-points.
 *
 * This class shares much of the W3C
 * [Document Object Model Range](http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html)
 * ideas and features, adding several range manipulation tools to it, but it's
 * not intended to be compatible with it.
 *
 *              // Create a range for the entire contents of the editor document body.
 *              var range = new CKEDITOR.dom.range( editor.document );
 *              range.selectNodeContents( editor.document.getBody() );
 *              // Delete the contents.
 *              range.deleteContents();
 *
 * Usually you will want to work on a ranges rooted in the editor's {@link CKEDITOR.editable editable}
 * element. Such ranges can be created with a shorthand method – {@link CKEDITOR.editor#createRange editor.createRange}.
 *
 *              var range = editor.createRange();
 *              range.root.equals( editor.editable() ); // -> true
 *
 * Note that the {@link #root} of a range is an important property, which limits many
 * algorithms implemented in range's methods. Therefore it is crucial, especially
 * when using ranges inside inline editors, to specify correct root, so using
 * the {@link CKEDITOR.editor#createRange} method is highly recommended.
 *
 * ### Selection
 *
 * Range is only a logical representation of a piece of content in a DOM. It should not
 * be confused with a {@link CKEDITOR.dom.selection selection} which represents "physically
 * marked" content. It is possible to create unlimited number of various ranges, when
 * only one real selection may exist at a time in a document. Ranges are used to read position
 * of selection in the DOM and to move selection to new positions.
 *
 * The editor selection may be retrieved using the {@link CKEDITOR.editor#getSelection} method:
 *
 *              var sel = editor.getSelection(),
 *                      ranges = sel.getRanges(); // CKEDITOR.dom.rangeList instance.
 *
 *              var range = ranges[ 0 ];
 *              range.root; // -> editor's editable element.
 *
 * A range can also be selected:
 *
 *              var range = editor.createRange();
 *              range.selectNodeContents( editor.editable() );
 *              sel.selectRanges( [ range ] );
 *
 * @class
 * @constructor Creates a {@link CKEDITOR.dom.range} instance that can be used inside a specific DOM Document.
 * @param {CKEDITOR.dom.document/CKEDITOR.dom.element} root The document or element
 * within which the range will be scoped.
 * @todo global "TODO" - precise algorithms descriptions needed for the most complex methods like #enlarge.
 */
CKEDITOR.dom.range = function( root ) {
        /**
         * Node within which the range begins.
         *
         *              var range = new CKEDITOR.dom.range( editor.document );
         *              range.selectNodeContents( editor.document.getBody() );
         *              alert( range.startContainer.getName() ); // 'body'
         *
         * @readonly
         * @property {CKEDITOR.dom.element/CKEDITOR.dom.text}
         */
        this.startContainer = null;

        /**
         * Offset within the starting node of the range.
         *
         *              var range = new CKEDITOR.dom.range( editor.document );
         *              range.selectNodeContents( editor.document.getBody() );
         *              alert( range.startOffset ); // 0
         *
         * @readonly
         * @property {Number}
         */
        this.startOffset = null;

        /**
         * Node within which the range ends.
         *
         *              var range = new CKEDITOR.dom.range( editor.document );
         *              range.selectNodeContents( editor.document.getBody() );
         *              alert( range.endContainer.getName() ); // 'body'
         *
         * @readonly
         * @property {CKEDITOR.dom.element/CKEDITOR.dom.text}
         */
        this.endContainer = null;

        /**
         * Offset within the ending node of the range.
         *
         *              var range = new CKEDITOR.dom.range( editor.document );
         *              range.selectNodeContents( editor.document.getBody() );
         *              alert( range.endOffset ); // == editor.document.getBody().getChildCount()
         *
         * @readonly
         * @property {Number}
         */
        this.endOffset = null;

        /**
         * Indicates that this is a collapsed range. A collapsed range has its
         * start and end boundaries at the very same point so nothing is contained
         * in it.
         *
         *              var range = new CKEDITOR.dom.range( editor.document );
         *              range.selectNodeContents( editor.document.getBody() );
         *              alert( range.collapsed ); // false
         *              range.collapse();
         *              alert( range.collapsed ); // true
         *
         * @readonly
         */
        this.collapsed = true;

        var isDocRoot = root instanceof CKEDITOR.dom.document;
        /**
         * The document within which the range can be used.
         *
         *              // Selects the body contents of the range document.
         *              range.selectNodeContents( range.document.getBody() );
         *
         * @readonly
         * @property {CKEDITOR.dom.document}
         */
        this.document = isDocRoot ? root : root.getDocument();

        /**
         * The ancestor DOM element within which the range manipulation are limited.
         *
         * @readonly
         * @property {CKEDITOR.dom.element}
         */
        this.root = isDocRoot ? root.getBody() : root;
};

( function() {
        // Updates the "collapsed" property for the given range object.
        function updateCollapsed( range ) {
                range.collapsed = ( range.startContainer && range.endContainer && range.startContainer.equals( range.endContainer ) && range.startOffset == range.endOffset );
        }

        // This is a shared function used to delete, extract and clone the range content.
        //
        // The outline of the algorithm:
        //
        // 1. Normalization. We handle special cases, split text nodes if we can, find boundary nodes (startNode and endNode).
        // 2. Gathering data.
        //   * We start by creating two arrays of boundary nodes parents. You can imagine these arrays as lines limiting
        //   the tree from the left and right and thus marking the part which is selected by the range. The both lines
        //   start in the same node which is the range.root and end in startNode and endNode.
        //   * Then we find min level and max levels. Level represents all nodes which are equally far from the range.root.
        //   Min level is the level at which the left and right boundaries diverged (the first diverged level). And max levels
        //   are how deep the start and end nodes are nested.
        // 3. Cloning/extraction.
        //   * We start iterating over start node parents (left branch) from min level and clone the parent (usually shallow clone,
        //   because we know that it's not fully selected) and its right siblings (deep clone, because they are fully selected).
        //   We iterate over siblings up to meeting end node parent or end of the siblings chain.
        //   * We clone level after level down to the startNode.
        //   * Then we do the same with end node parents (right branch), because it may contains notes we omit during the previous
        //   step, for example if the right branch is deeper then left branch. Things are more complicated here because we have to
        //   watch out for nodes that were already cloned.
        //   * ***Note:** Setting `cloneId` option to `false` for **extraction** works for partially selected elements only.
        //   See range.extractContents to know more.
        // 4. Clean up.
        //   * There are two things we need to do - updating the range position and perform the action of the "mergeThen"
        //   param (see range.deleteContents or range.extractContents).
        //   See comments in mergeAndUpdate because this is lots of fun too.
        function execContentsAction( range, action, docFrag, mergeThen, cloneId ) {
                'use strict';

                range.optimizeBookmark();

                var isDelete = action === 0;
                var isExtract = action == 1;
                var isClone = action == 2;
                var doClone = isClone || isExtract;

                var startNode = range.startContainer;
                var endNode = range.endContainer;

                var startOffset = range.startOffset;
                var endOffset = range.endOffset;

                var cloneStartNode;
                var cloneEndNode;

                var doNotRemoveStartNode;
                var doNotRemoveEndNode;

                var cloneStartText;
                var cloneEndText;

                // Handle here an edge case where we clone a range which is located in one text node.
                // This allows us to not think about startNode == endNode case later on.
                // We do that only when cloning, because in other cases we can safely split this text node
                // and hence we can easily handle this case as many others.
                if ( isClone && endNode.type == CKEDITOR.NODE_TEXT && startNode.equals( endNode ) ) {
                        startNode = range.document.createText( startNode.substring( startOffset, endOffset ) );
                        docFrag.append( startNode );
                        return;
                }

                // For text containers, we must simply split the node and point to the
                // second part. The removal will be handled by the rest of the code.
                if ( endNode.type == CKEDITOR.NODE_TEXT ) {
                        // If Extract or Delete we can split the text node,
                        // but if Clone (2), then we cannot modify the DOM (#11586) so we mark the text node for cloning.
                        if ( !isClone ) {
                                endNode = endNode.split( endOffset );
                        } else {
                                cloneEndText = true;
                        }
                } else {
                        // If there's no node after the range boundary we set endNode to the previous node
                        // and mark it to be cloned.
                        if ( endNode.getChildCount() > 0 ) {
                                // If the offset points after the last node.
                                if ( endOffset >= endNode.getChildCount() ) {
                                        endNode = endNode.getChild( endOffset - 1 );
                                        cloneEndNode = true;
                                } else {
                                        endNode = endNode.getChild( endOffset );
                                }
                        }
                        // The end container is empty (<h1>]</h1>), but we want to clone it, although not remove.
                        else {
                                cloneEndNode = true;
                                doNotRemoveEndNode = true;
                        }
                }

                // For text containers, we must simply split the node. The removal will
                // be handled by the rest of the code .
                if ( startNode.type == CKEDITOR.NODE_TEXT ) {
                        // If Extract or Delete we can split the text node,
                        // but if Clone (2), then we cannot modify the DOM (#11586) so we mark
                        // the text node for cloning.
                        if ( !isClone ) {
                                startNode.split( startOffset );
                        } else {
                                cloneStartText = true;
                        }
                } else {
                        // If there's no node before the range boundary we set startNode to the next node
                        // and mark it to be cloned.
                        if ( startNode.getChildCount() > 0 ) {
                                if ( startOffset === 0 ) {
                                        startNode = startNode.getChild( startOffset );
                                        cloneStartNode = true;
                                } else {
                                        startNode = startNode.getChild( startOffset - 1 );
                                }
                        }
                        // The start container is empty (<h1>[</h1>), but we want to clone it, although not remove.
                        else {
                                cloneStartNode = true;
                                doNotRemoveStartNode = true;
                        }
                }

                        // Get the parent nodes tree for the start and end boundaries.
                var startParents = startNode.getParents(),
                        endParents = endNode.getParents(),
                        // Level at which start and end boundaries diverged.
                        minLevel = findMinLevel(),
                        maxLevelLeft = startParents.length - 1,
                        maxLevelRight = endParents.length - 1,
                        // Keeps the frag/element which is parent of the level that we are currently cloning.
                        levelParent = docFrag,
                        nextLevelParent,
                        leftNode,
                        rightNode,
                        nextSibling,
                        // Keeps track of the last connected level (on which left and right branches are connected)
                        // Usually this is minLevel, but not always.
                        lastConnectedLevel = -1;

                // THE LEFT BRANCH.
                for ( var level = minLevel; level <= maxLevelLeft; level++ ) {
                        leftNode = startParents[ level ];
                        nextSibling = leftNode.getNext();

                        // 1.
                        // The first step is to handle partial selection of the left branch.

                        // Max depth of the left branch. It means that ( leftSibling == endNode ).
                        // We also check if the leftNode isn't only partially selected, because in this case
                        // we want to make a shallow clone of it (the else part).
                        if ( level == maxLevelLeft && !( leftNode.equals( endParents[ level ] ) && maxLevelLeft < maxLevelRight ) ) {
                                if ( cloneStartNode ) {
                                        consume( leftNode, levelParent, false, doNotRemoveStartNode );
                                } else if ( cloneStartText ) {
                                        levelParent.append( range.document.createText( leftNode.substring( startOffset ) ) );
                                }
                        } else if ( doClone ) {
                                nextLevelParent = levelParent.append( leftNode.clone( 0, cloneId ) );
                        }

                        // 2.
                        // The second step is to handle full selection of the content between the left branch and the right branch.

                        while ( nextSibling ) {
                                // We can't clone entire endParent just like we can't clone entire startParent -
                                // - they are not fully selected with the range. Partial endParent selection
                                // will be cloned in the next loop.
                                if ( nextSibling.equals( endParents[ level ] ) ) {
                                        lastConnectedLevel = level;
                                        break;
                                }

                                nextSibling = consume( nextSibling, levelParent );
                        }

                        levelParent = nextLevelParent;
                }

                // Reset levelParent, because we reset the level.
                levelParent = docFrag;

                // THE RIGHT BRANCH.
                for ( level = minLevel; level <= maxLevelRight; level++ ) {
                        rightNode = endParents[ level ];
                        nextSibling = rightNode.getPrevious();

                        // Do not process this node if it is shared with the left branch
                        // because it was already processed.
                        //
                        // Note: Don't worry about text nodes selection - if the entire range was placed in a single text node
                        // it was handled as a special case at the beginning. In other cases when startNode == endNode
                        // or when on this level leftNode == rightNode (so rightNode.equals( startParents[ level ] ))
                        // this node was handled by the previous loop.
                        if ( !rightNode.equals( startParents[ level ] ) ) {
                                // 1.
                                // The first step is to handle partial selection of the right branch.

                                // Max depth of the right branch. It means that ( rightNode == endNode ).
                                // We also check if the rightNode isn't only partially selected, because in this case
                                // we want to make a shallow clone of it (the else part).
                                if ( level == maxLevelRight && !( rightNode.equals( startParents[ level ] ) && maxLevelRight < maxLevelLeft ) ) {
                                        if ( cloneEndNode ) {
                                                consume( rightNode, levelParent, false, doNotRemoveEndNode );
                                        } else if ( cloneEndText ) {
                                                levelParent.append( range.document.createText( rightNode.substring( 0, endOffset ) ) );
                                        }
                                } else if ( doClone ) {
                                        nextLevelParent = levelParent.append( rightNode.clone( 0, cloneId ) );
                                }

                                // 2.
                                // The second step is to handle all left (selected) siblings of the rightNode which
                                // have not yet been handled. If the level branches were connected, the previous loop
                                // already copied all siblings (except the current rightNode).
                                if ( level > lastConnectedLevel ) {
                                        while ( nextSibling ) {
                                                nextSibling = consume( nextSibling, levelParent, true );
                                        }
                                }

                                levelParent = nextLevelParent;
                        } else if ( doClone ) {
                                // If this is "shared" node and we are in cloning mode we have to update levelParent to
                                // reflect that we visited the node (even though we didn't process it).
                                // If we don't do that, in next iterations nodes will be appended to wrong parent.
                                //
                                // We can just take first child because the algorithm guarantees
                                // that this will be the only child on this level. (#13568)
                                levelParent = levelParent.getChild( 0 );
                        }
                }

                // Delete or Extract.
                // We need to update the range and if mergeThen was passed do it.
                if ( !isClone ) {
                        mergeAndUpdate();
                }

                // Depending on an action:
                // * clones node and adds to new parent,
                // * removes node,
                // * moves node to the new parent.
                function consume( node, newParent, toStart, forceClone ) {
                        var nextSibling = toStart ? node.getPrevious() : node.getNext();

                        // We do not clone if we are only deleting, so do nothing.
                        if ( forceClone && isDelete ) {
                                return nextSibling;
                        }

                        // If cloning, just clone it.
                        if ( isClone || forceClone ) {
                                newParent.append( node.clone( true, cloneId ), toStart );
                        } else {
                                // Both Delete and Extract will remove the node.
                                node.remove();

                                // When Extracting, move the removed node to the docFrag.
                                if ( isExtract ) {
                                        newParent.append( node );
                                }
                        }

                        return nextSibling;
                }

                // Finds a level number on which both branches starts diverging.
                // If such level does not exist, return the last on which both branches have nodes.
                function findMinLevel() {
                        // Compare them, to find the top most siblings.
                        var i, topStart, topEnd,
                                maxLevel = Math.min( startParents.length, endParents.length );

                        for ( i = 0; i < maxLevel; i++ ) {
                                topStart = startParents[ i ];
                                topEnd = endParents[ i ];

                                // The compared nodes will match until we find the top most siblings (different nodes that have the same parent).
                                // "i" will hold the index in the parents array for the top most element.
                                if ( !topStart.equals( topEnd ) ) {
                                        return i;
                                }
                        }

                        // When startNode == endNode.
                        return i - 1;
                }

                // Executed only when deleting or extracting to update range position
                // and perform the merge operation.
                function mergeAndUpdate() {
                        var commonLevel = minLevel - 1,
                                boundariesInEmptyNode = doNotRemoveStartNode && doNotRemoveEndNode && !startNode.equals( endNode );

                        // If a node has been partially selected, collapse the range between
                        // startParents[ minLevel + 1 ] and endParents[ minLevel + 1 ] (the first diverged elements).
                        // Otherwise, simply collapse it to the start. (W3C specs).
                        //
                        // All clear, right?
                        //
                        // It took me few hours to truly understand a previous version of this condition.
                        // Mine seems to be more straightforward (even if it doesn't look so) and I could leave you here
                        // without additional comments, but I'm not that mean so here goes the explanation.
                        //
                        // We want to know if both ends of the range are anchored in the same element. Really. It's this simple.
                        // But why? Because we need to differentiate situations like:
                        //
                        // <p>foo[<b>x</b>bar]y</p>             (commonLevel = p, maxLL = "foo", maxLR = "y")
                        // from:
                        // <p>foo<b>x[</b>bar]y</p>             (commonLevel = p, maxLL = "x", maxLR = "y")
                        //
                        // In the first case we can collapse the range to the left, because simply everything between range's
                        // boundaries was removed.
                        // In the second case we must place the range after </b>, because <b> was only **partially selected**.
                        //
                        // * <b> is our startParents[ commonLevel + 1 ]
                        // * "y" is our endParents[ commonLevel + 1 ].
                        //
                        // By now "bar" is removed from the DOM so <b> is a direct sibling of "y":
                        // <p>foo<b>x</b>y</p>
                        //
                        // Therefore it's enough to place the range between <b> and "y".
                        //
                        // Now, what does the comparison mean? Why not just taking startNode and endNode and checking
                        // their parents? Because the tree is already changed and they may be gone. Plus, thanks to
                        // cloneStartNode and cloneEndNode, that would be reaaaaly tricky.
                        //
                        // So we play with levels which can give us the same information:
                        // * commonLevel - the level of common ancestor,
                        // * maxLevel - 1 - the level of range boundary parent (range boundary is here like a bookmark span).
                        // * commonLevel < maxLevel - 1 - whether the range boundary is not a child of common ancestor.
                        //
                        // There's also an edge case in which both range boundaries were placed in empty nodes like:
                        // <p>[</p><p>]</p>
                        // Those boundaries were not removed, but in this case start and end nodes are child of the common ancestor.
                        // We handle this edge case separately.
                        if ( commonLevel < ( maxLevelLeft - 1 ) || commonLevel < ( maxLevelRight - 1 ) || boundariesInEmptyNode ) {
                                if ( boundariesInEmptyNode ) {
                                        range.moveToPosition( endNode, CKEDITOR.POSITION_BEFORE_START );
                                } else if ( ( maxLevelRight == commonLevel + 1 ) && cloneEndNode ) {
                                        // The maxLevelRight + 1 element could be already removed so we use the fact that
                                        // we know that it was the last element in its parent.
                                        range.moveToPosition( endParents[ commonLevel ], CKEDITOR.POSITION_BEFORE_END );
                                } else {
                                        range.moveToPosition( endParents[ commonLevel + 1 ], CKEDITOR.POSITION_BEFORE_START );
                                }

                                // Merge split parents.
                                if ( mergeThen ) {
                                        // Find the first diverged node in the left branch.
                                        var topLeft = startParents[ commonLevel + 1 ];

                                        // TopLeft may simply not exist if commonLevel == maxLevel or may be a text node.
                                        if ( topLeft && topLeft.type == CKEDITOR.NODE_ELEMENT ) {
                                                var span = CKEDITOR.dom.element.createFromHtml( '<span ' +
                                                        'data-cke-bookmark="1" style="display:none">&nbsp;</span>', range.document );
                                                span.insertAfter( topLeft );
                                                topLeft.mergeSiblings( false );
                                                range.moveToBookmark( { startNode: span } );
                                        }
                                }
                        } else {
                                // Collapse it to the start.
                                range.collapse( true );
                        }
                }
        }

        var inlineChildReqElements = {
                abbr: 1, acronym: 1, b: 1, bdo: 1, big: 1, cite: 1, code: 1, del: 1,
                dfn: 1, em: 1, font: 1, i: 1, ins: 1, label: 1, kbd: 1, q: 1, samp: 1, small: 1, span: 1, strike: 1,
                strong: 1, sub: 1, sup: 1, tt: 1, u: 1, 'var': 1
        };

        // Creates the appropriate node evaluator for the dom walker used inside
        // check(Start|End)OfBlock.
        function getCheckStartEndBlockEvalFunction() {
                var skipBogus = false,
                        whitespaces = CKEDITOR.dom.walker.whitespaces(),
                        bookmarkEvaluator = CKEDITOR.dom.walker.bookmark( true ),
                        isBogus = CKEDITOR.dom.walker.bogus();

                return function( node ) {
                        // First skip empty nodes
                        if ( bookmarkEvaluator( node ) || whitespaces( node ) )
                                return true;

                        // Skip the bogus node at the end of block.
                        if ( isBogus( node ) && !skipBogus ) {
                                skipBogus = true;
                                return true;
                        }

                        // If there's any visible text, then we're not at the start.
                        if ( node.type == CKEDITOR.NODE_TEXT &&
                                ( node.hasAscendant( 'pre' ) ||
                                        CKEDITOR.tools.trim( node.getText() ).length ) ) {
                                return false;
                        }

                        // If there are non-empty inline elements (e.g. <img />), then we're not
                        // at the start.
                        if ( node.type == CKEDITOR.NODE_ELEMENT && !node.is( inlineChildReqElements ) )
                                return false;

                        return true;
                };
        }

        var isBogus = CKEDITOR.dom.walker.bogus(),
                nbspRegExp = /^[\t\r\n ]*(?:&nbsp;|\xa0)$/,
                editableEval = CKEDITOR.dom.walker.editable(),
                notIgnoredEval = CKEDITOR.dom.walker.ignored( true );

        // Evaluator for CKEDITOR.dom.element::checkBoundaryOfElement, reject any
        // text node and non-empty elements unless it's being bookmark text.
        function elementBoundaryEval( checkStart ) {
                var whitespaces = CKEDITOR.dom.walker.whitespaces(),
                        bookmark = CKEDITOR.dom.walker.bookmark( 1 );

                return function( node ) {
                        // First skip empty nodes.
                        if ( bookmark( node ) || whitespaces( node ) )
                                return true;

                        // Tolerant bogus br when checking at the end of block.
                        // Reject any text node unless it's being bookmark
                        // OR it's spaces.
                        // Reject any element unless it's being invisible empty. (#3883)
                        return !checkStart && isBogus( node ) ||
                                node.type == CKEDITOR.NODE_ELEMENT &&
                                node.is( CKEDITOR.dtd.$removeEmpty );
                };
        }

        function getNextEditableNode( isPrevious ) {
                return function() {
                        var first;

                        return this[ isPrevious ? 'getPreviousNode' : 'getNextNode' ]( function( node ) {
                                // Cache first not ignorable node.
                                if ( !first && notIgnoredEval( node ) )
                                        first = node;

                                // Return true if found editable node, but not a bogus next to start of our lookup (first != bogus).
                                return editableEval( node ) && !( isBogus( node ) && node.equals( first ) );
                        } );
                };
        }

        CKEDITOR.dom.range.prototype = {
                /**
                 * Clones this range.
                 *
                 * @returns {CKEDITOR.dom.range}
                 */
                clone: function() {
                        var clone = new CKEDITOR.dom.range( this.root );

                        clone._setStartContainer( this.startContainer );
                        clone.startOffset = this.startOffset;
                        clone._setEndContainer( this.endContainer );
                        clone.endOffset = this.endOffset;
                        clone.collapsed = this.collapsed;

                        return clone;
                },

                /**
                 * Makes the range collapsed by moving its start point (or end point if `toStart==true`)
                 * to the second end.
                 *
                 * @param {Boolean} toStart Collapse range "to start".
                 */
                collapse: function( toStart ) {
                        if ( toStart ) {
                                this._setEndContainer( this.startContainer );
                                this.endOffset = this.startOffset;
                        } else {
                                this._setStartContainer( this.endContainer );
                                this.startOffset = this.endOffset;
                        }

                        this.collapsed = true;
                },

                /**
                 * Clones content nodes of the range and adds them to a document fragment, which is returned.
                 *
                 * @param {Boolean} [cloneId=true] Whether to preserve ID attributes in the clone.
                 * @returns {CKEDITOR.dom.documentFragment} Document fragment containing a clone of range's content.
                 */
                cloneContents: function( cloneId ) {
                        var docFrag = new CKEDITOR.dom.documentFragment( this.document );

                        cloneId = typeof cloneId == 'undefined' ? true : cloneId;

                        if ( !this.collapsed )
                                execContentsAction( this, 2, docFrag, false, cloneId );

                        return docFrag;
                },

                /**
                 * Deletes the content nodes of the range permanently from the DOM tree.
                 *
                 * @param {Boolean} [mergeThen] Merge any split elements result in DOM true due to partial selection.
                 */
                deleteContents: function( mergeThen ) {
                        if ( this.collapsed )
                                return;

                        execContentsAction( this, 0, null, mergeThen );
                },

                /**
                 * The content nodes of the range are cloned and added to a document fragment,
                 * meanwhile they are removed permanently from the DOM tree.
                 *
                 * **Note:** Setting the `cloneId` parameter to `false` works for **partially** selected elements only.
                 * If an element with an ID attribute is **fully enclosed** in a range, it will keep the ID attribute
                 * regardless of the `cloneId` parameter value, because it is not cloned &mdash; it is moved to the returned
                 * document fragment.
                 *
                 * @param {Boolean} [mergeThen] Merge any split elements result in DOM true due to partial selection.
                 * @param {Boolean} [cloneId=true] Whether to preserve ID attributes in the extracted content.
                 * @returns {CKEDITOR.dom.documentFragment} Document fragment containing extracted content.
                 */
                extractContents: function( mergeThen, cloneId ) {
                        var docFrag = new CKEDITOR.dom.documentFragment( this.document );

                        cloneId = typeof cloneId == 'undefined' ? true : cloneId;

                        if ( !this.collapsed )
                                execContentsAction( this, 1, docFrag, mergeThen, cloneId );

                        return docFrag;
                },

                /**
                 * Creates a bookmark object, which can be later used to restore the
                 * range by using the {@link #moveToBookmark} function.
                 *
                 * This is an "intrusive" way to create a bookmark. It includes `<span>` tags
                 * in the range boundaries. The advantage of it is that it is possible to
                 * handle DOM mutations when moving back to the bookmark.
                 *
                 * **Note:** The inclusion of nodes in the DOM is a design choice and
                 * should not be changed as there are other points in the code that may be
                 * using those nodes to perform operations.
                 *
                 * @param {Boolean} [serializable] Indicates that the bookmark nodes
                 * must contain IDs, which can be used to restore the range even
                 * when these nodes suffer mutations (like cloning or `innerHTML` change).
                 * @returns {Object} And object representing a bookmark.
                 * @returns {CKEDITOR.dom.node/String} return.startNode Node or element ID.
                 * @returns {CKEDITOR.dom.node/String} return.endNode Node or element ID.
                 * @returns {Boolean} return.serializable
                 * @returns {Boolean} return.collapsed
                 */
                createBookmark: function( serializable ) {
                        var startNode, endNode;
                        var baseId;
                        var clone;
                        var collapsed = this.collapsed;

                        startNode = this.document.createElement( 'span' );
                        startNode.data( 'cke-bookmark', 1 );
                        startNode.setStyle( 'display', 'none' );

                        // For IE, it must have something inside, otherwise it may be
                        // removed during DOM operations.
                        startNode.setHtml( '&nbsp;' );

                        if ( serializable ) {
                                baseId = 'cke_bm_' + CKEDITOR.tools.getNextNumber();
                                startNode.setAttribute( 'id', baseId + ( collapsed ? 'C' : 'S' ) );
                        }

                        // If collapsed, the endNode will not be created.
                        if ( !collapsed ) {
                                endNode = startNode.clone();
                                endNode.setHtml( '&nbsp;' );

                                if ( serializable )
                                        endNode.setAttribute( 'id', baseId + 'E' );

                                clone = this.clone();
                                clone.collapse();
                                clone.insertNode( endNode );
                        }

                        clone = this.clone();
                        clone.collapse( true );
                        clone.insertNode( startNode );

                        // Update the range position.
                        if ( endNode ) {
                                this.setStartAfter( startNode );
                                this.setEndBefore( endNode );
                        } else {
                                this.moveToPosition( startNode, CKEDITOR.POSITION_AFTER_END );
                        }

                        return {
                                startNode: serializable ? baseId + ( collapsed ? 'C' : 'S' ) : startNode,
                                endNode: serializable ? baseId + 'E' : endNode,
                                serializable: serializable,
                                collapsed: collapsed
                        };
                },

                /**
                 * Creates a "non intrusive" and "mutation sensible" bookmark. This
                 * kind of bookmark should be used only when the DOM is supposed to
                 * remain stable after its creation.
                 *
                 * @param {Boolean} [normalized] Indicates that the bookmark must
                 * be normalized. When normalized, the successive text nodes are
                 * considered a single node. To successfully load a normalized
                 * bookmark, the DOM tree must also be normalized before calling
                 * {@link #moveToBookmark}.
                 * @returns {Object} An object representing the bookmark.
                 * @returns {Array} return.start Start container's address (see {@link CKEDITOR.dom.node#getAddress}).
                 * @returns {Array} return.end Start container's address.
                 * @returns {Number} return.startOffset
                 * @returns {Number} return.endOffset
                 * @returns {Boolean} return.collapsed
                 * @returns {Boolean} return.normalized
                 * @returns {Boolean} return.is2 This is "bookmark2".
                 */
                createBookmark2: ( function() {
                        var isNotText = CKEDITOR.dom.walker.nodeType( CKEDITOR.NODE_TEXT, true );

                        // Returns true for limit anchored in element and placed between text nodes.
                        //
                        //               v
                        // <p>[text node] [text node]</p> -> true
                        //
                        //    v
                        // <p> [text node]</p> -> false
                        //
                        //              v
                        // <p>[text node][text node]</p> -> false (limit is anchored in text node)
                        function betweenTextNodes( container, offset ) {
                                // Not anchored in element or limit is on the edge.
                                if ( container.type != CKEDITOR.NODE_ELEMENT || offset === 0 || offset == container.getChildCount() )
                                        return 0;

                                return container.getChild( offset - 1 ).type == CKEDITOR.NODE_TEXT &&
                                        container.getChild( offset ).type == CKEDITOR.NODE_TEXT;
                        }

                        // Sums lengths of all preceding text nodes.
                        function getLengthOfPrecedingTextNodes( node ) {
                                var sum = 0;

                                while ( ( node = node.getPrevious() ) && node.type == CKEDITOR.NODE_TEXT )
                                        sum += node.getText().replace( CKEDITOR.dom.selection.FILLING_CHAR_SEQUENCE, '' ).length;

                                return sum;
                        }

                        function normalizeTextNodes( limit ) {
                                var container = limit.container,
                                        offset = limit.offset;

                                // If limit is between text nodes move it to the end of preceding one,
                                // because they will be merged.
                                if ( betweenTextNodes( container, offset ) ) {
                                        container = container.getChild( offset - 1 );
                                        offset = container.getLength();
                                }

                                // Now, if limit is anchored in element and has at least one node before it,
                                // it may happen that some of them will be merged. Normalize the offset
                                // by setting it to normalized index of its preceding, safe node.
                                // (safe == one for which getIndex(true) does not return -1, so one which won't disappear).
                                if ( container.type == CKEDITOR.NODE_ELEMENT && offset > 0 ) {
                                        offset = getPrecedingSafeNodeIndex( container, offset ) + 1;
                                }

                                // The last step - fix the offset inside text node by adding
                                // lengths of preceding text nodes which will be merged with container.
                                if ( container.type == CKEDITOR.NODE_TEXT ) {
                                        var precedingLength = getLengthOfPrecedingTextNodes( container );

                                        // Normal case - text node is not empty.
                                        if ( container.getText() ) {
                                                offset += precedingLength;

                                        // Awful case - the text node is empty and thus will be totally lost.
                                        // In this case we are trying to normalize the limit to the left:
                                        // * either to the preceding text node,
                                        // * or to the "gap" after the preceding element.
                                        } else {
                                                // Find the closest non-text sibling.
                                                var precedingContainer = container.getPrevious( isNotText );

                                                // If there are any characters on the left, that means that we can anchor
                                                // there, because this text node will not be lost.
                                                if ( precedingLength ) {
                                                        offset = precedingLength;

                                                        if ( precedingContainer ) {
                                                                // The text node is the first node after the closest non-text sibling.
                                                                container = precedingContainer.getNext();
                                                        } else {
                                                                // But if there was no non-text sibling, then the text node is the first child.
                                                                container = container.getParent().getFirst();
                                                        }

                                                // If there are no characters on the left, then anchor after the previous non-text node.
                                                // E.g. (see tests for a legend :D):
                                                // <b>x</b>(foo)({}bar) -> <b>x</b>[](foo)(bar)
                                                } else {
                                                        container = container.getParent();
                                                        offset = precedingContainer ? ( precedingContainer.getIndex( true ) + 1 ) : 0;
                                                }
                                        }
                                }

                                limit.container = container;
                                limit.offset = offset;
                        }

                        function normalizeFCSeq( limit, root ) {
                                var fcseq = root.getCustomData( 'cke-fillingChar' );

                                if ( !fcseq ) {
                                        return;
                                }

                                var container = limit.container;

                                if ( fcseq.equals( container ) ) {
                                        limit.offset -= CKEDITOR.dom.selection.FILLING_CHAR_SEQUENCE.length;

                                        // == 0         handles case when limit was at the end of FCS.
                                        //  < 0         handles all cases where limit was somewhere in the middle or at the beginning.
                                        //  > 0         (the "else" case) means cases where there are some more characters in the FCS node (FCSabc^def).
                                        if ( limit.offset <= 0 ) {
                                                limit.offset = container.getIndex();
                                                limit.container = container.getParent();
                                        }
                                        return;
                                }

                                // And here goes the funny part - all other cases are handled inside node.getAddress() and getIndex() thanks to
                                // node.getIndex() being aware of FCS (handling it as an empty node).
                        }

                        // Finds a normalized index of a safe node preceding this one.
                        // Safe == one that will not disappear, so one for which getIndex( true ) does not return -1.
                        // Return -1 if there's no safe preceding node.
                        function getPrecedingSafeNodeIndex( container, offset ) {
                                var index;

                                while ( offset-- ) {
                                        index = container.getChild( offset ).getIndex( true );

                                        if ( index >= 0 )
                                                return index;
                                }

                                return -1;
                        }

                        return function( normalized ) {
                                var collapsed = this.collapsed,
                                        bmStart = {
                                                container: this.startContainer,
                                                offset: this.startOffset
                                        },
                                        bmEnd = {
                                                container: this.endContainer,
                                                offset: this.endOffset
                                        };

                                if ( normalized ) {
                                        normalizeTextNodes( bmStart );
                                        normalizeFCSeq( bmStart, this.root );

                                        if ( !collapsed ) {
                                                normalizeTextNodes( bmEnd );
                                                normalizeFCSeq( bmEnd, this.root );
                                        }
                                }

                                return {
                                        start: bmStart.container.getAddress( normalized ),
                                        end: collapsed ? null : bmEnd.container.getAddress( normalized ),
                                        startOffset: bmStart.offset,
                                        endOffset: bmEnd.offset,
                                        normalized: normalized,
                                        collapsed: collapsed,
                                        is2: true // It's a createBookmark2 bookmark.
                                };
                        };
                } )(),

                /**
                 * Moves this range to the given bookmark. See {@link #createBookmark} and {@link #createBookmark2}.
                 *
                 * If serializable bookmark passed, then its `<span>` markers will be removed.
                 *
                 * @param {Object} bookmark
                 */
                moveToBookmark: function( bookmark ) {
                        // Created with createBookmark2().
                        if ( bookmark.is2 ) {
                                // Get the start information.
                                var startContainer = this.document.getByAddress( bookmark.start, bookmark.normalized ),
                                        startOffset = bookmark.startOffset;

                                // Get the end information.
                                var endContainer = bookmark.end && this.document.getByAddress( bookmark.end, bookmark.normalized ),
                                        endOffset = bookmark.endOffset;

                                // Set the start boundary.
                                this.setStart( startContainer, startOffset );

                                // Set the end boundary. If not available, collapse it.
                                if ( endContainer )
                                        this.setEnd( endContainer, endOffset );
                                else
                                        this.collapse( true );
                        }
                        // Created with createBookmark().
                        else {
                                var serializable = bookmark.serializable,
                                        startNode = serializable ? this.document.getById( bookmark.startNode ) : bookmark.startNode,
                                        endNode = serializable ? this.document.getById( bookmark.endNode ) : bookmark.endNode;

                                // Set the range start at the bookmark start node position.
                                this.setStartBefore( startNode );

                                // Remove it, because it may interfere in the setEndBefore call.
                                startNode.remove();

                                // Set the range end at the bookmark end node position, or simply
                                // collapse it if it is not available.
                                if ( endNode ) {
                                        this.setEndBefore( endNode );
                                        endNode.remove();
                                } else {
                                        this.collapse( true );
                                }
                        }
                },

                /**
                 * Returns two nodes which are on the boundaries of this range.
                 *
                 * @returns {Object}
                 * @returns {CKEDITOR.dom.node} return.startNode
                 * @returns {CKEDITOR.dom.node} return.endNode
                 * @todo precise desc/algorithm
                 */
                getBoundaryNodes: function() {
                        var startNode = this.startContainer,
                                endNode = this.endContainer,
                                startOffset = this.startOffset,
                                endOffset = this.endOffset,
                                childCount;

                        if ( startNode.type == CKEDITOR.NODE_ELEMENT ) {
                                childCount = startNode.getChildCount();
                                if ( childCount > startOffset ) {
                                        startNode = startNode.getChild( startOffset );
                                } else if ( childCount < 1 ) {
                                        startNode = startNode.getPreviousSourceNode();
                                }
                                // startOffset > childCount but childCount is not 0
                                else {
                                        // Try to take the node just after the current position.
                                        startNode = startNode.$;
                                        while ( startNode.lastChild )
                                                startNode = startNode.lastChild;
                                        startNode = new CKEDITOR.dom.node( startNode );

                                        // Normally we should take the next node in DFS order. But it
                                        // is also possible that we've already reached the end of
                                        // document.
                                        startNode = startNode.getNextSourceNode() || startNode;
                                }
                        }

                        if ( endNode.type == CKEDITOR.NODE_ELEMENT ) {
                                childCount = endNode.getChildCount();
                                if ( childCount > endOffset ) {
                                        endNode = endNode.getChild( endOffset ).getPreviousSourceNode( true );
                                } else if ( childCount < 1 ) {
                                        endNode = endNode.getPreviousSourceNode();
                                }
                                // endOffset > childCount but childCount is not 0.
                                else {
                                        // Try to take the node just before the current position.
                                        endNode = endNode.$;
                                        while ( endNode.lastChild )
                                                endNode = endNode.lastChild;
                                        endNode = new CKEDITOR.dom.node( endNode );
                                }
                        }

                        // Sometimes the endNode will come right before startNode for collapsed
                        // ranges. Fix it. (#3780)
                        if ( startNode.getPosition( endNode ) & CKEDITOR.POSITION_FOLLOWING )
                                startNode = endNode;

                        return { startNode: startNode, endNode: endNode };
                },

                /**
                 * Find the node which fully contains the range.
                 *
                 * @param {Boolean} [includeSelf=false]
                 * @param {Boolean} [ignoreTextNode=false] Whether ignore {@link CKEDITOR#NODE_TEXT} type.
                 * @returns {CKEDITOR.dom.element}
                 */
                getCommonAncestor: function( includeSelf, ignoreTextNode ) {
                        var start = this.startContainer,
                                end = this.endContainer,
                                ancestor;

                        if ( start.equals( end ) ) {
                                if ( includeSelf && start.type == CKEDITOR.NODE_ELEMENT && this.startOffset == this.endOffset - 1 )
                                        ancestor = start.getChild( this.startOffset );
                                else
                                        ancestor = start;
                        } else {
                                ancestor = start.getCommonAncestor( end );
                        }

                        return ignoreTextNode && !ancestor.is ? ancestor.getParent() : ancestor;
                },

                /**
                 * Transforms the {@link #startContainer} and {@link #endContainer} properties from text
                 * nodes to element nodes, whenever possible. This is actually possible
                 * if either of the boundary containers point to a text node, and its
                 * offset is set to zero, or after the last char in the node.
                 */
                optimize: function() {
                        var container = this.startContainer;
                        var offset = this.startOffset;

                        if ( container.type != CKEDITOR.NODE_ELEMENT ) {
                                if ( !offset )
                                        this.setStartBefore( container );
                                else if ( offset >= container.getLength() )
                                        this.setStartAfter( container );
                        }

                        container = this.endContainer;
                        offset = this.endOffset;

                        if ( container.type != CKEDITOR.NODE_ELEMENT ) {
                                if ( !offset )
                                        this.setEndBefore( container );
                                else if ( offset >= container.getLength() )
                                        this.setEndAfter( container );
                        }
                },

                /**
                 * Move the range out of bookmark nodes if they'd been the container.
                 */
                optimizeBookmark: function() {
                        var startNode = this.startContainer,
                                endNode = this.endContainer;

                        if ( startNode.is && startNode.is( 'span' ) && startNode.data( 'cke-bookmark' ) )
                                this.setStartAt( startNode, CKEDITOR.POSITION_BEFORE_START );
                        if ( endNode && endNode.is && endNode.is( 'span' ) && endNode.data( 'cke-bookmark' ) )
                                this.setEndAt( endNode, CKEDITOR.POSITION_AFTER_END );
                },

                /**
                 * @param {Boolean} [ignoreStart=false]
                 * @param {Boolean} [ignoreEnd=false]
                 * @todo precise desc/algorithm
                 */
                trim: function( ignoreStart, ignoreEnd ) {
                        var startContainer = this.startContainer,
                                startOffset = this.startOffset,
                                collapsed = this.collapsed;
                        if ( ( !ignoreStart || collapsed ) && startContainer && startContainer.type == CKEDITOR.NODE_TEXT ) {
                                // If the offset is zero, we just insert the new node before
                                // the start.
                                if ( !startOffset ) {
                                        startOffset = startContainer.getIndex();
                                        startContainer = startContainer.getParent();
                                }
                                // If the offset is at the end, we'll insert it after the text
                                // node.
                                else if ( startOffset >= startContainer.getLength() ) {
                                        startOffset = startContainer.getIndex() + 1;
                                        startContainer = startContainer.getParent();
                                }
                                // In other case, we split the text node and insert the new
                                // node at the split point.
                                else {
                                        var nextText = startContainer.split( startOffset );

                                        startOffset = startContainer.getIndex() + 1;
                                        startContainer = startContainer.getParent();

                                        // Check all necessity of updating the end boundary.
                                        if ( this.startContainer.equals( this.endContainer ) )
                                                this.setEnd( nextText, this.endOffset - this.startOffset );
                                        else if ( startContainer.equals( this.endContainer ) )
                                                this.endOffset += 1;
                                }

                                this.setStart( startContainer, startOffset );

                                if ( collapsed ) {
                                        this.collapse( true );
                                        return;
                                }
                        }

                        var endContainer = this.endContainer;
                        var endOffset = this.endOffset;

                        if ( !( ignoreEnd || collapsed ) && endContainer && endContainer.type == CKEDITOR.NODE_TEXT ) {
                                // If the offset is zero, we just insert the new node before
                                // the start.
                                if ( !endOffset ) {
                                        endOffset = endContainer.getIndex();
                                        endContainer = endContainer.getParent();
                                }
                                // If the offset is at the end, we'll insert it after the text
                                // node.
                                else if ( endOffset >= endContainer.getLength() ) {
                                        endOffset = endContainer.getIndex() + 1;
                                        endContainer = endContainer.getParent();
                                }
                                // In other case, we split the text node and insert the new
                                // node at the split point.
                                else {
                                        endContainer.split( endOffset );

                                        endOffset = endContainer.getIndex() + 1;
                                        endContainer = endContainer.getParent();
                                }

                                this.setEnd( endContainer, endOffset );
                        }
                },

                /**
                 * Expands the range so that partial units are completely contained.
                 *
                 * @param {Number} unit The unit type to expand with. Use one of following values: {@link CKEDITOR#ENLARGE_BLOCK_CONTENTS},
                 * {@link CKEDITOR#ENLARGE_ELEMENT}, {@link CKEDITOR#ENLARGE_INLINE}, {@link CKEDITOR#ENLARGE_LIST_ITEM_CONTENTS}.
                 * @param {Boolean} [excludeBrs=false] Whether include line-breaks when expanding.
                 */
                enlarge: function( unit, excludeBrs ) {
                        var leadingWhitespaceRegex = new RegExp( /[^\s\ufeff]/ );

                        switch ( unit ) {
                                case CKEDITOR.ENLARGE_INLINE:
                                        var enlargeInlineOnly = 1;

                                /* falls through */
                                case CKEDITOR.ENLARGE_ELEMENT:

                                        if ( this.collapsed )
                                                return;

                                        // Get the common ancestor.
                                        var commonAncestor = this.getCommonAncestor();

                                        var boundary = this.root;

                                        // For each boundary
                                        //              a. Depending on its position, find out the first node to be checked (a sibling) or,
                                        //                      if not available, to be enlarge.
                                        //              b. Go ahead checking siblings and enlarging the boundary as much as possible until the
                                        //                      common ancestor is not reached. After reaching the common ancestor, just save the
                                        //                      enlargeable node to be used later.

                                        var startTop, endTop;

                                        var enlargeable, sibling, commonReached;

                                        // Indicates that the node can be added only if whitespace
                                        // is available before it.
                                        var needsWhiteSpace = false;
                                        var isWhiteSpace;
                                        var siblingText;

                                        // Process the start boundary.

                                        var container = this.startContainer;
                                        var offset = this.startOffset;

                                        if ( container.type == CKEDITOR.NODE_TEXT ) {
                                                if ( offset ) {
                                                        // Check if there is any non-space text before the
                                                        // offset. Otherwise, container is null.
                                                        container = !CKEDITOR.tools.trim( container.substring( 0, offset ) ).length && container;

                                                        // If we found only whitespace in the node, it
                                                        // means that we'll need more whitespace to be able
                                                        // to expand. For example, <i> can be expanded in
                                                        // "A <i> [B]</i>", but not in "A<i> [B]</i>".
                                                        needsWhiteSpace = !!container;
                                                }

                                                if ( container ) {
                                                        if ( !( sibling = container.getPrevious() ) )
                                                                enlargeable = container.getParent();
                                                }
                                        } else {
                                                // If we have offset, get the node preceeding it as the
                                                // first sibling to be checked.
                                                if ( offset )
                                                        sibling = container.getChild( offset - 1 ) || container.getLast();

                                                // If there is no sibling, mark the container to be
                                                // enlarged.
                                                if ( !sibling )
                                                        enlargeable = container;
                                        }

                                        // Ensures that enlargeable can be indeed enlarged, if not it will be nulled.
                                        enlargeable = getValidEnlargeable( enlargeable );

                                        while ( enlargeable || sibling ) {
                                                if ( enlargeable && !sibling ) {
                                                        // If we reached the common ancestor, mark the flag
                                                        // for it.
                                                        if ( !commonReached && enlargeable.equals( commonAncestor ) )
                                                                commonReached = true;

                                                        if ( enlargeInlineOnly ? enlargeable.isBlockBoundary() : !boundary.contains( enlargeable ) )
                                                                break;

                                                        // If we don't need space or this element breaks
                                                        // the line, then enlarge it.
                                                        if ( !needsWhiteSpace || enlargeable.getComputedStyle( 'display' ) != 'inline' ) {
                                                                needsWhiteSpace = false;

                                                                // If the common ancestor has been reached,
                                                                // we'll not enlarge it immediately, but just
                                                                // mark it to be enlarged later if the end
                                                                // boundary also enlarges it.
                                                                if ( commonReached )
                                                                        startTop = enlargeable;
                                                                else
                                                                        this.setStartBefore( enlargeable );
                                                        }

                                                        sibling = enlargeable.getPrevious();
                                                }

                                                // Check all sibling nodes preceeding the enlargeable
                                                // node. The node wil lbe enlarged only if none of them
                                                // blocks it.
                                                while ( sibling ) {
                                                        // This flag indicates that this node has
                                                        // whitespaces at the end.
                                                        isWhiteSpace = false;

                                                        if ( sibling.type == CKEDITOR.NODE_COMMENT ) {
                                                                sibling = sibling.getPrevious();
                                                                continue;
                                                        } else if ( sibling.type == CKEDITOR.NODE_TEXT ) {
                                                                siblingText = sibling.getText();

                                                                if ( leadingWhitespaceRegex.test( siblingText ) )
                                                                        sibling = null;

                                                                isWhiteSpace = /[\s\ufeff]$/.test( siblingText );
                                                        } else {
                                                                // #12221 (Chrome) plus #11111 (Safari).
                                                                var offsetWidth0 = CKEDITOR.env.webkit ? 1 : 0;

                                                                // If this is a visible element.
                                                                // We need to check for the bookmark attribute because IE insists on
                                                                // rendering the display:none nodes we use for bookmarks. (#3363)
                                                                // Line-breaks (br) are rendered with zero width, which we don't want to include. (#7041)
                                                                if ( ( sibling.$.offsetWidth > offsetWidth0 || excludeBrs && sibling.is( 'br' ) ) && !sibling.data( 'cke-bookmark' ) ) {
                                                                        // We'll accept it only if we need
                                                                        // whitespace, and this is an inline
                                                                        // element with whitespace only.
                                                                        if ( needsWhiteSpace && CKEDITOR.dtd.$removeEmpty[ sibling.getName() ] ) {
                                                                                // It must contains spaces and inline elements only.

                                                                                siblingText = sibling.getText();

                                                                                if ( leadingWhitespaceRegex.test( siblingText ) ) // Spaces + Zero Width No-Break Space (U+FEFF)
                                                                                sibling = null;
                                                                                else {
                                                                                        var allChildren = sibling.$.getElementsByTagName( '*' );
                                                                                        for ( var i = 0, child; child = allChildren[ i++ ]; ) {
                                                                                                if ( !CKEDITOR.dtd.$removeEmpty[ child.nodeName.toLowerCase() ] ) {
                                                                                                        sibling = null;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                }

                                                                                if ( sibling )
                                                                                        isWhiteSpace = !!siblingText.length;
                                                                        } else {
                                                                                sibling = null;
                                                                        }
                                                                }
                                                        }

                                                        // A node with whitespaces has been found.
                                                        if ( isWhiteSpace ) {
                                                                // Enlarge the last enlargeable node, if we
                                                                // were waiting for spaces.
                                                                if ( needsWhiteSpace ) {
                                                                        if ( commonReached )
                                                                                startTop = enlargeable;
                                                                        else if ( enlargeable )
                                                                                this.setStartBefore( enlargeable );
                                                                } else {
                                                                        needsWhiteSpace = true;
                                                                }
                                                        }

                                                        if ( sibling ) {
                                                                var next = sibling.getPrevious();

                                                                if ( !enlargeable && !next ) {
                                                                        // Set the sibling as enlargeable, so it's
                                                                        // parent will be get later outside this while.
                                                                        enlargeable = sibling;
                                                                        sibling = null;
                                                                        break;
                                                                }

                                                                sibling = next;
                                                        } else {
                                                                // If sibling has been set to null, then we
                                                                // need to stop enlarging.
                                                                enlargeable = null;
                                                        }
                                                }

                                                if ( enlargeable )
                                                        enlargeable = getValidEnlargeable( enlargeable.getParent() );
                                        }

                                        // Process the end boundary. This is basically the same
                                        // code used for the start boundary, with small changes to
                                        // make it work in the oposite side (to the right). This
                                        // makes it difficult to reuse the code here. So, fixes to
                                        // the above code are likely to be replicated here.

                                        container = this.endContainer;
                                        offset = this.endOffset;

                                        // Reset the common variables.
                                        enlargeable = sibling = null;
                                        commonReached = needsWhiteSpace = false;

                                        // Function check if there are only whitespaces from the given starting point
                                        // (startContainer and startOffset) till the end on block.
                                        // Examples ("[" is the start point):
                                        //  - <p>foo[ </p>           - will return true,
                                        //  - <p><b>foo[ </b> </p>   - will return true,
                                        //  - <p>foo[ bar</p>        - will return false,
                                        //  - <p><b>foo[ </b>bar</p> - will return false,
                                        //  - <p>foo[ <b></b></p>    - will return false.
                                        function onlyWhiteSpaces( startContainer, startOffset ) {
                                                // We need to enlarge range if there is white space at the end of the block,
                                                // because it is not displayed in WYSIWYG mode and user can not select it. So
                                                // "<p>foo[bar] </p>" should be changed to "<p>foo[bar ]</p>". On the other hand
                                                // we should do nothing if we are not at the end of the block, so this should not
                                                // be changed: "<p><i>[foo] </i>bar</p>".
                                                var walkerRange = new CKEDITOR.dom.range( boundary );
                                                walkerRange.setStart( startContainer, startOffset );
                                                // The guard will find the end of range so I put boundary here.
                                                walkerRange.setEndAt( boundary, CKEDITOR.POSITION_BEFORE_END );

                                                var walker = new CKEDITOR.dom.walker( walkerRange ),
                                                        node;

                                                walker.guard = function( node ) {
                                                        // Stop if you exit block.
                                                        return !( node.type == CKEDITOR.NODE_ELEMENT && node.isBlockBoundary() );
                                                };

                                                while ( ( node = walker.next() ) ) {
                                                        if ( node.type != CKEDITOR.NODE_TEXT ) {
                                                                // Stop if you enter to any node (walker.next() will return node only
                                                                // it goes out, not if it is go into node).
                                                                return false;
                                                        } else {
                                                                // Trim the first node to startOffset.
                                                                if ( node != startContainer )
                                                                        siblingText = node.getText();
                                                                else
                                                                        siblingText = node.substring( startOffset );

                                                                // Check if it is white space.
                                                                if ( leadingWhitespaceRegex.test( siblingText ) )
                                                                        return false;
                                                        }
                                                }

                                                return true;
                                        }

                                        if ( container.type == CKEDITOR.NODE_TEXT ) {
                                                // Check if there is only white space after the offset.
                                                if ( CKEDITOR.tools.trim( container.substring( offset ) ).length ) {
                                                        // If we found only whitespace in the node, it
                                                        // means that we'll need more whitespace to be able
                                                        // to expand. For example, <i> can be expanded in
                                                        // "A <i> [B]</i>", but not in "A<i> [B]</i>".
                                                        needsWhiteSpace = true;
                                                } else {
                                                        needsWhiteSpace = !container.getLength();

                                                        if ( offset == container.getLength() ) {
                                                                // If we are at the end of container and this is the last text node,
                                                                // we should enlarge end to the parent.
                                                                if ( !( sibling = container.getNext() ) )
                                                                        enlargeable = container.getParent();
                                                        } else {
                                                                // If we are in the middle on text node and there are only whitespaces
                                                                // till the end of block, we should enlarge element.
                                                                if ( onlyWhiteSpaces( container, offset ) )
                                                                        enlargeable = container.getParent();
                                                        }
                                                }
                                        } else {
                                                // Get the node right after the boudary to be checked
                                                // first.
                                                sibling = container.getChild( offset );

                                                if ( !sibling )
                                                        enlargeable = container;
                                        }

                                        while ( enlargeable || sibling ) {
                                                if ( enlargeable && !sibling ) {
                                                        if ( !commonReached && enlargeable.equals( commonAncestor ) )
                                                                commonReached = true;

                                                        if ( enlargeInlineOnly ? enlargeable.isBlockBoundary() : !boundary.contains( enlargeable ) )
                                                                break;

                                                        if ( !needsWhiteSpace || enlargeable.getComputedStyle( 'display' ) != 'inline' ) {
                                                                needsWhiteSpace = false;

                                                                if ( commonReached )
                                                                        endTop = enlargeable;
                                                                else if ( enlargeable )
                                                                        this.setEndAfter( enlargeable );
                                                        }

                                                        sibling = enlargeable.getNext();
                                                }

                                                while ( sibling ) {
                                                        isWhiteSpace = false;

                                                        if ( sibling.type == CKEDITOR.NODE_TEXT ) {
                                                                siblingText = sibling.getText();

                                                                // Check if there are not whitespace characters till the end of editable.
                                                                // If so stop expanding.
                                                                if ( !onlyWhiteSpaces( sibling, 0 ) )
                                                                        sibling = null;

                                                                isWhiteSpace = /^[\s\ufeff]/.test( siblingText );
                                                        } else if ( sibling.type == CKEDITOR.NODE_ELEMENT ) {
                                                                // If this is a visible element.
                                                                // We need to check for the bookmark attribute because IE insists on
                                                                // rendering the display:none nodes we use for bookmarks. (#3363)
                                                                // Line-breaks (br) are rendered with zero width, which we don't want to include. (#7041)
                                                                if ( ( sibling.$.offsetWidth > 0 || excludeBrs && sibling.is( 'br' ) ) && !sibling.data( 'cke-bookmark' ) ) {
                                                                        // We'll accept it only if we need
                                                                        // whitespace, and this is an inline
                                                                        // element with whitespace only.
                                                                        if ( needsWhiteSpace && CKEDITOR.dtd.$removeEmpty[ sibling.getName() ] ) {
                                                                                // It must contains spaces and inline elements only.

                                                                                siblingText = sibling.getText();

                                                                                if ( leadingWhitespaceRegex.test( siblingText ) )
                                                                                        sibling = null;
                                                                                else {
                                                                                        allChildren = sibling.$.getElementsByTagName( '*' );
                                                                                        for ( i = 0; child = allChildren[ i++ ]; ) {
                                                                                                if ( !CKEDITOR.dtd.$removeEmpty[ child.nodeName.toLowerCase() ] ) {
                                                                                                        sibling = null;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                }

                                                                                if ( sibling )
                                                                                        isWhiteSpace = !!siblingText.length;
                                                                        } else {
                                                                                sibling = null;
                                                                        }
                                                                }
                                                        } else {
                                                                isWhiteSpace = 1;
                                                        }

                                                        if ( isWhiteSpace ) {
                                                                if ( needsWhiteSpace ) {
                                                                        if ( commonReached )
                                                                                endTop = enlargeable;
                                                                        else
                                                                                this.setEndAfter( enlargeable );
                                                                }
                                                        }

                                                        if ( sibling ) {
                                                                next = sibling.getNext();

                                                                if ( !enlargeable && !next ) {
                                                                        enlargeable = sibling;
                                                                        sibling = null;
                                                                        break;
                                                                }

                                                                sibling = next;
                                                        } else {
                                                                // If sibling has been set to null, then we
                                                                // need to stop enlarging.
                                                                enlargeable = null;
                                                        }
                                                }

                                                if ( enlargeable )
                                                        enlargeable = getValidEnlargeable( enlargeable.getParent() );
                                        }

                                        // If the common ancestor can be enlarged by both boundaries, then include it also.
                                        if ( startTop && endTop ) {
                                                commonAncestor = startTop.contains( endTop ) ? endTop : startTop;

                                                this.setStartBefore( commonAncestor );
                                                this.setEndAfter( commonAncestor );
                                        }
                                        break;

                                case CKEDITOR.ENLARGE_BLOCK_CONTENTS:
                                case CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS:

                                        // Enlarging the start boundary.
                                        var walkerRange = new CKEDITOR.dom.range( this.root );

                                        boundary = this.root;

                                        walkerRange.setStartAt( boundary, CKEDITOR.POSITION_AFTER_START );
                                        walkerRange.setEnd( this.startContainer, this.startOffset );

                                        var walker = new CKEDITOR.dom.walker( walkerRange ),
                                                blockBoundary, // The node on which the enlarging should stop.
                                                tailBr, // In case BR as block boundary.
                                                notBlockBoundary = CKEDITOR.dom.walker.blockBoundary( ( unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS ) ? { br: 1 } : null ),
                                                inNonEditable = null,
                                                // Record the encountered 'blockBoundary' for later use.
                                                boundaryGuard = function( node ) {
                                                        // We should not check contents of non-editable elements. It may happen
                                                        // that inline widget has display:table child which should not block range#enlarge.
                                                        // When encoutered non-editable element...
                                                        if ( node.type == CKEDITOR.NODE_ELEMENT && node.getAttribute( 'contenteditable' ) == 'false' ) {
                                                                if ( inNonEditable ) {
                                                                        // ... in which we already were, reset it (because we're leaving it) and return.
                                                                        if ( inNonEditable.equals( node ) ) {
                                                                                inNonEditable = null;
                                                                                return;
                                                                        }
                                                                // ... which we're entering, remember it but check it (no return).
                                                                } else {
                                                                        inNonEditable = node;
                                                                }
                                                        // When we are in non-editable element, do not check if current node is a block boundary.
                                                        } else if ( inNonEditable ) {
                                                                return;
                                                        }

                                                        var retval = notBlockBoundary( node );
                                                        if ( !retval )
                                                                blockBoundary = node;
                                                        return retval;
                                                },
                                                // Record the encounted 'tailBr' for later use.
                                                tailBrGuard = function( node ) {
                                                        var retval = boundaryGuard( node );
                                                        if ( !retval && node.is && node.is( 'br' ) )
                                                                tailBr = node;
                                                        return retval;
                                                };

                                        walker.guard = boundaryGuard;

                                        enlargeable = walker.lastBackward();

                                        // It's the body which stop the enlarging if no block boundary found.
                                        blockBoundary = blockBoundary || boundary;

                                        // Start the range either after the end of found block (<p>...</p>[text)
                                        // or at the start of block (<p>[text...), by comparing the document position
                                        // with 'enlargeable' node.
                                        this.setStartAt( blockBoundary, !blockBoundary.is( 'br' ) && ( !enlargeable && this.checkStartOfBlock() ||
                                                enlargeable && blockBoundary.contains( enlargeable ) ) ? CKEDITOR.POSITION_AFTER_START : CKEDITOR.POSITION_AFTER_END );

                                        // Avoid enlarging the range further when end boundary spans right after the BR. (#7490)
                                        if ( unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS ) {
                                                var theRange = this.clone();
                                                walker = new CKEDITOR.dom.walker( theRange );

                                                var whitespaces = CKEDITOR.dom.walker.whitespaces(),
                                                        bookmark = CKEDITOR.dom.walker.bookmark();

                                                walker.evaluator = function( node ) {
                                                        return !whitespaces( node ) && !bookmark( node );
                                                };
                                                var previous = walker.previous();
                                                if ( previous && previous.type == CKEDITOR.NODE_ELEMENT && previous.is( 'br' ) )
                                                        return;
                                        }

                                        // Enlarging the end boundary.
                                        // Set up new range and reset all flags (blockBoundary, inNonEditable, tailBr).

                                        walkerRange = this.clone();
                                        walkerRange.collapse();
                                        walkerRange.setEndAt( boundary, CKEDITOR.POSITION_BEFORE_END );
                                        walker = new CKEDITOR.dom.walker( walkerRange );

                                        // tailBrGuard only used for on range end.
                                        walker.guard = ( unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS ) ? tailBrGuard : boundaryGuard;
                                        blockBoundary = inNonEditable = tailBr = null;

                                        // End the range right before the block boundary node.
                                        enlargeable = walker.lastForward();

                                        // It's the body which stop the enlarging if no block boundary found.
                                        blockBoundary = blockBoundary || boundary;

                                        // Close the range either before the found block start (text]<p>...</p>) or at the block end (...text]</p>)
                                        // by comparing the document position with 'enlargeable' node.
                                        this.setEndAt( blockBoundary, ( !enlargeable && this.checkEndOfBlock() ||
                                                enlargeable && blockBoundary.contains( enlargeable ) ) ? CKEDITOR.POSITION_BEFORE_END : CKEDITOR.POSITION_BEFORE_START );
                                        // We must include the <br> at the end of range if there's
                                        // one and we're expanding list item contents
                                        if ( tailBr ) {
                                                this.setEndAfter( tailBr );
                                        }
                        }

                        // Ensures that returned element can be enlarged by selection, null otherwise.
                        // @param {CKEDITOR.dom.element} enlargeable
                        // @returns {CKEDITOR.dom.element/null}
                        function getValidEnlargeable( enlargeable ) {
                                return enlargeable && enlargeable.type == CKEDITOR.NODE_ELEMENT && enlargeable.hasAttribute( 'contenteditable' ) ?
                                        null : enlargeable;
                        }
                },

                /**
                 * Descrease the range to make sure that boundaries
                 * always anchor beside text nodes or innermost element.
                 *
                 * @param {Number} mode The shrinking mode ({@link CKEDITOR#SHRINK_ELEMENT} or {@link CKEDITOR#SHRINK_TEXT}).
                 *
                 * * {@link CKEDITOR#SHRINK_ELEMENT} - Shrink the range boundaries to the edge of the innermost element.
                 * * {@link CKEDITOR#SHRINK_TEXT} - Shrink the range boudaries to anchor by the side of enclosed text
                 *     node, range remains if there's no text nodes on boundaries at all.
                 *
                 * @param {Boolean} selectContents Whether result range anchors at the inner OR outer boundary of the node.
                 */
                shrink: function( mode, selectContents, shrinkOnBlockBoundary ) {
                        // Unable to shrink a collapsed range.
                        if ( !this.collapsed ) {
                                mode = mode || CKEDITOR.SHRINK_TEXT;

                                var walkerRange = this.clone();

                                var startContainer = this.startContainer,
                                        endContainer = this.endContainer,
                                        startOffset = this.startOffset,
                                        endOffset = this.endOffset;

                                // Whether the start/end boundary is moveable.
                                var moveStart = 1,
                                        moveEnd = 1;

                                if ( startContainer && startContainer.type == CKEDITOR.NODE_TEXT ) {
                                        if ( !startOffset )
                                                walkerRange.setStartBefore( startContainer );
                                        else if ( startOffset >= startContainer.getLength() )
                                                walkerRange.setStartAfter( startContainer );
                                        else {
                                                // Enlarge the range properly to avoid walker making
                                                // DOM changes caused by triming the text nodes later.
                                                walkerRange.setStartBefore( startContainer );
                                                moveStart = 0;
                                        }
                                }

                                if ( endContainer && endContainer.type == CKEDITOR.NODE_TEXT ) {
                                        if ( !endOffset )
                                                walkerRange.setEndBefore( endContainer );
                                        else if ( endOffset >= endContainer.getLength() )
                                                walkerRange.setEndAfter( endContainer );
                                        else {
                                                walkerRange.setEndAfter( endContainer );
                                                moveEnd = 0;
                                        }
                                }

                                var walker = new CKEDITOR.dom.walker( walkerRange ),
                                        isBookmark = CKEDITOR.dom.walker.bookmark();

                                walker.evaluator = function( node ) {
                                        return node.type == ( mode == CKEDITOR.SHRINK_ELEMENT ? CKEDITOR.NODE_ELEMENT : CKEDITOR.NODE_TEXT );
                                };

                                var currentElement;
                                walker.guard = function( node, movingOut ) {
                                        if ( isBookmark( node ) )
                                                return true;

                                        // Stop when we're shrink in element mode while encountering a text node.
                                        if ( mode == CKEDITOR.SHRINK_ELEMENT && node.type == CKEDITOR.NODE_TEXT )
                                                return false;

                                        // Stop when we've already walked "through" an element.
                                        if ( movingOut && node.equals( currentElement ) )
                                                return false;

                                        if ( shrinkOnBlockBoundary === false && node.type == CKEDITOR.NODE_ELEMENT && node.isBlockBoundary() )
                                                return false;

                                        // Stop shrinking when encountering an editable border.
                                        if ( node.type == CKEDITOR.NODE_ELEMENT && node.hasAttribute( 'contenteditable' ) )
                                                return false;

                                        if ( !movingOut && node.type == CKEDITOR.NODE_ELEMENT )
                                                currentElement = node;

                                        return true;
                                };

                                if ( moveStart ) {
                                        var textStart = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastForward' : 'next' ]();
                                        textStart && this.setStartAt( textStart, selectContents ? CKEDITOR.POSITION_AFTER_START : CKEDITOR.POSITION_BEFORE_START );
                                }

                                if ( moveEnd ) {
                                        walker.reset();
                                        var textEnd = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastBackward' : 'previous' ]();
                                        textEnd && this.setEndAt( textEnd, selectContents ? CKEDITOR.POSITION_BEFORE_END : CKEDITOR.POSITION_AFTER_END );
                                }

                                return !!( moveStart || moveEnd );
                        }
                },

                /**
                 * Inserts a node at the start of the range. The range will be expanded
                 * the contain the node.
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                insertNode: function( node ) {
                        this.optimizeBookmark();
                        this.trim( false, true );

                        var startContainer = this.startContainer;
                        var startOffset = this.startOffset;

                        var nextNode = startContainer.getChild( startOffset );

                        if ( nextNode )
                                node.insertBefore( nextNode );
                        else
                                startContainer.append( node );

                        // Check if we need to update the end boundary.
                        if ( node.getParent() && node.getParent().equals( this.endContainer ) )
                                this.endOffset++;

                        // Expand the range to embrace the new node.
                        this.setStartBefore( node );
                },

                /**
                 * Moves the range to given position according to specified node.
                 *
                 *              // HTML: <p>Foo <b>bar</b></p>
                 *              range.moveToPosition( elB, CKEDITOR.POSITION_BEFORE_START );
                 *              // Range will be moved to: <p>Foo ^<b>bar</b></p>
                 *
                 * See also {@link #setStartAt} and {@link #setEndAt}.
                 *
                 * @param {CKEDITOR.dom.node} node The node according to which position will be set.
                 * @param {Number} position One of {@link CKEDITOR#POSITION_BEFORE_START},
                 * {@link CKEDITOR#POSITION_AFTER_START}, {@link CKEDITOR#POSITION_BEFORE_END},
                 * {@link CKEDITOR#POSITION_AFTER_END}.
                 */
                moveToPosition: function( node, position ) {
                        this.setStartAt( node, position );
                        this.collapse( true );
                },

                /**
                 * Moves the range to the exact position of the specified range.
                 *
                 * @param {CKEDITOR.dom.range} range
                 */
                moveToRange: function( range ) {
                        this.setStart( range.startContainer, range.startOffset );
                        this.setEnd( range.endContainer, range.endOffset );
                },

                /**
                 * Select nodes content. Range will start and end inside this node.
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                selectNodeContents: function( node ) {
                        this.setStart( node, 0 );
                        this.setEnd( node, node.type == CKEDITOR.NODE_TEXT ? node.getLength() : node.getChildCount() );
                },

                /**
                 * Sets the start position of a range.
                 *
                 * @param {CKEDITOR.dom.node} startNode The node to start the range.
                 * @param {Number} startOffset An integer greater than or equal to zero
                 * representing the offset for the start of the range from the start
                 * of `startNode`.
                 */
                setStart: function( startNode, startOffset ) {
                        // W3C requires a check for the new position. If it is after the end
                        // boundary, the range should be collapsed to the new start. It seams
                        // we will not need this check for our use of this class so we can
                        // ignore it for now.

                        // Fixing invalid range start inside dtd empty elements.
                        if ( startNode.type == CKEDITOR.NODE_ELEMENT && CKEDITOR.dtd.$empty[ startNode.getName() ] )
                                startOffset = startNode.getIndex(), startNode = startNode.getParent();

                        this._setStartContainer( startNode );
                        this.startOffset = startOffset;

                        if ( !this.endContainer ) {
                                this._setEndContainer( startNode );
                                this.endOffset = startOffset;
                        }

                        updateCollapsed( this );
                },

                /**
                 * Sets the end position of a Range.
                 *
                 * @param {CKEDITOR.dom.node} endNode The node to end the range.
                 * @param {Number} endOffset An integer greater than or equal to zero
                 * representing the offset for the end of the range from the start
                 * of `endNode`.
                 */
                setEnd: function( endNode, endOffset ) {
                        // W3C requires a check for the new position. If it is before the start
                        // boundary, the range should be collapsed to the new end. It seams we
                        // will not need this check for our use of this class so we can ignore
                        // it for now.

                        // Fixing invalid range end inside dtd empty elements.
                        if ( endNode.type == CKEDITOR.NODE_ELEMENT && CKEDITOR.dtd.$empty[ endNode.getName() ] )
                                endOffset = endNode.getIndex() + 1, endNode = endNode.getParent();

                        this._setEndContainer( endNode );
                        this.endOffset = endOffset;

                        if ( !this.startContainer ) {
                                this._setStartContainer( endNode );
                                this.startOffset = endOffset;
                        }

                        updateCollapsed( this );
                },

                /**
                 * Sets start of this range after the specified node.
                 *
                 *              // Range: <p>foo<b>bar</b>^</p>
                 *              range.setStartAfter( textFoo );
                 *              // The range will be changed to:
                 *              // <p>foo[<b>bar</b>]</p>
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                setStartAfter: function( node ) {
                        this.setStart( node.getParent(), node.getIndex() + 1 );
                },

                /**
                 * Sets start of this range after the specified node.
                 *
                 *              // Range: <p>foo<b>bar</b>^</p>
                 *              range.setStartBefore( elB );
                 *              // The range will be changed to:
                 *              // <p>foo[<b>bar</b>]</p>
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                setStartBefore: function( node ) {
                        this.setStart( node.getParent(), node.getIndex() );
                },

                /**
                 * Sets end of this range after the specified node.
                 *
                 *              // Range: <p>foo^<b>bar</b></p>
                 *              range.setEndAfter( elB );
                 *              // The range will be changed to:
                 *              // <p>foo[<b>bar</b>]</p>
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                setEndAfter: function( node ) {
                        this.setEnd( node.getParent(), node.getIndex() + 1 );
                },

                /**
                 * Sets end of this range before the specified node.
                 *
                 *              // Range: <p>^foo<b>bar</b></p>
                 *              range.setStartAfter( textBar );
                 *              // The range will be changed to:
                 *              // <p>[foo<b>]bar</b></p>
                 *
                 * @param {CKEDITOR.dom.node} node
                 */
                setEndBefore: function( node ) {
                        this.setEnd( node.getParent(), node.getIndex() );
                },

                /**
                 * Moves the start of this range to given position according to specified node.
                 *
                 *              // HTML: <p>Foo <b>bar</b>^</p>
                 *              range.setStartAt( elB, CKEDITOR.POSITION_AFTER_START );
                 *              // The range will be changed to:
                 *              // <p>Foo <b>[bar</b>]</p>
                 *
                 * See also {@link #setEndAt} and {@link #moveToPosition}.
                 *
                 * @param {CKEDITOR.dom.node} node The node according to which position will be set.
                 * @param {Number} position One of {@link CKEDITOR#POSITION_BEFORE_START},
                 * {@link CKEDITOR#POSITION_AFTER_START}, {@link CKEDITOR#POSITION_BEFORE_END},
                 * {@link CKEDITOR#POSITION_AFTER_END}.
                 */
                setStartAt: function( node, position ) {
                        switch ( position ) {
                                case CKEDITOR.POSITION_AFTER_START:
                                        this.setStart( node, 0 );
                                        break;

                                case CKEDITOR.POSITION_BEFORE_END:
                                        if ( node.type == CKEDITOR.NODE_TEXT )
                                                this.setStart( node, node.getLength() );
                                        else
                                                this.setStart( node, node.getChildCount() );
                                        break;

                                case CKEDITOR.POSITION_BEFORE_START:
                                        this.setStartBefore( node );
                                        break;

                                case CKEDITOR.POSITION_AFTER_END:
                                        this.setStartAfter( node );
                        }

                        updateCollapsed( this );
                },

                /**
                 * Moves the end of this range to given position according to specified node.
                 *
                 *              // HTML: <p>^Foo <b>bar</b></p>
                 *              range.setEndAt( textBar, CKEDITOR.POSITION_BEFORE_START );
                 *              // The range will be changed to:
                 *              // <p>[Foo <b>]bar</b></p>
                 *
                 * See also {@link #setStartAt} and {@link #moveToPosition}.
                 *
                 * @param {CKEDITOR.dom.node} node The node according to which position will be set.
                 * @param {Number} position One of {@link CKEDITOR#POSITION_BEFORE_START},
                 * {@link CKEDITOR#POSITION_AFTER_START}, {@link CKEDITOR#POSITION_BEFORE_END},
                 * {@link CKEDITOR#POSITION_AFTER_END}.
                 */
                setEndAt: function( node, position ) {
                        switch ( position ) {
                                case CKEDITOR.POSITION_AFTER_START:
                                        this.setEnd( node, 0 );
                                        break;

                                case CKEDITOR.POSITION_BEFORE_END:
                                        if ( node.type == CKEDITOR.NODE_TEXT )
                                                this.setEnd( node, node.getLength() );
                                        else
                                                this.setEnd( node, node.getChildCount() );
                                        break;

                                case CKEDITOR.POSITION_BEFORE_START:
                                        this.setEndBefore( node );
                                        break;

                                case CKEDITOR.POSITION_AFTER_END:
                                        this.setEndAfter( node );
                        }

                        updateCollapsed( this );
                },

                /**
                 * Wraps inline content found around the range's start or end boundary
                 * with a block element.
                 *
                 *              // Assuming the following range:
                 *              // <h1>foo</h1>ba^r<br />bom<p>foo</p>
                 *              // The result of executing:
                 *              range.fixBlock( true, 'p' );
                 *              // will be:
                 *              // <h1>foo</h1><p>ba^r<br />bom</p><p>foo</p>
                 *
                 * Non-collapsed range:
                 *
                 *              // Assuming the following range:
                 *              // ba[r<p>foo</p>bo]m
                 *              // The result of executing:
                 *              range.fixBlock( false, 'p' );
                 *              // will be:
                 *              // ba[r<p>foo</p><p>bo]m</p>
                 *
                 * @param {Boolean} isStart Whether the start or end boundary of a range should be checked.
                 * @param {String} blockTag The name of a block element in which content will be wrapped.
                 * For example: `'p'`.
                 * @returns {CKEDITOR.dom.element} Created block wrapper.
                 */
                fixBlock: function( isStart, blockTag ) {
                        var bookmark = this.createBookmark(),
                                fixedBlock = this.document.createElement( blockTag );

                        this.collapse( isStart );

                        this.enlarge( CKEDITOR.ENLARGE_BLOCK_CONTENTS );

                        this.extractContents().appendTo( fixedBlock );
                        fixedBlock.trim();

                        this.insertNode( fixedBlock );

                        // Bogus <br> could already exist in the range's container before fixBlock() was called. In such case it was
                        // extracted and appended to the fixBlock. However, we are not sure that it's at the end of
                        // the fixedBlock, because of FF's terrible bug. When creating a bookmark in an empty editable
                        // FF moves the bogus <br> before that bookmark (<editable><br /><bm />[]</editable>).
                        // So even if the initial range was placed before the bogus <br>, after creating the bookmark it
                        // is placed before the bookmark.
                        // Fortunately, getBogus() is able to skip the bookmark so it finds the bogus <br> in this case.
                        // We remove incorrectly placed one and add a brand new one. (#13001)
                        var bogus = fixedBlock.getBogus();
                        if ( bogus ) {
                                bogus.remove();
                        }
                        fixedBlock.appendBogus();

                        this.moveToBookmark( bookmark );

                        return fixedBlock;
                },

                /**
                 * @todo
                 * @param {Boolean} [cloneId=false] Whether to preserve ID attributes in the result blocks.
                 */
                splitBlock: function( blockTag, cloneId ) {
                        var startPath = new CKEDITOR.dom.elementPath( this.startContainer, this.root ),
                                endPath = new CKEDITOR.dom.elementPath( this.endContainer, this.root );

                        var startBlockLimit = startPath.blockLimit,
                                endBlockLimit = endPath.blockLimit;

                        var startBlock = startPath.block,
                                endBlock = endPath.block;

                        var elementPath = null;
                        // Do nothing if the boundaries are in different block limits.
                        if ( !startBlockLimit.equals( endBlockLimit ) )
                                return null;

                        // Get or fix current blocks.
                        if ( blockTag != 'br' ) {
                                if ( !startBlock ) {
                                        startBlock = this.fixBlock( true, blockTag );
                                        endBlock = new CKEDITOR.dom.elementPath( this.endContainer, this.root ).block;
                                }

                                if ( !endBlock )
                                        endBlock = this.fixBlock( false, blockTag );
                        }

                        // Get the range position.
                        var isStartOfBlock = startBlock && this.checkStartOfBlock(),
                                isEndOfBlock = endBlock && this.checkEndOfBlock();

                        // Delete the current contents.
                        // TODO: Why is 2.x doing CheckIsEmpty()?
                        this.deleteContents();

                        if ( startBlock && startBlock.equals( endBlock ) ) {
                                if ( isEndOfBlock ) {
                                        elementPath = new CKEDITOR.dom.elementPath( this.startContainer, this.root );
                                        this.moveToPosition( endBlock, CKEDITOR.POSITION_AFTER_END );
                                        endBlock = null;
                                } else if ( isStartOfBlock ) {
                                        elementPath = new CKEDITOR.dom.elementPath( this.startContainer, this.root );
                                        this.moveToPosition( startBlock, CKEDITOR.POSITION_BEFORE_START );
                                        startBlock = null;
                                } else {
                                        endBlock = this.splitElement( startBlock, cloneId || false );

                                        // In Gecko, the last child node must be a bogus <br>.
                                        // Note: bogus <br> added under <ul> or <ol> would cause
                                        // lists to be incorrectly rendered.
                                        if ( !startBlock.is( 'ul', 'ol' ) )
                                                startBlock.appendBogus();
                                }
                        }

                        return {
                                previousBlock: startBlock,
                                nextBlock: endBlock,
                                wasStartOfBlock: isStartOfBlock,
                                wasEndOfBlock: isEndOfBlock,
                                elementPath: elementPath
                        };
                },

                /**
                 * Branch the specified element from the collapsed range position and
                 * place the caret between the two result branches.
                 *
                 * **Note:** The range must be collapsed and been enclosed by this element.
                 *
                 * @param {CKEDITOR.dom.element} element
                 * @param {Boolean} [cloneId=false] Whether to preserve ID attributes in the result elements.
                 * @returns {CKEDITOR.dom.element} Root element of the new branch after the split.
                 */
                splitElement: function( toSplit, cloneId ) {
                        if ( !this.collapsed )
                                return null;

                        // Extract the contents of the block from the selection point to the end
                        // of its contents.
                        this.setEndAt( toSplit, CKEDITOR.POSITION_BEFORE_END );
                        var documentFragment = this.extractContents( false, cloneId || false );

                        // Duplicate the element after it.
                        var clone = toSplit.clone( false, cloneId || false );

                        // Place the extracted contents into the duplicated element.
                        documentFragment.appendTo( clone );
                        clone.insertAfter( toSplit );
                        this.moveToPosition( toSplit, CKEDITOR.POSITION_AFTER_END );
                        return clone;
                },

                /**
                 * Recursively remove any empty path blocks at the range boundary.
                 *
                 * @method
                 * @param {Boolean} atEnd Removal to perform at the end boundary,
                 * otherwise to perform at the start.
                 */
                removeEmptyBlocksAtEnd: ( function() {

                        var whitespace = CKEDITOR.dom.walker.whitespaces(),
                                        bookmark = CKEDITOR.dom.walker.bookmark( false );

                        function childEval( parent ) {
                                return function( node ) {
                                        // Whitespace, bookmarks, empty inlines.
                                        if ( whitespace( node ) || bookmark( node ) ||
                                                        node.type == CKEDITOR.NODE_ELEMENT &&
                                                        node.isEmptyInlineRemoveable() ) {
                                                return false;
                                        } else if ( parent.is( 'table' ) && node.is( 'caption' ) ) {
                                                return false;
                                        }

                                        return true;
                                };
                        }

                        return function( atEnd ) {

                                var bm = this.createBookmark();
                                var path = this[ atEnd ? 'endPath' : 'startPath' ]();
                                var block = path.block || path.blockLimit, parent;

                                // Remove any childless block, including list and table.
                                while ( block && !block.equals( path.root ) &&
                                                !block.getFirst( childEval( block ) ) ) {
                                        parent = block.getParent();
                                        this[ atEnd ? 'setEndAt' : 'setStartAt' ]( block, CKEDITOR.POSITION_AFTER_END );
                                        block.remove( 1 );
                                        block = parent;
                                }

                                this.moveToBookmark( bm );
                        };

                } )(),

                /**
                 * Gets {@link CKEDITOR.dom.elementPath} for the {@link #startContainer}.
                 *
                 * @returns {CKEDITOR.dom.elementPath}
                 */
                startPath: function() {
                        return new CKEDITOR.dom.elementPath( this.startContainer, this.root );
                },

                /**
                 * Gets {@link CKEDITOR.dom.elementPath} for the {@link #endContainer}.
                 *
                 * @returns {CKEDITOR.dom.elementPath}
                 */
                endPath: function() {
                        return new CKEDITOR.dom.elementPath( this.endContainer, this.root );
                },

                /**
                 * Check whether a range boundary is at the inner boundary of a given
                 * element.
                 *
                 * @param {CKEDITOR.dom.element} element The target element to check.
                 * @param {Number} checkType The boundary to check for both the range
                 * and the element. It can be {@link CKEDITOR#START} or {@link CKEDITOR#END}.
                 * @returns {Boolean} `true` if the range boundary is at the inner
                 * boundary of the element.
                 */
                checkBoundaryOfElement: function( element, checkType ) {
                        var checkStart = ( checkType == CKEDITOR.START );

                        // Create a copy of this range, so we can manipulate it for our checks.
                        var walkerRange = this.clone();

                        // Collapse the range at the proper size.
                        walkerRange.collapse( checkStart );

                        // Expand the range to element boundary.
                        walkerRange[ checkStart ? 'setStartAt' : 'setEndAt' ]( element, checkStart ? CKEDITOR.POSITION_AFTER_START : CKEDITOR.POSITION_BEFORE_END );

                        // Create the walker, which will check if we have anything useful
                        // in the range.
                        var walker = new CKEDITOR.dom.walker( walkerRange );
                        walker.evaluator = elementBoundaryEval( checkStart );

                        return walker[ checkStart ? 'checkBackward' : 'checkForward' ]();
                },

                /**
                 * **Note:** Calls to this function may produce changes to the DOM. The range may
                 * be updated to reflect such changes.
                 *
                 * @returns {Boolean}
                 * @todo
                 */
                checkStartOfBlock: function() {
                        var startContainer = this.startContainer,
                                startOffset = this.startOffset;

                        // [IE] Special handling for range start in text with a leading NBSP,
                        // we it to be isolated, for bogus check.
                        if ( CKEDITOR.env.ie && startOffset && startContainer.type == CKEDITOR.NODE_TEXT ) {
                                var textBefore = CKEDITOR.tools.ltrim( startContainer.substring( 0, startOffset ) );
                                if ( nbspRegExp.test( textBefore ) )
                                        this.trim( 0, 1 );
                        }

                        // Antecipate the trim() call here, so the walker will not make
                        // changes to the DOM, which would not get reflected into this
                        // range otherwise.
                        this.trim();

                        // We need to grab the block element holding the start boundary, so
                        // let's use an element path for it.
                        var path = new CKEDITOR.dom.elementPath( this.startContainer, this.root );

                        // Creates a range starting at the block start until the range start.
                        var walkerRange = this.clone();
                        walkerRange.collapse( true );
                        walkerRange.setStartAt( path.block || path.blockLimit, CKEDITOR.POSITION_AFTER_START );

                        var walker = new CKEDITOR.dom.walker( walkerRange );
                        walker.evaluator = getCheckStartEndBlockEvalFunction();

                        return walker.checkBackward();
                },

                /**
                 * **Note:** Calls to this function may produce changes to the DOM. The range may
                 * be updated to reflect such changes.
                 *
                 * @returns {Boolean}
                 * @todo
                 */
                checkEndOfBlock: function() {
                        var endContainer = this.endContainer,
                                endOffset = this.endOffset;

                        // [IE] Special handling for range end in text with a following NBSP,
                        // we it to be isolated, for bogus check.
                        if ( CKEDITOR.env.ie && endContainer.type == CKEDITOR.NODE_TEXT ) {
                                var textAfter = CKEDITOR.tools.rtrim( endContainer.substring( endOffset ) );
                                if ( nbspRegExp.test( textAfter ) )
                                        this.trim( 1, 0 );
                        }

                        // Antecipate the trim() call here, so the walker will not make
                        // changes to the DOM, which would not get reflected into this
                        // range otherwise.
                        this.trim();

                        // We need to grab the block element holding the start boundary, so
                        // let's use an element path for it.
                        var path = new CKEDITOR.dom.elementPath( this.endContainer, this.root );

                        // Creates a range starting at the block start until the range start.
                        var walkerRange = this.clone();
                        walkerRange.collapse( false );
                        walkerRange.setEndAt( path.block || path.blockLimit, CKEDITOR.POSITION_BEFORE_END );

                        var walker = new CKEDITOR.dom.walker( walkerRange );
                        walker.evaluator = getCheckStartEndBlockEvalFunction();

                        return walker.checkForward();
                },

                /**
                 * Traverse with {@link CKEDITOR.dom.walker} to retrieve the previous element before the range start.
                 *
                 * @param {Function} evaluator Function used as the walker's evaluator.
                 * @param {Function} [guard] Function used as the walker's guard.
                 * @param {CKEDITOR.dom.element} [boundary] A range ancestor element in which the traversal is limited,
                 * default to the root editable if not defined.
                 * @returns {CKEDITOR.dom.element/null} The returned node from the traversal.
                 */
                getPreviousNode: function( evaluator, guard, boundary ) {
                        var walkerRange = this.clone();
                        walkerRange.collapse( 1 );
                        walkerRange.setStartAt( boundary || this.root, CKEDITOR.POSITION_AFTER_START );

                        var walker = new CKEDITOR.dom.walker( walkerRange );
                        walker.evaluator = evaluator;
                        walker.guard = guard;
                        return walker.previous();
                },

                /**
                 * Traverse with {@link CKEDITOR.dom.walker} to retrieve the next element before the range start.
                 *
                 * @param {Function} evaluator Function used as the walker's evaluator.
                 * @param {Function} [guard] Function used as the walker's guard.
                 * @param {CKEDITOR.dom.element} [boundary] A range ancestor element in which the traversal is limited,
                 * default to the root editable if not defined.
                 * @returns {CKEDITOR.dom.element/null} The returned node from the traversal.
                 */
                getNextNode: function( evaluator, guard, boundary ) {
                        var walkerRange = this.clone();
                        walkerRange.collapse();
                        walkerRange.setEndAt( boundary || this.root, CKEDITOR.POSITION_BEFORE_END );

                        var walker = new CKEDITOR.dom.walker( walkerRange );
                        walker.evaluator = evaluator;
                        walker.guard = guard;
                        return walker.next();
                },

                /**
                 * Check if elements at which the range boundaries anchor are read-only,
                 * with respect to `contenteditable` attribute.
                 *
                 * @returns {Boolean}
                 */
                checkReadOnly: ( function() {
                        function checkNodesEditable( node, anotherEnd ) {
                                while ( node ) {
                                        if ( node.type == CKEDITOR.NODE_ELEMENT ) {
                                                if ( node.getAttribute( 'contentEditable' ) == 'false' && !node.data( 'cke-editable' ) )
                                                        return 0;

                                                // Range enclosed entirely in an editable element.
                                                else if ( node.is( 'html' ) || node.getAttribute( 'contentEditable' ) == 'true' && ( node.contains( anotherEnd ) || node.equals( anotherEnd ) ) )
                                                        break;

                                        }
                                        node = node.getParent();
                                }

                                return 1;
                        }

                        return function() {
                                var startNode = this.startContainer,
                                        endNode = this.endContainer;

                                // Check if elements path at both boundaries are editable.
                                return !( checkNodesEditable( startNode, endNode ) && checkNodesEditable( endNode, startNode ) );
                        };
                } )(),

                /**
                 * Moves the range boundaries to the first/end editing point inside an
                 * element.
                 *
                 * For example, in an element tree like
                 * `<p><b><i></i></b> Text</p>`, the start editing point is
                 * `<p><b><i>^</i></b> Text</p>` (inside `<i>`).
                 *
                 * @param {CKEDITOR.dom.element} el The element into which look for the
                 * editing spot.
                 * @param {Boolean} isMoveToEnd Whether move to the end editable position.
                 * @returns {Boolean} Whether range was moved.
                 */
                moveToElementEditablePosition: function( el, isMoveToEnd ) {

                        function nextDFS( node, childOnly ) {
                                var next;

                                if ( node.type == CKEDITOR.NODE_ELEMENT && node.isEditable( false ) )
                                        next = node[ isMoveToEnd ? 'getLast' : 'getFirst' ]( notIgnoredEval );

                                if ( !childOnly && !next )
                                        next = node[ isMoveToEnd ? 'getPrevious' : 'getNext' ]( notIgnoredEval );

                                return next;
                        }

                        // Handle non-editable element e.g. HR.
                        if ( el.type == CKEDITOR.NODE_ELEMENT && !el.isEditable( false ) ) {
                                this.moveToPosition( el, isMoveToEnd ? CKEDITOR.POSITION_AFTER_END : CKEDITOR.POSITION_BEFORE_START );
                                return true;
                        }

                        var found = 0;

                        while ( el ) {
                                // Stop immediately if we've found a text node.
                                if ( el.type == CKEDITOR.NODE_TEXT ) {
                                        // Put cursor before block filler.
                                        if ( isMoveToEnd && this.endContainer && this.checkEndOfBlock() && nbspRegExp.test( el.getText() ) )
                                                this.moveToPosition( el, CKEDITOR.POSITION_BEFORE_START );
                                        else
                                                this.moveToPosition( el, isMoveToEnd ? CKEDITOR.POSITION_AFTER_END : CKEDITOR.POSITION_BEFORE_START );
                                        found = 1;
                                        break;
                                }

                                // If an editable element is found, move inside it, but not stop the searching.
                                if ( el.type == CKEDITOR.NODE_ELEMENT ) {
                                        if ( el.isEditable() ) {
                                                this.moveToPosition( el, isMoveToEnd ? CKEDITOR.POSITION_BEFORE_END : CKEDITOR.POSITION_AFTER_START );
                                                found = 1;
                                        }
                                        // Put cursor before padding block br.
                                        else if ( isMoveToEnd && el.is( 'br' ) && this.endContainer && this.checkEndOfBlock() )
                                                this.moveToPosition( el, CKEDITOR.POSITION_BEFORE_START );
                                        // Special case - non-editable block. Select entire element, because it does not make sense
                                        // to place collapsed selection next to it, because browsers can't handle that.
                                        else if ( el.getAttribute( 'contenteditable' ) == 'false' && el.is( CKEDITOR.dtd.$block ) ) {
                                                this.setStartBefore( el );
                                                this.setEndAfter( el );
                                                return true;
                                        }
                                }

                                el = nextDFS( el, found );
                        }

                        return !!found;
                },

                /**
                 * Moves the range boundaries to the closest editing point after/before an
                 * element or the current range position (depends on whether the element was specified).
                 *
                 * For example, if the start element has `id="start"`,
                 * `<p><b>foo</b><span id="start">start</start></p>`, the closest previous editing point is
                 * `<p><b>foo</b>^<span id="start">start</start></p>` (between `<b>` and `<span>`).
                 *
                 * See also: {@link #moveToElementEditablePosition}.
                 *
                 * @since 4.3
                 * @param {CKEDITOR.dom.element} [element] The starting element. If not specified, the current range
                 * position will be used.
                 * @param {Boolean} [isMoveForward] Whether move to the end of editable. Otherwise, look back.
                 * @returns {Boolean} Whether the range was moved.
                 */
                moveToClosestEditablePosition: function( element, isMoveForward ) {
                        // We don't want to modify original range if there's no editable position.
                        var range,
                                found = 0,
                                sibling,
                                isElement,
                                positions = [ CKEDITOR.POSITION_AFTER_END, CKEDITOR.POSITION_BEFORE_START ];

                        if ( element ) {
                                // Set collapsed range at one of ends of element.
                                // Can't clone this range, because this range might not be yet positioned (no containers => errors).
                                range = new CKEDITOR.dom.range( this.root );
                                range.moveToPosition( element, positions[ isMoveForward ? 0 : 1 ] );
                        } else {
                                range = this.clone();
                        }

                        // Start element isn't a block, so we can automatically place range
                        // next to it.
                        if ( element && !element.is( CKEDITOR.dtd.$block ) )
                                found = 1;
                        else {
                                // Look for first node that fulfills eval function and place range next to it.
                                sibling = range[ isMoveForward ? 'getNextEditableNode' : 'getPreviousEditableNode' ]();
                                if ( sibling ) {
                                        found = 1;
                                        isElement = sibling.type == CKEDITOR.NODE_ELEMENT;

                                        // Special case - eval accepts block element only if it's a non-editable block,
                                        // which we want to select, not place collapsed selection next to it (which browsers
                                        // can't handle).
                                        if ( isElement && sibling.is( CKEDITOR.dtd.$block ) && sibling.getAttribute( 'contenteditable' ) == 'false' ) {
                                                range.setStartAt( sibling, CKEDITOR.POSITION_BEFORE_START );
                                                range.setEndAt( sibling, CKEDITOR.POSITION_AFTER_END );
                                        }
                                        // Handle empty blocks which can be selection containers on old IEs.
                                        else if ( !CKEDITOR.env.needsBrFiller && isElement && sibling.is( CKEDITOR.dom.walker.validEmptyBlockContainers ) ) {
                                                range.setEnd( sibling, 0 );
                                                range.collapse();
                                        } else {
                                                range.moveToPosition( sibling, positions[ isMoveForward ? 1 : 0 ] );
                                        }
                                }
                        }

                        if ( found )
                                this.moveToRange( range );

                        return !!found;
                },

                /**
                 * See {@link #moveToElementEditablePosition}.
                 *
                 * @returns {Boolean} Whether range was moved.
                 */
                moveToElementEditStart: function( target ) {
                        return this.moveToElementEditablePosition( target );
                },

                /**
                 * See {@link #moveToElementEditablePosition}.
                 *
                 * @returns {Boolean} Whether range was moved.
                 */
                moveToElementEditEnd: function( target ) {
                        return this.moveToElementEditablePosition( target, true );
                },

                /**
                 * Get the single node enclosed within the range if there's one.
                 *
                 * @returns {CKEDITOR.dom.node}
                 */
                getEnclosedNode: function() {
                        var walkerRange = this.clone();

                        // Optimize and analyze the range to avoid DOM destructive nature of walker. (#5780)
                        walkerRange.optimize();
                        if ( walkerRange.startContainer.type != CKEDITOR.NODE_ELEMENT || walkerRange.endContainer.type != CKEDITOR.NODE_ELEMENT )
                                return null;

                        var walker = new CKEDITOR.dom.walker( walkerRange ),
                                isNotBookmarks = CKEDITOR.dom.walker.bookmark( false, true ),
                                isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true );

                        walker.evaluator = function( node ) {
                                return isNotWhitespaces( node ) && isNotBookmarks( node );
                        };
                        var node = walker.next();
                        walker.reset();
                        return node && node.equals( walker.previous() ) ? node : null;
                },

                /**
                 * Get the node adjacent to the range start or {@link #startContainer}.
                 *
                 * @returns {CKEDITOR.dom.node}
                 */
                getTouchedStartNode: function() {
                        var container = this.startContainer;

                        if ( this.collapsed || container.type != CKEDITOR.NODE_ELEMENT )
                                return container;

                        return container.getChild( this.startOffset ) || container;
                },

                /**
                 * Get the node adjacent to the range end or {@link #endContainer}.
                 *
                 * @returns {CKEDITOR.dom.node}
                 */
                getTouchedEndNode: function() {
                        var container = this.endContainer;

                        if ( this.collapsed || container.type != CKEDITOR.NODE_ELEMENT )
                                return container;

                        return container.getChild( this.endOffset - 1 ) || container;
                },

                /**
                 * Gets next node which can be a container of a selection.
                 * This methods mimics a behavior of right/left arrow keys in case of
                 * collapsed selection. It does not return an exact position (with offset) though,
                 * but just a selection's container.
                 *
                 * Note: use this method on a collapsed range.
                 *
                 * @since 4.3
                 * @returns {CKEDITOR.dom.element/CKEDITOR.dom.text}
                 */
                getNextEditableNode: getNextEditableNode(),

                /**
                 * See {@link #getNextEditableNode}.
                 *
                 * @since 4.3
                 * @returns {CKEDITOR.dom.element/CKEDITOR.dom.text}
                 */
                getPreviousEditableNode: getNextEditableNode( 1 ),

                /**
                 * Scrolls the start of current range into view.
                 */
                scrollIntoView: function() {

                        // The reference element contains a zero-width space to avoid
                        // a premature removal. The view is to be scrolled with respect
                        // to this element.
                        var reference = new CKEDITOR.dom.element.createFromHtml( '<span>&nbsp;</span>', this.document ),
                                afterCaretNode, startContainerText, isStartText;

                        var range = this.clone();

                        // Work with the range to obtain a proper caret position.
                        range.optimize();

                        // Currently in a text node, so we need to split it into two
                        // halves and put the reference between.
                        if ( isStartText = range.startContainer.type == CKEDITOR.NODE_TEXT ) {
                                // Keep the original content. It will be restored.
                                startContainerText = range.startContainer.getText();

                                // Split the startContainer at the this position.
                                afterCaretNode = range.startContainer.split( range.startOffset );

                                // Insert the reference between two text nodes.
                                reference.insertAfter( range.startContainer );
                        }

                        // If not in a text node, simply insert the reference into the range.
                        else {
                                range.insertNode( reference );
                        }

                        // Scroll with respect to the reference element.
                        reference.scrollIntoView();

                        // Get rid of split parts if "in a text node" case.
                        // Revert the original text of the startContainer.
                        if ( isStartText ) {
                                range.startContainer.setText( startContainerText );
                                afterCaretNode.remove();
                        }

                        // Get rid of the reference node. It is no longer necessary.
                        reference.remove();
                },

                /**
                 * Setter for the {@link #startContainer}.
                 *
                 * @since 4.4.6
                 * @private
                 * @param {CKEDITOR.dom.element} startContainer
                 */
                _setStartContainer: function( startContainer ) {
                        // %REMOVE_START%
                        var isRootAscendantOrSelf = this.root.equals( startContainer ) || this.root.contains( startContainer );

                        if ( !isRootAscendantOrSelf ) {
                                CKEDITOR.warn( 'range-startcontainer', { startContainer: startContainer, root: this.root } );
                        }
                        // %REMOVE_END%
                        this.startContainer = startContainer;
                },

                /**
                 * Setter for the {@link #endContainer}.
                 *
                 * @since 4.4.6
                 * @private
                 * @param {CKEDITOR.dom.element} endContainer
                 */
                _setEndContainer: function( endContainer ) {
                        // %REMOVE_START%
                        var isRootAscendantOrSelf = this.root.equals( endContainer ) || this.root.contains( endContainer );

                        if ( !isRootAscendantOrSelf ) {
                                CKEDITOR.warn( 'range-endcontainer', { endContainer: endContainer, root: this.root } );
                        }
                        // %REMOVE_END%
                        this.endContainer = endContainer;
                },

                /**
                 * Looks for elements matching the `query` selector within a range.
                 *
                 * @since 4.5.11
                 * @private
                 * @param {String} query
                 * @param {Boolean} [includeNonEditables=false] Whether elements with `contenteditable` set to `false` should
                 * be included.
                 * @returns {CKEDITOR.dom.element[]}
                 */
                _find: function( query, includeNonEditables ) {
                        var ancestor = this.getCommonAncestor(),
                                boundaries = this.getBoundaryNodes(),
                                // Contrary to CKEDITOR.dom.element#find we're returning array, that's because NodeList is immutable, and we need
                                // to do some filtering in returned list.
                                ret = [],
                                curItem,
                                i,
                                initialMatches,
                                isStartGood,
                                isEndGood;

                        if ( ancestor && ancestor.find ) {
                                initialMatches = ancestor.find( query );

                                for ( i = 0; i < initialMatches.count(); i++ ) {
                                        curItem = initialMatches.getItem( i );

                                        // Using isReadOnly() method to filterout non editables. It checks isContentEditable including all browser quirks.
                                        if ( !includeNonEditables && curItem.isReadOnly() ) {
                                                continue;
                                        }

                                        // It's not enough to get elements from common ancestor, because it migth contain too many matches.
                                        // We need to ensure that returned items are between boundary points.
                                        isStartGood = ( curItem.getPosition( boundaries.startNode ) & CKEDITOR.POSITION_FOLLOWING ) || boundaries.startNode.equals( curItem );
                                        isEndGood = ( curItem.getPosition( boundaries.endNode ) & ( CKEDITOR.POSITION_PRECEDING + CKEDITOR.POSITION_IS_CONTAINED ) );

                                        if ( isStartGood && isEndGood ) {
                                                ret.push( curItem );
                                        }
                                }
                        }

                        return ret;
                }
        };


} )();

/**
 * Indicates a position after start of a node.
 *
 *              // When used according to an element:
 *              // <element>^contents</element>
 *
 *              // When used according to a text node:
 *              // "^text" (range is anchored in the text node)
 *
 * It is used as a parameter of methods like: {@link CKEDITOR.dom.range#moveToPosition},
 * {@link CKEDITOR.dom.range#setStartAt} and {@link CKEDITOR.dom.range#setEndAt}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=1]
 */
CKEDITOR.POSITION_AFTER_START = 1;

/**
 * Indicates a position before end of a node.
 *
 *              // When used according to an element:
 *              // <element>contents^</element>
 *
 *              // When used according to a text node:
 *              // "text^" (range is anchored in the text node)
 *
 * It is used as a parameter of methods like: {@link CKEDITOR.dom.range#moveToPosition},
 * {@link CKEDITOR.dom.range#setStartAt} and {@link CKEDITOR.dom.range#setEndAt}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=2]
 */
CKEDITOR.POSITION_BEFORE_END = 2;

/**
 * Indicates a position before start of a node.
 *
 *              // When used according to an element:
 *              // ^<element>contents</element> (range is anchored in element's parent)
 *
 *              // When used according to a text node:
 *              // ^"text" (range is anchored in text node's parent)
 *
 * It is used as a parameter of methods like: {@link CKEDITOR.dom.range#moveToPosition},
 * {@link CKEDITOR.dom.range#setStartAt} and {@link CKEDITOR.dom.range#setEndAt}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=3]
 */
CKEDITOR.POSITION_BEFORE_START = 3;

/**
 * Indicates a position after end of a node.
 *
 *              // When used according to an element:
 *              // <element>contents</element>^ (range is anchored in element's parent)
 *
 *              // When used according to a text node:
 *              // "text"^ (range is anchored in text node's parent)
 *
 * It is used as a parameter of methods like: {@link CKEDITOR.dom.range#moveToPosition},
 * {@link CKEDITOR.dom.range#setStartAt} and {@link CKEDITOR.dom.range#setEndAt}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=4]
 */
CKEDITOR.POSITION_AFTER_END = 4;

/**
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=1]
 */
CKEDITOR.ENLARGE_ELEMENT = 1;

/**
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=2]
 */
CKEDITOR.ENLARGE_BLOCK_CONTENTS = 2;

/**
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=3]
 */
CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS = 3;

/**
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=4]
 */
CKEDITOR.ENLARGE_INLINE = 4;

// Check boundary types.

/**
 * See {@link CKEDITOR.dom.range#checkBoundaryOfElement}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=1]
 */
CKEDITOR.START = 1;

/**
 * See {@link CKEDITOR.dom.range#checkBoundaryOfElement}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=2]
 */
CKEDITOR.END = 2;

// Shrink range types.

/**
 * See {@link CKEDITOR.dom.range#shrink}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=1]
 */
CKEDITOR.SHRINK_ELEMENT = 1;

/**
 * See {@link CKEDITOR.dom.range#shrink}.
 *
 * @readonly
 * @member CKEDITOR
 * @property {Number} [=2]
 */
CKEDITOR.SHRINK_TEXT = 2;