forge-cli 0.0.6

data/lib/forge/public/javascripts/ckeditor/_source/core/dom/rangelist.js

@@ -0,0 +1,163 @@
+/*
+Copyright (c) 2003-2010, 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,
+					bookmarks = [],
+					current;
+
+				/**
+				 * @lends CKEDITOR.dom.rangeListIterator.prototype
+				 */
+				return {
+
+					/**
+					 * Retrieves the next range in the list.
+					 */
+					getNextRange : function()
+					{
+						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 ) );
+							}
+							else
+								range.moveToBookmark( bookmarks.shift() );
+						}
+
+						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/lib/forge/public/javascripts/ckeditor/_source/core/dom/text.js

@@ -0,0 +1,123 @@
+/*
+Copyright (c) 2003-2010, 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;
+		},
+
+		/**
+		 * 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/lib/forge/public/javascripts/ckeditor/_source/core/dom/walker.js

@@ -0,0 +1,445 @@
+/*
+Copyright (c) 2003-2010, 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, true );
+			},
+
+			/**
+			 * 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, false, true ) !== 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, true, true ) !== 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, true );
+			},
+
+			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
+	},
+	blockBoundaryNodeNameMatch = { hr : 1 };
+
+	CKEDITOR.dom.element.prototype.isBlockBoundary = function( customNodeNames )
+	{
+		var nodeNameMatches = CKEDITOR.tools.extend( {},
+													blockBoundaryNodeNameMatch, customNodeNames || {} );
+
+		return 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.hasAttribute('_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;
+		};
+	};
+
+	var tailNbspRegex = /^[\t\r\n ]*(?:&nbsp;|\xa0)$/,
+		isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
+		isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true ),
+		fillerEvaluator = function( element )
+		{
+			return isNotBookmark( element ) && isNotWhitespaces( element );
+		};
+
+	// Check if there's a filler node at the end of an element, and return it.
+	CKEDITOR.dom.element.prototype.getBogus = function ()
+	{
+		var tail = this.getLast( fillerEvaluator );
+		if ( tail && ( !CKEDITOR.env.ie ? tail.is && tail.is( 'br' )
+				: tail.getText && tailNbspRegex.test( tail.getText() ) ) )
+		{
+			return tail;
+		}
+		return false;
+	};
+
+})();