esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/core/dom/rangelist.js

@@ -0,0 +1,213 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  /**
+   * Represents a list os CKEDITOR.dom.range objects, which can be easily
+   * iterated sequentially.
+   * @constructor
+   * @param {CKEDITOR.dom.range|Array} [ranges] The ranges contained on this list.
+   *    Note that, if an array of ranges is specified, the range sequence
+   *    should match its DOM order. This class will not help to sort them.
+   */
+  CKEDITOR.dom.rangeList = function( ranges )
+  {
+    if ( ranges instanceof CKEDITOR.dom.rangeList )
+      return ranges;
+
+    if ( !ranges )
+      ranges = [];
+    else if ( ranges instanceof CKEDITOR.dom.range )
+      ranges = [ ranges ];
+
+    return CKEDITOR.tools.extend( ranges, mixins );
+  };
+
+  var mixins =
+  /** @lends CKEDITOR.dom.rangeList.prototype */
+  {
+      /**
+       * Creates an instance of the rangeList iterator, it should be used
+       * only when the ranges processing could be DOM intrusive, which
+       * means it may pollute and break other ranges in this list.
+       * Otherwise, it's enough to just iterate over this array in a for loop.
+       * @returns {CKEDITOR.dom.rangeListIterator}
+       */
+      createIterator : function()
+      {
+        var rangeList = this,
+          bookmark = CKEDITOR.dom.walker.bookmark(),
+          guard = function( node ) { return ! ( node.is && node.is( 'tr' ) ); },
+            bookmarks = [],
+          current;
+
+        /**
+         * @lends CKEDITOR.dom.rangeListIterator.prototype
+         */
+        return {
+
+          /**
+           * Retrieves the next range in the list.
+           * @param {Boolean} mergeConsequent Whether join two adjacent ranges into single, e.g. consequent table cells.
+           */
+          getNextRange : function( mergeConsequent )
+          {
+            current = current == undefined ? 0 : current + 1;
+
+            var range = rangeList[ current ];
+
+            // Multiple ranges might be mangled by each other.
+            if ( range && rangeList.length > 1 )
+            {
+              // Bookmarking all other ranges on the first iteration,
+              // the range correctness after it doesn't matter since we'll
+              // restore them before the next iteration.
+              if ( !current )
+              {
+                // Make sure bookmark correctness by reverse processing.
+                for ( var i = rangeList.length - 1; i >= 0; i-- )
+                  bookmarks.unshift( rangeList[ i ].createBookmark( true ) );
+              }
+
+              if ( mergeConsequent )
+              {
+                // Figure out how many ranges should be merged.
+                var mergeCount = 0;
+                while ( rangeList[ current + mergeCount + 1 ] )
+                {
+                  var doc = range.document,
+                    found = 0,
+                    left =  doc.getById( bookmarks[ mergeCount ].endNode ),
+                    right = doc.getById( bookmarks[ mergeCount + 1 ].startNode ),
+                    next;
+
+                  // Check subsequent range.
+                  while ( 1 )
+                  {
+                    next = left.getNextSourceNode( false );
+                    if ( !right.equals( next ) )
+                    {
+                      // This could be yet another bookmark or
+                      // walking across block boundaries.
+                      if ( bookmark( next ) || ( next.type == CKEDITOR.NODE_ELEMENT && next.isBlockBoundary() ) )
+                      {
+                        left = next;
+                        continue;
+                      }
+                    }
+                    else
+                      found = 1;
+
+                    break;
+                  }
+
+                  if ( !found )
+                    break;
+
+                  mergeCount++;
+                }
+              }
+
+              range.moveToBookmark( bookmarks.shift() );
+
+              // Merge ranges finally after moving to bookmarks.
+              while( mergeCount-- )
+              {
+                next = rangeList[ ++current ];
+                next.moveToBookmark( bookmarks.shift() );
+                range.setEnd( next.endContainer, next.endOffset );
+              }
+            }
+
+            return range;
+          }
+        };
+      },
+
+      createBookmarks : function( serializable )
+      {
+        var retval = [], bookmark;
+        for ( var i = 0; i < this.length ; i++ )
+        {
+          retval.push( bookmark = this[ i ].createBookmark( serializable, true) );
+
+          // Updating the container & offset values for ranges
+          // that have been touched.
+          for ( var j = i + 1; j < this.length; j++ )
+          {
+            this[ j ] = updateDirtyRange( bookmark, this[ j ] );
+            this[ j ] = updateDirtyRange( bookmark, this[ j ], true );
+          }
+        }
+        return retval;
+      },
+
+      createBookmarks2 : function( normalized )
+      {
+        var bookmarks = [];
+
+        for ( var i = 0 ; i < this.length ; i++ )
+          bookmarks.push( this[ i ].createBookmark2( normalized ) );
+
+        return bookmarks;
+      },
+
+      /**
+       * Move each range in the list to the position specified by a list of bookmarks.
+       * @param {Array} bookmarks The list of bookmarks, each one matching a range in the list.
+       */
+      moveToBookmarks :  function( bookmarks )
+      {
+        for ( var i = 0 ; i < this.length ; i++ )
+          this[ i ].moveToBookmark( bookmarks[ i ] );
+      }
+  };
+
+  // Update the specified range which has been mangled by previous insertion of
+  // range bookmark nodes.(#3256)
+  function updateDirtyRange( bookmark, dirtyRange, checkEnd )
+  {
+    var serializable = bookmark.serializable,
+      container = dirtyRange[ checkEnd ? 'endContainer' : 'startContainer' ],
+      offset = checkEnd ? 'endOffset' : 'startOffset';
+
+    var bookmarkStart = serializable ?
+        dirtyRange.document.getById( bookmark.startNode )
+        : bookmark.startNode;
+
+    var bookmarkEnd = serializable ?
+        dirtyRange.document.getById( bookmark.endNode )
+        : bookmark.endNode;
+
+    if ( container.equals( bookmarkStart.getPrevious() ) )
+    {
+      dirtyRange.startOffset = dirtyRange.startOffset
+          - container.getLength()
+          - bookmarkEnd.getPrevious().getLength();
+      container = bookmarkEnd.getNext();
+    }
+    else if ( container.equals( bookmarkEnd.getPrevious() ) )
+    {
+      dirtyRange.startOffset = dirtyRange.startOffset - container.getLength();
+      container = bookmarkEnd.getNext();
+    }
+
+    container.equals( bookmarkStart.getParent() ) && dirtyRange[ offset ]++;
+    container.equals( bookmarkEnd.getParent() ) && dirtyRange[ offset ]++;
+
+    // Update and return this range.
+    dirtyRange[ checkEnd ? 'endContainer' : 'startContainer' ] = container;
+    return dirtyRange;
+  }
+})();
+
+/**
+ * (Virtual Class) Do not call this constructor. This class is not really part
+ *  of the API. It just describes the return type of {@link CKEDITOR.dom.rangeList#createIterator}.
+ * @name CKEDITOR.dom.rangeListIterator
+ * @constructor
+ * @example
+ */

data/app/assets/javascripts/esp-ckeditor/_source/core/dom/text.js

@@ -0,0 +1,128 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.text} class, which represents
+ *    a DOM text node.
+ */
+
+/**
+ * Represents a DOM text node.
+ * @constructor
+ * @augments CKEDITOR.dom.node
+ * @param {Object|String} text A native DOM text node or a string containing
+ *    the text to use to create a new text node.
+ * @param {CKEDITOR.dom.document} [ownerDocument] The document that will contain
+ *    the node in case of new node creation. Defaults to the current document.
+ * @example
+ * var nativeNode = document.createTextNode( 'Example' );
+ * var text = CKEDITOR.dom.text( nativeNode );
+ * @example
+ * var text = CKEDITOR.dom.text( 'Example' );
+ */
+CKEDITOR.dom.text = function( text, ownerDocument )
+{
+  if ( typeof text == 'string' )
+    text = ( ownerDocument ? ownerDocument.$ : document ).createTextNode( text );
+
+  // Theoretically, we should call the base constructor here
+  // (not CKEDITOR.dom.node though). But, IE doesn't support expando
+  // properties on text node, so the features provided by domObject will not
+  // work for text nodes (which is not a big issue for us).
+  //
+  // CKEDITOR.dom.domObject.call( this, element );
+
+  /**
+   * The native DOM text node represented by this class instance.
+   * @type Object
+   * @example
+   * var element = new CKEDITOR.dom.text( 'Example' );
+   * alert( element.$.nodeType );  // "3"
+   */
+  this.$ = text;
+};
+
+CKEDITOR.dom.text.prototype = new CKEDITOR.dom.node();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.text.prototype,
+  /** @lends CKEDITOR.dom.text.prototype */
+  {
+    /**
+     * The node type. This is a constant value set to
+     * {@link CKEDITOR.NODE_TEXT}.
+     * @type Number
+     * @example
+     */
+    type : CKEDITOR.NODE_TEXT,
+
+    getLength : function()
+    {
+      return this.$.nodeValue.length;
+    },
+
+    getText : function()
+    {
+      return this.$.nodeValue;
+    },
+
+    setText : function( text )
+    {
+      this.$.nodeValue = text;
+    },
+
+    /**
+     * Breaks this text node into two nodes at the specified offset,
+     * keeping both in the tree as siblings. This node then only contains
+     * all the content up to the offset point. A new text node, which is
+     * inserted as the next sibling of this node, contains all the content
+     * at and after the offset point. When the offset is equal to the
+     * length of this node, the new node has no data.
+     * @param {Number} The position at which to split, starting from zero.
+     * @returns {CKEDITOR.dom.text} The new text node.
+     */
+    split : function( offset )
+    {
+      // If the offset is after the last char, IE creates the text node
+      // on split, but don't include it into the DOM. So, we have to do
+      // that manually here.
+      if ( CKEDITOR.env.ie && offset == this.getLength() )
+      {
+        var next = this.getDocument().createText( '' );
+        next.insertAfter( this );
+        return next;
+      }
+
+      var doc = this.getDocument();
+      var retval = new CKEDITOR.dom.text( this.$.splitText( offset ), doc );
+
+      // IE BUG: IE8 does not update the childNodes array in DOM after splitText(),
+      // we need to make some DOM changes to make it update. (#3436)
+      if ( CKEDITOR.env.ie8 )
+      {
+        var workaround = new CKEDITOR.dom.text( '', doc );
+        workaround.insertAfter( retval );
+        workaround.remove();
+      }
+
+      return retval;
+    },
+
+    /**
+     * Extracts characters from indexA up to but not including indexB.
+     * @param {Number} indexA An integer between 0 and one less than the
+     *    length of the text.
+     * @param {Number} [indexB] An integer between 0 and the length of the
+     *    string. If omitted, extracts characters to the end of the text.
+     */
+    substring : function( indexA, indexB )
+    {
+      // We need the following check due to a Firefox bug
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=458886
+      if ( typeof indexB != 'number' )
+        return this.$.nodeValue.substr( indexA );
+      else
+        return this.$.nodeValue.substring( indexA, indexB );
+    }
+  });

data/app/assets/javascripts/esp-ckeditor/_source/core/dom/walker.js

@@ -0,0 +1,462 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  // This function is to be called under a "walker" instance scope.
+  function iterate( rtl, breakOnFalse )
+  {
+    // Return null if we have reached the end.
+    if ( this._.end )
+      return null;
+
+    var node,
+      range = this.range,
+      guard,
+      userGuard = this.guard,
+      type = this.type,
+      getSourceNodeFn = ( rtl ? 'getPreviousSourceNode' : 'getNextSourceNode' );
+
+    // This is the first call. Initialize it.
+    if ( !this._.start )
+    {
+      this._.start = 1;
+
+      // Trim text nodes and optmize the range boundaries. DOM changes
+      // may happen at this point.
+      range.trim();
+
+      // A collapsed range must return null at first call.
+      if ( range.collapsed )
+      {
+        this.end();
+        return null;
+      }
+    }
+
+    // Create the LTR guard function, if necessary.
+    if ( !rtl && !this._.guardLTR )
+    {
+      // Gets the node that stops the walker when going LTR.
+      var limitLTR = range.endContainer,
+        blockerLTR = limitLTR.getChild( range.endOffset );
+
+      this._.guardLTR = function( node, movingOut )
+      {
+        return ( ( !movingOut || !limitLTR.equals( node ) )
+          && ( !blockerLTR || !node.equals( blockerLTR ) )
+          && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || node.getName() != 'body' ) );
+      };
+    }
+
+    // Create the RTL guard function, if necessary.
+    if ( rtl && !this._.guardRTL )
+    {
+      // Gets the node that stops the walker when going LTR.
+      var limitRTL = range.startContainer,
+        blockerRTL = ( range.startOffset > 0 ) && limitRTL.getChild( range.startOffset - 1 );
+
+      this._.guardRTL = function( node, movingOut )
+      {
+        return ( ( !movingOut || !limitRTL.equals( node ) )
+          && ( !blockerRTL || !node.equals( blockerRTL ) )
+          && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || node.getName() != 'body' ) );
+      };
+    }
+
+    // Define which guard function to use.
+    var stopGuard = rtl ? this._.guardRTL : this._.guardLTR;
+
+    // Make the user defined guard function participate in the process,
+    // otherwise simply use the boundary guard.
+    if ( userGuard )
+    {
+      guard = function( node, movingOut )
+      {
+        if ( stopGuard( node, movingOut ) === false )
+          return false;
+
+        return userGuard( node, movingOut );
+      };
+    }
+    else
+      guard = stopGuard;
+
+    if ( this.current )
+      node = this.current[ getSourceNodeFn ]( false, type, guard );
+    else
+    {
+      // Get the first node to be returned.
+
+      if ( rtl )
+      {
+        node = range.endContainer;
+
+        if ( range.endOffset > 0 )
+        {
+          node = node.getChild( range.endOffset - 1 );
+          if ( guard( node ) === false )
+            node = null;
+        }
+        else
+          node = ( guard ( node, true ) === false ) ?
+            null : node.getPreviousSourceNode( true, type, guard );
+      }
+      else
+      {
+        node = range.startContainer;
+        node = node.getChild( range.startOffset );
+
+        if ( node )
+        {
+          if ( guard( node ) === false )
+            node = null;
+        }
+        else
+          node = ( guard ( range.startContainer, true ) === false ) ?
+            null : range.startContainer.getNextSourceNode( true, type, guard ) ;
+      }
+    }
+
+    while ( node && !this._.end )
+    {
+      this.current = node;
+
+      if ( !this.evaluator || this.evaluator( node ) !== false )
+      {
+        if ( !breakOnFalse )
+          return node;
+      }
+      else if ( breakOnFalse && this.evaluator )
+        return false;
+
+      node = node[ getSourceNodeFn ]( false, type, guard );
+    }
+
+    this.end();
+    return this.current = null;
+  }
+
+  function iterateToLast( rtl )
+  {
+    var node, last = null;
+
+    while ( ( node = iterate.call( this, rtl ) ) )
+      last = node;
+
+    return last;
+  }
+
+  CKEDITOR.dom.walker = CKEDITOR.tools.createClass(
+  {
+    /**
+     * Utility class to "walk" the DOM inside a range boundaries. If
+     * necessary, partially included nodes (text nodes) are broken to
+     * reflect the boundaries limits, so DOM and range changes may happen.
+     * Outside changes to the range may break the walker.
+     *
+     * The walker may return nodes that are not totaly included into the
+     * range boundaires. Let's take the following range representation,
+     * where the square brackets indicate the boundaries:
+     *
+     * [<p>Some <b>sample] text</b>
+     *
+     * While walking forward into the above range, the following nodes are
+     * returned: <p>, "Some ", <b> and "sample". Going
+     * backwards instead we have: "sample" and "Some ". So note that the
+     * walker always returns nodes when "entering" them, but not when
+     * "leaving" them. The guard function is instead called both when
+     * entering and leaving nodes.
+     *
+     * @constructor
+     * @param {CKEDITOR.dom.range} range The range within which walk.
+     */
+    $ : function( range )
+    {
+      this.range = range;
+
+      /**
+       * A function executed for every matched node, to check whether
+       * it's to be considered into the walk or not. If not provided, all
+       * matched nodes are considered good.
+       * If the function returns "false" the node is ignored.
+       * @name CKEDITOR.dom.walker.prototype.evaluator
+       * @property
+       * @type Function
+       */
+      // this.evaluator = null;
+
+      /**
+       * A function executed for every node the walk pass by to check
+       * whether the walk is to be finished. It's called when both
+       * entering and exiting nodes, as well as for the matched nodes.
+       * If this function returns "false", the walking ends and no more
+       * nodes are evaluated.
+       * @name CKEDITOR.dom.walker.prototype.guard
+       * @property
+       * @type Function
+       */
+      // this.guard = null;
+
+      /** @private */
+      this._ = {};
+    },
+
+//    statics :
+//    {
+//      /* Creates a CKEDITOR.dom.walker instance to walk inside DOM boundaries set by nodes.
+//       * @param {CKEDITOR.dom.node} startNode The node from wich the walk
+//       *    will start.
+//       * @param {CKEDITOR.dom.node} [endNode] The last node to be considered
+//       *    in the walk. No more nodes are retrieved after touching or
+//       *    passing it. If not provided, the walker stops at the
+//       *    <body> closing boundary.
+//       * @returns {CKEDITOR.dom.walker} A DOM walker for the nodes between the
+//       *    provided nodes.
+//       */
+//      createOnNodes : function( startNode, endNode, startInclusive, endInclusive )
+//      {
+//        var range = new CKEDITOR.dom.range();
+//        if ( startNode )
+//          range.setStartAt( startNode, startInclusive ? CKEDITOR.POSITION_BEFORE_START : CKEDITOR.POSITION_AFTER_END ) ;
+//        else
+//          range.setStartAt( startNode.getDocument().getBody(), CKEDITOR.POSITION_AFTER_START ) ;
+//
+//        if ( endNode )
+//          range.setEndAt( endNode, endInclusive ? CKEDITOR.POSITION_AFTER_END : CKEDITOR.POSITION_BEFORE_START ) ;
+//        else
+//          range.setEndAt( startNode.getDocument().getBody(), CKEDITOR.POSITION_BEFORE_END ) ;
+//
+//        return new CKEDITOR.dom.walker( range );
+//      }
+//    },
+//
+    proto :
+    {
+      /**
+       * Stop walking. No more nodes are retrieved if this function gets
+       * called.
+       */
+      end : function()
+      {
+        this._.end = 1;
+      },
+
+      /**
+       * Retrieves the next node (at right).
+       * @returns {CKEDITOR.dom.node} The next node or null if no more
+       *    nodes are available.
+       */
+      next : function()
+      {
+        return iterate.call( this );
+      },
+
+      /**
+       * Retrieves the previous node (at left).
+       * @returns {CKEDITOR.dom.node} The previous node or null if no more
+       *    nodes are available.
+       */
+      previous : function()
+      {
+        return iterate.call( this, 1 );
+      },
+
+      /**
+       * Check all nodes at right, executing the evaluation fuction.
+       * @returns {Boolean} "false" if the evaluator function returned
+       *    "false" for any of the matched nodes. Otherwise "true".
+       */
+      checkForward : function()
+      {
+        return iterate.call( this, 0, 1 ) !== false;
+      },
+
+      /**
+       * Check all nodes at left, executing the evaluation fuction.
+       * @returns {Boolean} "false" if the evaluator function returned
+       *    "false" for any of the matched nodes. Otherwise "true".
+       */
+      checkBackward : function()
+      {
+        return iterate.call( this, 1, 1 ) !== false;
+      },
+
+      /**
+       * Executes a full walk forward (to the right), until no more nodes
+       * are available, returning the last valid node.
+       * @returns {CKEDITOR.dom.node} The last node at the right or null
+       *    if no valid nodes are available.
+       */
+      lastForward : function()
+      {
+        return iterateToLast.call( this );
+      },
+
+      /**
+       * Executes a full walk backwards (to the left), until no more nodes
+       * are available, returning the last valid node.
+       * @returns {CKEDITOR.dom.node} The last node at the left or null
+       *    if no valid nodes are available.
+       */
+      lastBackward : function()
+      {
+        return iterateToLast.call( this, 1 );
+      },
+
+      reset : function()
+      {
+        delete this.current;
+        this._ = {};
+      }
+
+    }
+  });
+
+  /*
+   * Anything whose display computed style is block, list-item, table,
+   * table-row-group, table-header-group, table-footer-group, table-row,
+   * table-column-group, table-column, table-cell, table-caption, or whose node
+   * name is hr, br (when enterMode is br only) is a block boundary.
+   */
+  var blockBoundaryDisplayMatch =
+  {
+    block : 1,
+    'list-item' : 1,
+    table : 1,
+    'table-row-group' : 1,
+    'table-header-group' : 1,
+    'table-footer-group' : 1,
+    'table-row' : 1,
+    'table-column-group' : 1,
+    'table-column' : 1,
+    'table-cell' : 1,
+    'table-caption' : 1
+  };
+
+  CKEDITOR.dom.element.prototype.isBlockBoundary = function( customNodeNames )
+  {
+    var nodeNameMatches = customNodeNames ?
+      CKEDITOR.tools.extend( {}, CKEDITOR.dtd.$block, customNodeNames || {} ) :
+      CKEDITOR.dtd.$block;
+
+    // Don't consider floated formatting as block boundary, fall back to dtd check in that case. (#6297)
+    return this.getComputedStyle( 'float' ) == 'none' && blockBoundaryDisplayMatch[ this.getComputedStyle( 'display' ) ]
+        || nodeNameMatches[ this.getName() ];
+  };
+
+  CKEDITOR.dom.walker.blockBoundary = function( customNodeNames )
+  {
+    return function( node , type )
+    {
+      return ! ( node.type == CKEDITOR.NODE_ELEMENT
+            && node.isBlockBoundary( customNodeNames ) );
+    };
+  };
+
+  CKEDITOR.dom.walker.listItemBoundary = function()
+  {
+      return this.blockBoundary( { br : 1 } );
+  };
+
+  /**
+   * Whether the to-be-evaluated node is a bookmark node OR bookmark node
+   * inner contents.
+   * @param {Boolean} contentOnly Whether only test againt the text content of
+   * bookmark node instead of the element itself(default).
+   * @param {Boolean} isReject Whether should return 'false' for the bookmark
+   * node instead of 'true'(default).
+   */
+  CKEDITOR.dom.walker.bookmark = function( contentOnly, isReject )
+  {
+    function isBookmarkNode( node )
+    {
+      return ( node && node.getName
+          && node.getName() == 'span'
+          && node.data( 'cke-bookmark' ) );
+    }
+
+    return function( node )
+    {
+      var isBookmark, parent;
+      // Is bookmark inner text node?
+      isBookmark = ( node && !node.getName && ( parent = node.getParent() )
+            && isBookmarkNode( parent ) );
+      // Is bookmark node?
+      isBookmark = contentOnly ? isBookmark : isBookmark || isBookmarkNode( node );
+      return !! ( isReject ^ isBookmark );
+    };
+  };
+
+  /**
+   * Whether the node is a text node containing only whitespaces characters.
+   * @param isReject
+   */
+  CKEDITOR.dom.walker.whitespaces = function( isReject )
+  {
+    return function( node )
+    {
+      var isWhitespace = node && ( node.type == CKEDITOR.NODE_TEXT )
+              && !CKEDITOR.tools.trim( node.getText() );
+      return !! ( isReject ^ isWhitespace );
+    };
+  };
+
+  /**
+   * Whether the node is invisible in wysiwyg mode.
+   * @param isReject
+   */
+  CKEDITOR.dom.walker.invisible = function( isReject )
+  {
+    var whitespace = CKEDITOR.dom.walker.whitespaces();
+    return function( node )
+    {
+      // Nodes that take no spaces in wysiwyg:
+      // 1. White-spaces but not including NBSP;
+      // 2. Empty inline elements, e.g. <b></b> we're checking here
+      // 'offsetHeight' instead of 'offsetWidth' for properly excluding
+      // all sorts of empty paragraph, e.g. <br />.
+      var isInvisible = whitespace( node ) || node.is && !node.$.offsetHeight;
+      return !! ( isReject ^ isInvisible );
+    };
+  };
+
+  CKEDITOR.dom.walker.nodeType = function( type, isReject )
+  {
+    return function( node )
+    {
+      return !! ( isReject ^ ( node.type == type ) );
+    };
+  };
+
+  var tailNbspRegex = /^[\t\r\n ]*(?:&nbsp;|\xa0)$/,
+    isWhitespaces = CKEDITOR.dom.walker.whitespaces(),
+    isBookmark = CKEDITOR.dom.walker.bookmark(),
+    toSkip = function( node )
+    {
+      return isBookmark( node )
+          || isWhitespaces( node )
+          || node.type == CKEDITOR.NODE_ELEMENT
+          && node.getName() in CKEDITOR.dtd.$inline
+          && !( node.getName() in CKEDITOR.dtd.$empty );
+    };
+
+  // Check if there's a filler node at the end of an element, and return it.
+  CKEDITOR.dom.element.prototype.getBogus = function()
+  {
+    // Bogus are not always at the end, e.g. <p><a>text<br /></a></p> (#7070).
+    var tail = this;
+    do { tail = tail.getPreviousSourceNode(); }
+    while ( toSkip( tail ) )
+
+    if ( tail && ( !CKEDITOR.env.ie ? tail.is && tail.is( 'br' )
+        : tail.getText && tailNbspRegex.test( tail.getText() ) ) )
+    {
+      return tail;
+    }
+    return false;
+  };
+
+})();