diff --git a/lam/templates/lib/extra/ckeditor/core/creators/inline.js b/lam/templates/lib/extra/ckeditor/core/creators/inline.js
new file mode 100644
index 00000000..ccee992e
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/creators/inline.js
@@ -0,0 +1,153 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	/** @class CKEDITOR */
+
+	/**
+	 * Turns a DOM element with `contenteditable` attribute set to `true` into a
+	 * CKEditor instance. Check {@link CKEDITOR.dtd#$editable} for the list of
+	 * allowed element names.
+	 *
+	 *		<div contenteditable="true" id="content">...</div>
+	 *		...
+	 *		CKEDITOR.inline( 'content' );
+	 *
+	 * It is also possible to create an inline editor from the `<textarea>` element.
+	 * If you do so, an additional `<div>` element with editable content will be created
+	 * directly after the `<textarea>` element and the `<textarea>` element will be hidden.
+	 *
+	 * @param {Object/String} element The DOM element or its ID.
+	 * @param {Object} [instanceConfig] The specific configurations to apply to this editor instance.
+	 * See {@link CKEDITOR.config}.
+	 * @returns {CKEDITOR.editor} The editor instance created.
+	 */
+	CKEDITOR.inline = function( element, instanceConfig ) {
+		if ( !CKEDITOR.env.isCompatible )
+			return null;
+
+		element = CKEDITOR.dom.element.get( element );
+
+		// Avoid multiple inline editor instances on the same element.
+		if ( element.getEditor() )
+			throw 'The editor instance "' + element.getEditor().name + '" is already attached to the provided element.';
+
+		var editor = new CKEDITOR.editor( instanceConfig, element, CKEDITOR.ELEMENT_MODE_INLINE ),
+			textarea = element.is( 'textarea' ) ? element : null;
+
+		if ( textarea ) {
+			editor.setData( textarea.getValue(), null, true );
+
+			//Change element from textarea to div
+			element = CKEDITOR.dom.element.createFromHtml(
+				'<div contenteditable="' + !!editor.readOnly + '" class="cke_textarea_inline">' +
+					textarea.getValue() +
+				'</div>',
+				CKEDITOR.document );
+
+			element.insertAfter( textarea );
+			textarea.hide();
+
+			// Attaching the concrete form.
+			if ( textarea.$.form )
+				editor._attachToForm();
+		} else {
+			// Initial editor data is simply loaded from the page element content to make
+			// data retrieval possible immediately after the editor creation.
+			editor.setData( element.getHtml(), null, true );
+		}
+
+		// Once the editor is loaded, start the UI.
+		editor.on( 'loaded', function() {
+			editor.fire( 'uiReady' );
+
+			// Enable editing on the element.
+			editor.editable( element );
+
+			// Editable itself is the outermost element.
+			editor.container = element;
+
+			// Load and process editor data.
+			editor.setData( editor.getData( 1 ) );
+
+			// Clean on startup.
+			editor.resetDirty();
+
+			editor.fire( 'contentDom' );
+
+			// Inline editing defaults to "wysiwyg" mode, so plugins don't
+			// need to make special handling for this "mode-less" environment.
+			editor.mode = 'wysiwyg';
+			editor.fire( 'mode' );
+
+			// The editor is completely loaded for interaction.
+			editor.status = 'ready';
+			editor.fireOnce( 'instanceReady' );
+			CKEDITOR.fire( 'instanceReady', null, editor );
+
+			// give priority to plugins that relay on editor#loaded for bootstrapping.
+		}, null, null, 10000 );
+
+		// Handle editor destroying.
+		editor.on( 'destroy', function() {
+			// Remove container from DOM if inline-textarea editor.
+			// Show <textarea> back again.
+			if ( textarea ) {
+				editor.container.clearCustomData();
+				editor.container.remove();
+				textarea.show();
+			}
+
+			editor.element.clearCustomData();
+
+			delete editor.element;
+		} );
+
+		return editor;
+	};
+
+	/**
+	 * Calls {@link CKEDITOR#inline} for all page elements with
+	 * `contenteditable` attribute set to `true`.
+	 *
+	 */
+	CKEDITOR.inlineAll = function() {
+		var el, data;
+
+		for ( var name in CKEDITOR.dtd.$editable ) {
+			var elements = CKEDITOR.document.getElementsByTag( name );
+
+			for ( var i = 0, len = elements.count(); i < len; i++ ) {
+				el = elements.getItem( i );
+
+				if ( el.getAttribute( 'contenteditable' ) == 'true' ) {
+					// Fire the "inline" event, making it possible to customize
+					// the instance settings and eventually cancel the creation.
+
+					data = {
+						element: el,
+						config: {}
+					};
+
+					if ( CKEDITOR.fire( 'inline', data ) !== false )
+						CKEDITOR.inline( el, data.config );
+				}
+			}
+		}
+	};
+
+	CKEDITOR.domReady( function() {
+		!CKEDITOR.disableAutoInline && CKEDITOR.inlineAll();
+	} );
+} )();
+
+/**
+ * Disables creating the inline editor automatically for elements with
+ * `contenteditable` attribute set to the `true`.
+ *
+ *		CKEDITOR.disableAutoInline = true;
+ *
+ * @cfg {Boolean} [disableAutoInline=false]
+ */
diff --git a/lam/templates/lib/extra/ckeditor/core/creators/themedui.js b/lam/templates/lib/extra/ckeditor/core/creators/themedui.js
new file mode 100644
index 00000000..8c2a04a9
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/creators/themedui.js
@@ -0,0 +1,457 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+ /** @class CKEDITOR */
+
+/**
+ * The class name used to identify `<textarea>` elements to be replaced
+ * by CKEditor instances. Set it to empty/`null` to disable this feature.
+ *
+ *		CKEDITOR.replaceClass = 'rich_editor';
+ *
+ * @cfg {String} [replaceClass='ckeditor']
+ */
+CKEDITOR.replaceClass = 'ckeditor';
+
+( function() {
+	/**
+	 * Replaces a `<textarea>` or a DOM element (`<div>`) with a CKEditor
+	 * instance. For textareas, the initial value in the editor will be the
+	 * textarea value. For DOM elements, their `innerHTML` will be used
+	 * instead. We recommend using `<textarea>` and `<div>` elements only.
+	 *
+	 *		<textarea id="myfield" name="myfield"></textarea>
+	 *		...
+	 *		CKEDITOR.replace( 'myfield' );
+	 *
+	 *		var textarea = document.body.appendChild( document.createElement( 'textarea' ) );
+	 *		CKEDITOR.replace( textarea );
+	 *
+	 * @param {Object/String} element The DOM element (textarea), its ID, or name.
+	 * @param {Object} [config] The specific configuration to apply to this
+	 * editor instance. Configuration set here will override the global CKEditor settings
+	 * (see {@link CKEDITOR.config}).
+	 * @returns {CKEDITOR.editor} The editor instance created.
+	 */
+	CKEDITOR.replace = function( element, config ) {
+		return createInstance( element, config, null, CKEDITOR.ELEMENT_MODE_REPLACE );
+	};
+
+	/**
+	 * Creates a new editor instance at the end of a specific DOM element.
+	 *
+	 *		<div id="editorSpace"></div>
+	 *		...
+	 *		CKEDITOR.appendTo( 'editorSpace' );
+	 *
+	 * @param {Object/String} element The DOM element, its ID, or name.
+	 * @param {Object} [config] The specific configuration to apply to this
+	 * editor instance. Configuration set here will override the global CKEditor settings
+	 * (see {@link CKEDITOR.config}).
+	 * @param {String} [data] Since 3.3. Initial value for the instance.
+	 * @returns {CKEDITOR.editor} The editor instance created.
+	 */
+	CKEDITOR.appendTo = function( element, config, data )
+	{
+		return createInstance( element, config, data, CKEDITOR.ELEMENT_MODE_APPENDTO );
+	};
+
+	/**
+	 * Replaces all `<textarea>` elements available in the document with
+	 * editor instances.
+	 *
+	 *		// Replace all <textarea> elements in the page.
+	 *		CKEDITOR.replaceAll();
+	 *
+	 *		// Replace all <textarea class="myClassName"> elements in the page.
+	 *		CKEDITOR.replaceAll( 'myClassName' );
+	 *
+	 *		// Selectively replace <textarea> elements, based on custom assertions.
+	 *		CKEDITOR.replaceAll( function( textarea, config ) {
+	 *			// An assertion function that needs to be evaluated for the <textarea>
+	 *			// to be replaced. It must explicitely return "false" to ignore a
+	 *			// specific <textarea>.
+	 *			// You can also customize the editor instance by having the function
+	 *			// modify the "config" parameter.
+	 *		} );
+	 *
+	 * @param {String} [className] The `<textarea>` class name.
+	 * @param {Function} [function] An assertion function that must return `true` for a `<textarea>`
+	 * to be replaced with the editor. If the function returns `false`, the `<textarea>` element
+	 * will not be replaced.
+	 */
+	CKEDITOR.replaceAll = function() {
+		var textareas = document.getElementsByTagName( 'textarea' );
+
+		for ( var i = 0; i < textareas.length; i++ ) {
+			var config = null,
+				textarea = textareas[ i ];
+
+			// The "name" and/or "id" attribute must exist.
+			if ( !textarea.name && !textarea.id )
+				continue;
+
+			if ( typeof arguments[ 0 ] == 'string' ) {
+				// The textarea class name could be passed as the function
+				// parameter.
+
+				var classRegex = new RegExp( '(?:^|\\s)' + arguments[ 0 ] + '(?:$|\\s)' );
+
+				if ( !classRegex.test( textarea.className ) )
+					continue;
+			} else if ( typeof arguments[ 0 ] == 'function' ) {
+				// An assertion function could be passed as the function parameter.
+				// It must explicitly return "false" to ignore a specific <textarea>.
+				config = {};
+				if ( arguments[ 0 ]( textarea, config ) === false )
+					continue;
+			}
+
+			this.replace( textarea, config );
+		}
+	};
+
+	/** @class CKEDITOR.editor */
+
+	/**
+	 * Registers an editing mode. This function is to be used mainly by plugins.
+	 *
+	 * @param {String} mode The mode name.
+	 * @param {Function} exec The function that performs the actual mode change.
+	 */
+	CKEDITOR.editor.prototype.addMode = function( mode, exec ) {
+		( this._.modes || ( this._.modes = {} ) )[ mode ] = exec;
+	};
+
+	/**
+	 * Changes the editing mode of this editor instance.
+	 *
+	 * **Note:** The mode switch could be asynchronous depending on the mode provider.
+	 * Use the `callback` to hook subsequent code.
+	 *
+	 *		// Switch to "source" view.
+	 *		CKEDITOR.instances.editor1.setMode( 'source' );
+	 *		// Switch to "wysiwyg" view and be notified on completion.
+	 *		CKEDITOR.instances.editor1.setMode( 'wysiwyg', function() { alert( 'wysiwyg mode loaded!' ); } );
+	 *
+	 * @param {String} [newMode] If not specified, the {@link CKEDITOR.config#startupMode} will be used.
+	 * @param {Function} [callback] Optional callback function which is invoked once the mode switch has succeeded.
+	 */
+	CKEDITOR.editor.prototype.setMode = function( newMode, callback ) {
+		var editor = this;
+
+		var modes = this._.modes;
+
+		// Mode loading quickly fails.
+		if ( newMode == editor.mode || !modes || !modes[ newMode ] )
+			return;
+
+		editor.fire( 'beforeSetMode', newMode );
+
+		if ( editor.mode ) {
+			var isDirty = editor.checkDirty();
+
+			editor._.previousMode = editor.mode;
+
+			editor.fire( 'beforeModeUnload' );
+
+			// Detach the current editable.
+			editor.editable( 0 );
+
+			// Clear up the mode space.
+			editor.ui.space( 'contents' ).setHtml( '' );
+
+			editor.mode = '';
+		}
+
+		// Fire the mode handler.
+		this._.modes[ newMode ]( function() {
+			// Set the current mode.
+			editor.mode = newMode;
+
+			if ( isDirty !== undefined )
+				!isDirty && editor.resetDirty();
+
+			// Delay to avoid race conditions (setMode inside setMode).
+			setTimeout( function() {
+				editor.fire( 'mode' );
+				callback && callback.call( editor );
+			}, 0 );
+		} );
+	};
+
+	/**
+	 * Resizes the editor interface.
+	 *
+	 *		editor.resize( 900, 300 );
+	 *
+	 *		editor.resize( '100%', 450, true );
+	 *
+	 * @param {Number/String} width The new width. It can be an integer denoting a value
+	 * in pixels or a CSS size value with unit.
+	 * @param {Number/String} height The new height. It can be an integer denoting a value
+	 * in pixels or a CSS size value with unit.
+	 * @param {Boolean} [isContentHeight] Indicates that the provided height is to
+	 * be applied to the editor content area, and not to the entire editor
+	 * interface. Defaults to `false`.
+	 * @param {Boolean} [resizeInner] Indicates that it is the inner interface
+	 * element that must be resized, not the outer element. The default theme
+	 * defines the editor interface inside a pair of `<span>` elements
+	 * (`<span><span>...</span></span>`). By default the first,
+	 * outer `<span>` element receives the sizes. If this parameter is set to
+	 * `true`, the second, inner `<span>` is resized instead.
+	 */
+	CKEDITOR.editor.prototype.resize = function( width, height, isContentHeight, resizeInner ) {
+		var container = this.container,
+			contents = this.ui.space( 'contents' ),
+			contentsFrame = CKEDITOR.env.webkit && this.document && this.document.getWindow().$.frameElement,
+			outer = resizeInner ? container.getChild( 1 ) : container;
+
+		// Set as border box width. (#5353)
+		outer.setSize( 'width', width, true );
+
+		// WebKit needs to refresh the iframe size to avoid rendering issues. (1/2) (#8348)
+		contentsFrame && ( contentsFrame.style.width = '1%' );
+
+		// Get the height delta between the outer table and the content area.
+		// If we're setting the content area's height, then we don't need the delta.
+		var delta = isContentHeight ? 0 : ( outer.$.offsetHeight || 0 ) - ( contents.$.clientHeight || 0 );
+		contents.setStyle( 'height', Math.max( height - delta, 0 ) + 'px' );
+
+		// WebKit needs to refresh the iframe size to avoid rendering issues. (2/2) (#8348)
+		contentsFrame && ( contentsFrame.style.width = '100%' );
+
+		// Emit a resize event.
+		this.fire( 'resize' );
+	};
+
+	/**
+	 * Gets the element that can be used to check the editor size. This method
+	 * is mainly used by the `resize` plugin, which adds a UI handle that can be used
+	 * to resize the editor.
+	 *
+	 * @param {Boolean} forContents Whether to return the "contents" part of the theme instead of the container.
+	 * @returns {CKEDITOR.dom.element} The resizable element.
+	 */
+	CKEDITOR.editor.prototype.getResizable = function( forContents ) {
+		return forContents ? this.ui.space( 'contents' ) : this.container;
+	};
+
+	function createInstance( element, config, data, mode ) {
+		if ( !CKEDITOR.env.isCompatible )
+			return null;
+
+		element = CKEDITOR.dom.element.get( element );
+
+		// Avoid multiple inline editor instances on the same element.
+		if ( element.getEditor() )
+			throw 'The editor instance "' + element.getEditor().name + '" is already attached to the provided element.';
+
+		// Create the editor instance.
+		var editor = new CKEDITOR.editor( config, element, mode );
+
+		if ( mode == CKEDITOR.ELEMENT_MODE_REPLACE ) {
+			// Do not replace the textarea right now, just hide it. The effective
+			// replacement will be done later in the editor creation lifecycle.
+			element.setStyle( 'visibility', 'hidden' );
+
+			// #8031 Remember if textarea was required and remove the attribute.
+			editor._.required = element.hasAttribute( 'required' );
+			element.removeAttribute( 'required' );
+		}
+
+		data && editor.setData( data, null, true );
+
+		// Once the editor is loaded, start the UI.
+		editor.on( 'loaded', function() {
+			loadTheme( editor );
+
+			if ( mode == CKEDITOR.ELEMENT_MODE_REPLACE && editor.config.autoUpdateElement && element.$.form )
+				editor._attachToForm();
+
+			editor.setMode( editor.config.startupMode, function() {
+				// Clean on startup.
+				editor.resetDirty();
+
+				// Editor is completely loaded for interaction.
+				editor.status = 'ready';
+				editor.fireOnce( 'instanceReady' );
+				CKEDITOR.fire( 'instanceReady', null, editor );
+			} );
+		} );
+
+		editor.on( 'destroy', destroy );
+		return editor;
+	}
+
+	function destroy() {
+		var editor = this,
+			container = editor.container,
+			element = editor.element;
+
+		if ( container ) {
+			container.clearCustomData();
+			container.remove();
+		}
+
+		if ( element ) {
+			element.clearCustomData();
+			if ( editor.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE ) {
+				element.show();
+				if ( editor._.required )
+					element.setAttribute( 'required', 'required' );
+			}
+			delete editor.element;
+		}
+	}
+
+	var themedTpl;
+
+	function loadTheme( editor ) {
+		var name = editor.name,
+			element = editor.element,
+			elementMode = editor.elementMode;
+
+		// Get the HTML for the predefined spaces.
+		var topHtml = editor.fire( 'uiSpace', { space: 'top', html: '' } ).html;
+		var bottomHtml = editor.fire( 'uiSpace', { space: 'bottom', html: '' } ).html;
+
+		if ( !themedTpl ) {
+			themedTpl = CKEDITOR.addTemplate( 'maincontainer', '<{outerEl}' +
+				' id="cke_{name}"' +
+				' class="{id} cke cke_reset cke_chrome cke_editor_{name} cke_{langDir} ' + CKEDITOR.env.cssClass + '" ' +
+				' dir="{langDir}"' +
+				' lang="{langCode}"' +
+				' role="application"' +
+				' aria-labelledby="cke_{name}_arialbl">' +
+				'<span id="cke_{name}_arialbl" class="cke_voice_label">{voiceLabel}</span>' +
+					'<{outerEl} class="cke_inner cke_reset" role="presentation">' +
+						'{topHtml}' +
+						'<{outerEl} id="{contentId}" class="cke_contents cke_reset" role="presentation"></{outerEl}>' +
+						'{bottomHtml}' +
+					'</{outerEl}>' +
+				'</{outerEl}>' );
+		}
+
+		var container = CKEDITOR.dom.element.createFromHtml( themedTpl.output( {
+			id: editor.id,
+			name: name,
+			langDir: editor.lang.dir,
+			langCode: editor.langCode,
+			voiceLabel: [ editor.lang.editor, editor.name ].join( ', ' ),
+			topHtml: topHtml ? '<span id="' + editor.ui.spaceId( 'top' ) + '" class="cke_top cke_reset_all" role="presentation" style="height:auto">' + topHtml + '</span>' : '',
+			contentId: editor.ui.spaceId( 'contents' ),
+			bottomHtml: bottomHtml ? '<span id="' + editor.ui.spaceId( 'bottom' ) + '" class="cke_bottom cke_reset_all" role="presentation">' + bottomHtml + '</span>' : '',
+			outerEl: CKEDITOR.env.ie ? 'span' : 'div'	// #9571
+		} ) );
+
+		if ( elementMode == CKEDITOR.ELEMENT_MODE_REPLACE ) {
+			element.hide();
+			container.insertAfter( element );
+		} else
+			element.append( container );
+
+		editor.container = container;
+
+		// Make top and bottom spaces unelectable, but not content space,
+		// otherwise the editable area would be affected.
+		topHtml && editor.ui.space( 'top' ).unselectable();
+		bottomHtml && editor.ui.space( 'bottom' ).unselectable();
+
+		var width = editor.config.width, height = editor.config.height;
+		if ( width )
+			container.setStyle( 'width', CKEDITOR.tools.cssLength( width ) );
+
+		// The editor height is applied to the contents space.
+		if ( height )
+			editor.ui.space( 'contents' ).setStyle( 'height', CKEDITOR.tools.cssLength( height ) );
+
+		// Disable browser context menu for editor's chrome.
+		container.disableContextMenu();
+
+		// Redirect the focus into editor for webkit. (#5713)
+		CKEDITOR.env.webkit && container.on( 'focus', function() {
+			editor.focus();
+		} );
+
+		editor.fireOnce( 'uiReady' );
+	}
+
+	// Replace all textareas with the default class name.
+	CKEDITOR.domReady( function() {
+		CKEDITOR.replaceClass && CKEDITOR.replaceAll( CKEDITOR.replaceClass );
+	} );
+} )();
+
+/**
+ * The current editing mode. An editing mode basically provides
+ * different ways of editing or viewing the contents.
+ *
+ *		alert( CKEDITOR.instances.editor1.mode ); // (e.g.) 'wysiwyg'
+ *
+ * @readonly
+ * @property {String} mode
+ */
+
+/**
+ * The mode to load at the editor startup. It depends on the plugins
+ * loaded. By default, the `wysiwyg` and `source` modes are available.
+ *
+ *		config.startupMode = 'source';
+ *
+ * @cfg {String} [startupMode='wysiwyg']
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.startupMode = 'wysiwyg';
+
+/**
+ * Fired after the editor instance is resized through
+ * the {@link CKEDITOR.editor#method-resize CKEDITOR.resize} method.
+ *
+ * @event resize
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
+
+/**
+ * Fired before changing the editing mode. See also
+ * {@link #beforeSetMode} and {@link #event-mode}.
+ *
+ * @event beforeModeUnload
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
+
+/**
+ * Fired before the editor mode is set. See also
+ * {@link #event-mode} and {@link #beforeModeUnload}.
+ *
+ * @since 3.5.3
+ * @event beforeSetMode
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {String} data The name of the mode which is about to be set.
+ */
+
+/**
+ * Fired after setting the editing mode. See also {@link #beforeSetMode} and {@link #beforeModeUnload}
+ *
+ * @event mode
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
+
+/**
+ * Fired when the editor (replacing a `<textarea>` which has a `required` attribute) is empty during form submission.
+ *
+ * This event replaces native required fields validation that the browsers cannot
+ * perform when CKEditor replaces `<textarea>` elements.
+ *
+ * You can cancel this event to prevent the page from submitting data.
+ *
+ *		editor.on( 'required', function( evt ) {
+ *			alert( 'Article content is required.' );
+ *			evt.cancel();
+ *		} );
+ *
+ * @event required
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/comment.js b/lam/templates/lib/extra/ckeditor/core/dom/comment.js
new file mode 100644
index 00000000..d772265b
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/comment.js
@@ -0,0 +1,53 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.comment} class, which represents
+ *		a DOM comment node.
+ */
+
+/**
+ * Represents a DOM comment node.
+ *
+ *		var nativeNode = document.createComment( 'Example' );
+ *		var comment = new CKEDITOR.dom.comment( nativeNode );
+ *
+ *		var comment = new CKEDITOR.dom.comment( 'Example' );
+ *
+ * @class
+ * @extends CKEDITOR.dom.node
+ * @constructor Creates a comment class instance.
+ * @param {Object/String} comment A native DOM comment node or a string containing
+ * the text to use to create a new comment node.
+ * @param {CKEDITOR.dom.document} [ownerDocument] The document that will contain
+ * the node in case of new node creation. Defaults to the current document.
+ */
+CKEDITOR.dom.comment = function( comment, ownerDocument ) {
+	if ( typeof comment == 'string' )
+		comment = ( ownerDocument ? ownerDocument.$ : document ).createComment( comment );
+
+	CKEDITOR.dom.domObject.call( this, comment );
+};
+
+CKEDITOR.dom.comment.prototype = new CKEDITOR.dom.node();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.comment.prototype, {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_COMMENT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_COMMENT]
+	 */
+	type: CKEDITOR.NODE_COMMENT,
+
+	/**
+	 * Gets the outer HTML of this comment.
+	 *
+	 * @returns {String} The HTML `<!-- comment value -->`.
+	 */
+	getOuterHtml: function() {
+		return '<!--' + this.$.nodeValue + '-->';
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/document.js b/lam/templates/lib/extra/ckeditor/core/dom/document.js
new file mode 100644
index 00000000..7645c194
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/document.js
@@ -0,0 +1,316 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.document} class, which
+ *		represents a DOM document.
+ */
+
+/**
+ * Represents a DOM document.
+ *
+ *		var document = new CKEDITOR.dom.document( document );
+ *
+ * @class
+ * @extends CKEDITOR.dom.domObject
+ * @constructor Creates a document class instance.
+ * @param {Object} domDocument A native DOM document.
+ */
+CKEDITOR.dom.document = function( domDocument ) {
+	CKEDITOR.dom.domObject.call( this, domDocument );
+};
+
+// PACKAGER_RENAME( CKEDITOR.dom.document )
+
+CKEDITOR.dom.document.prototype = new CKEDITOR.dom.domObject();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.document.prototype, {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_DOCUMENT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_DOCUMENT]
+	 */
+	type: CKEDITOR.NODE_DOCUMENT,
+
+	/**
+	 * Appends a CSS file to the document.
+	 *
+	 *		CKEDITOR.document.appendStyleSheet( '/mystyles.css' );
+	 *
+	 * @param {String} cssFileUrl The CSS file URL.
+	 */
+	appendStyleSheet: function( cssFileUrl ) {
+		if ( this.$.createStyleSheet )
+			this.$.createStyleSheet( cssFileUrl );
+		else {
+			var link = new CKEDITOR.dom.element( 'link' );
+			link.setAttributes( {
+				rel: 'stylesheet',
+				type: 'text/css',
+				href: cssFileUrl
+			} );
+
+			this.getHead().append( link );
+		}
+	},
+
+	/**
+	 * Creates a CSS style sheet and inserts it into the document.
+	 *
+	 * @param cssStyleText {String} CSS style text.
+	 * @returns {Object} The created DOM native style sheet object.
+	 */
+	appendStyleText: function( cssStyleText ) {
+		if ( this.$.createStyleSheet ) {
+			var styleSheet = this.$.createStyleSheet( "" );
+			styleSheet.cssText = cssStyleText;
+		} else {
+			var style = new CKEDITOR.dom.element( 'style', this );
+			style.append( new CKEDITOR.dom.text( cssStyleText, this ) );
+			this.getHead().append( style );
+		}
+
+		return styleSheet || style.$.sheet;
+	},
+
+	/**
+	 * Creates {@link CKEDITOR.dom.element} instance in this document.
+	 *
+	 * @returns {CKEDITOR.dom.element}
+	 * @todo
+	 */
+	createElement: function( name, attribsAndStyles ) {
+		var element = new CKEDITOR.dom.element( name, this );
+
+		if ( attribsAndStyles ) {
+			if ( attribsAndStyles.attributes )
+				element.setAttributes( attribsAndStyles.attributes );
+
+			if ( attribsAndStyles.styles )
+				element.setStyles( attribsAndStyles.styles );
+		}
+
+		return element;
+	},
+
+	/**
+	 * Creates {@link CKEDITOR.dom.text} instance in this document.
+	 *
+	 * @param {String} text Value of the text node.
+	 * @returns {CKEDITOR.dom.element}
+	 */
+	createText: function( text ) {
+		return new CKEDITOR.dom.text( text, this );
+	},
+
+	/**
+	 * Moves the selection focus to this document's window.
+	 */
+	focus: function() {
+		this.getWindow().focus();
+	},
+
+	/**
+	 * Returns the element that is currently designated as the active element in the document.
+	 *
+	 * **Note:** Only one element can be active at a time in a document.
+	 * An active element does not necessarily have focus,
+	 * but an element with focus is always the active element in a document.
+	 *
+	 * @returns {CKEDITOR.dom.element}
+	 */
+	getActive: function() {
+		return new CKEDITOR.dom.element( this.$.activeElement );
+	},
+
+	/**
+	 * Gets an element based on its id.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		alert( element.getId() ); // 'myElement'
+	 *
+	 * @param {String} elementId The element id.
+	 * @returns {CKEDITOR.dom.element} The element instance, or null if not found.
+	 */
+	getById: function( elementId ) {
+		var $ = this.$.getElementById( elementId );
+		return $ ? new CKEDITOR.dom.element( $ ) : null;
+	},
+
+	/**
+	 * Gets a node based on its address. See {@link CKEDITOR.dom.node#getAddress}.
+	 *
+	 * @param {Array} address
+	 * @param {Boolean} [normalized=false]
+	 */
+	getByAddress: function( address, normalized ) {
+		var $ = this.$.documentElement;
+
+		for ( var i = 0; $ && i < address.length; i++ ) {
+			var target = address[ i ];
+
+			if ( !normalized ) {
+				$ = $.childNodes[ target ];
+				continue;
+			}
+
+			var currentIndex = -1;
+
+			for ( var j = 0; j < $.childNodes.length; j++ ) {
+				var candidate = $.childNodes[ j ];
+
+				if ( normalized === true && candidate.nodeType == 3 && candidate.previousSibling && candidate.previousSibling.nodeType == 3 )
+					continue;
+
+				currentIndex++;
+
+				if ( currentIndex == target ) {
+					$ = candidate;
+					break;
+				}
+			}
+		}
+
+		return $ ? new CKEDITOR.dom.node( $ ) : null;
+	},
+
+	/**
+	 * Gets elements list based on given tag name.
+	 *
+	 * @param {String} tagName The element tag name.
+	 * @returns {CKEDITOR.dom.nodeList} The nodes list.
+	 */
+	getElementsByTag: function( tagName, namespace ) {
+		if ( !( CKEDITOR.env.ie && !( document.documentMode > 8 ) ) && namespace )
+			tagName = namespace + ':' + tagName;
+		return new CKEDITOR.dom.nodeList( this.$.getElementsByTagName( tagName ) );
+	},
+
+	/**
+	 * Gets the `<head>` element for this document.
+	 *
+	 *		var element = CKEDITOR.document.getHead();
+	 *		alert( element.getName() ); // 'head'
+	 *
+	 * @returns {CKEDITOR.dom.element} The `<head>` element.
+	 */
+	getHead: function() {
+		var head = this.$.getElementsByTagName( 'head' )[ 0 ];
+		if ( !head )
+			head = this.getDocumentElement().append( new CKEDITOR.dom.element( 'head' ), true );
+		else
+			head = new CKEDITOR.dom.element( head );
+
+		return head;
+	},
+
+	/**
+	 * Gets the `<body>` element for this document.
+	 *
+	 *		var element = CKEDITOR.document.getBody();
+	 *		alert( element.getName() ); // 'body'
+	 *
+	 * @returns {CKEDITOR.dom.element} The `<body>` element.
+	 */
+	getBody: function() {
+		return new CKEDITOR.dom.element( this.$.body );
+	},
+
+	/**
+	 * Gets the DOM document element for this document.
+	 *
+	 * @returns {CKEDITOR.dom.element} The DOM document element.
+	 */
+	getDocumentElement: function() {
+		return new CKEDITOR.dom.element( this.$.documentElement );
+	},
+
+	/**
+	 * Gets the window object that holds this document.
+	 *
+	 * @returns {CKEDITOR.dom.window} The window object.
+	 */
+	getWindow: function() {
+		return new CKEDITOR.dom.window( this.$.parentWindow || this.$.defaultView );
+	},
+
+	/**
+	 * Defines the document contents through document.write. Note that the
+	 * previous document contents will be lost (cleaned).
+	 *
+	 *		document.write(
+	 *			'<html>' +
+	 *				'<head><title>Sample Doc</title></head>' +
+	 *				'<body>Document contents created by code</body>' +
+	 *			'</html>'
+	 *		);
+	 *
+	 * @since 3.5
+	 * @param {String} html The HTML defining the document contents.
+	 */
+	write: function( html ) {
+		// Don't leave any history log in IE. (#5657)
+		this.$.open( 'text/html', 'replace' );
+
+		// Support for custom document.domain in IE.
+		//
+		// The script must be appended because if placed before the
+		// doctype, IE will go into quirks mode and mess with
+		// the editable, e.g. by changing its default height.
+		if ( CKEDITOR.env.ie )
+			html = html.replace( /(?:^\s*<!DOCTYPE[^>]*?>)|^/i, '$&\n<script data-cke-temp="1">(' + CKEDITOR.tools.fixDomain + ')();</script>' );
+
+		this.$.write( html );
+		this.$.close();
+	},
+
+	/**
+	 * Wrapper for `querySelectorAll`. Returns a list of elements within this document that match
+	 * specified `selector`.
+	 *
+	 * **Note:** returned list is not a live collection (like a result of native `querySelectorAll`).
+	 *
+	 * @since 4.3
+	 * @param {String} selector
+	 * @returns {CKEDITOR.dom.nodeList}
+	 */
+	find: function( selector ) {
+		return new CKEDITOR.dom.nodeList( this.$.querySelectorAll( selector ) );
+	},
+
+	/**
+	 * Wrapper for `querySelector`. Returns first element within this document that matches
+	 * specified `selector`.
+	 *
+	 * @since 4.3
+	 * @param {String} selector
+	 * @returns {CKEDITOR.dom.element}
+	 */
+	findOne: function( selector ) {
+		var el = this.$.querySelector( selector );
+
+		return el ? new CKEDITOR.dom.element( el ) : null;
+	},
+
+	/**
+	 * IE8 only method. It returns document fragment which has all HTML5 elements enabled.
+	 *
+	 * @since 4.3
+	 * @private
+	 * @returns DocumentFragment
+	 */
+	_getHtml5ShivFrag: function() {
+		var $frag = this.getCustomData( 'html5ShivFrag' );
+
+		if ( !$frag ) {
+			$frag = this.$.createDocumentFragment();
+			CKEDITOR.tools.enableHtml5Elements( $frag, true );
+			this.setCustomData( 'html5ShivFrag', $frag );
+		}
+
+		return $frag;
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/documentfragment.js b/lam/templates/lib/extra/ckeditor/core/dom/documentfragment.js
new file mode 100644
index 00000000..c1af8992
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/documentfragment.js
@@ -0,0 +1,45 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * DocumentFragment is a "lightweight" or "minimal" Document object. It is
+ * commonly used to extract a portion of a document's tree or to create a new
+ * fragment of a document. Various operations may take DocumentFragment objects
+ * as arguments and results in all the child nodes of the DocumentFragment being
+ * moved to the child list of this node.
+ *
+ * @class
+ * @constructor Creates a document fragment class instance.
+ * @param {Object} nodeOrDoc
+ * @todo example and param doc
+ */
+CKEDITOR.dom.documentFragment = function( nodeOrDoc ) {
+	nodeOrDoc = nodeOrDoc || CKEDITOR.document;
+
+	if ( nodeOrDoc.type == CKEDITOR.NODE_DOCUMENT )
+		this.$ = nodeOrDoc.$.createDocumentFragment();
+	else
+		this.$ = nodeOrDoc;
+};
+
+CKEDITOR.tools.extend( CKEDITOR.dom.documentFragment.prototype, CKEDITOR.dom.element.prototype, {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_DOCUMENT_FRAGMENT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_DOCUMENT_FRAGMENT]
+	 */
+	type: CKEDITOR.NODE_DOCUMENT_FRAGMENT,
+
+	/**
+	 * Inserts document fragment's contents after specified node.
+	 *
+	 * @param {CKEDITOR.dom.node} node
+	 */
+	insertAfterNode: function( node ) {
+		node = node.$;
+		node.parentNode.insertBefore( this.$, node.nextSibling );
+	}
+}, true, { 'append': 1, 'appendBogus': 1, 'getFirst': 1, 'getLast': 1, 'getParent': 1, 'getNext': 1, 'getPrevious': 1, 'appendTo': 1, 'moveChildren': 1, 'insertBefore': 1, 'insertAfterNode': 1, 'replace': 1, 'trim': 1, 'type': 1, 'ltrim': 1, 'rtrim': 1, 'getDocument': 1, 'getChildCount': 1, 'getChild': 1, 'getChildren': 1 } );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/domobject.js b/lam/templates/lib/extra/ckeditor/core/dom/domobject.js
new file mode 100644
index 00000000..96e2be18
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/domobject.js
@@ -0,0 +1,262 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.editor} class, which is the base
+ *		for other classes representing DOM objects.
+ */
+
+/**
+ * Represents a DOM object. This class is not intended to be used directly. It
+ * serves as the base class for other classes representing specific DOM
+ * objects.
+ *
+ * @class
+ * @mixins CKEDITOR.event
+ * @constructor Creates a domObject class instance.
+ * @param {Object} nativeDomObject A native DOM object.
+ */
+CKEDITOR.dom.domObject = function( nativeDomObject ) {
+	if ( nativeDomObject ) {
+		/**
+		 * The native DOM object represented by this class instance.
+		 *
+		 *		var element = new CKEDITOR.dom.element( 'span' );
+		 *		alert( element.$.nodeType ); // '1'
+		 *
+		 * @readonly
+		 * @property {Object}
+		 */
+		this.$ = nativeDomObject;
+	}
+};
+
+CKEDITOR.dom.domObject.prototype = ( function() {
+	// Do not define other local variables here. We want to keep the native
+	// listener closures as clean as possible.
+
+	var getNativeListener = function( domObject, eventName ) {
+			return function( domEvent ) {
+				// In FF, when reloading the page with the editor focused, it may
+				// throw an error because the CKEDITOR global is not anymore
+				// available. So, we check it here first. (#2923)
+				if ( typeof CKEDITOR != 'undefined' )
+					domObject.fire( eventName, new CKEDITOR.dom.event( domEvent ) );
+			};
+		};
+
+	return {
+
+		/**
+		 * Get the private `_` object which is bound to the native
+		 * DOM object using {@link #getCustomData}.
+		 *
+		 *		var elementA = new CKEDITOR.dom.element( nativeElement );
+		 *		elementA.getPrivate().value = 1;
+		 *		...
+		 *		var elementB = new CKEDITOR.dom.element( nativeElement );
+		 *		elementB.getPrivate().value; // 1
+		 *
+		 * @returns {Object} The private object.
+		 */
+		getPrivate: function() {
+			var priv;
+
+			// Get the main private object from the custom data. Create it if not defined.
+			if ( !( priv = this.getCustomData( '_' ) ) )
+				this.setCustomData( '_', ( priv = {} ) );
+
+			return priv;
+		},
+
+		// Docs inherited from event.
+		on: function( eventName ) {
+			// We customize the "on" function here. The basic idea is that we'll have
+			// only one listener for a native event, which will then call all listeners
+			// set to the event.
+
+			// Get the listeners holder object.
+			var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+
+			if ( !nativeListeners ) {
+				nativeListeners = {};
+				this.setCustomData( '_cke_nativeListeners', nativeListeners );
+			}
+
+			// Check if we have a listener for that event.
+			if ( !nativeListeners[ eventName ] ) {
+				var listener = nativeListeners[ eventName ] = getNativeListener( this, eventName );
+
+				if ( this.$.addEventListener )
+					this.$.addEventListener( eventName, listener, !!CKEDITOR.event.useCapture );
+				else if ( this.$.attachEvent )
+					this.$.attachEvent( 'on' + eventName, listener );
+			}
+
+			// Call the original implementation.
+			return CKEDITOR.event.prototype.on.apply( this, arguments );
+		},
+
+		// Docs inherited from event.
+		removeListener: function( eventName ) {
+			// Call the original implementation.
+			CKEDITOR.event.prototype.removeListener.apply( this, arguments );
+
+			// If we don't have listeners for this event, clean the DOM up.
+			if ( !this.hasListeners( eventName ) ) {
+				var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+				var listener = nativeListeners && nativeListeners[ eventName ];
+				if ( listener ) {
+					if ( this.$.removeEventListener )
+						this.$.removeEventListener( eventName, listener, false );
+					else if ( this.$.detachEvent )
+						this.$.detachEvent( 'on' + eventName, listener );
+
+					delete nativeListeners[ eventName ];
+				}
+			}
+		},
+
+		/**
+		 * Removes any listener set on this object.
+		 *
+		 * To avoid memory leaks we must assure that there are no
+		 * references left after the object is no longer needed.
+		 */
+		removeAllListeners: function() {
+			var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+			for ( var eventName in nativeListeners ) {
+				var listener = nativeListeners[ eventName ];
+				if ( this.$.detachEvent )
+					this.$.detachEvent( 'on' + eventName, listener );
+				else if ( this.$.removeEventListener )
+					this.$.removeEventListener( eventName, listener, false );
+
+				delete nativeListeners[ eventName ];
+			}
+
+			// Remove events from events object so fire() method will not call
+			// listeners (#11400).
+			CKEDITOR.event.prototype.removeAllListeners.call( this );
+		}
+	};
+} )();
+
+( function( domObjectProto ) {
+	var customData = {};
+
+	CKEDITOR.on( 'reset', function() {
+		customData = {};
+	} );
+
+	/**
+	 * Determines whether the specified object is equal to the current object.
+	 *
+	 *		var doc = new CKEDITOR.dom.document( document );
+	 *		alert( doc.equals( CKEDITOR.document ) );	// true
+	 *		alert( doc == CKEDITOR.document );			// false
+	 *
+	 * @param {Object} object The object to compare with the current object.
+	 * @returns {Boolean} `true` if the object is equal.
+	 */
+	domObjectProto.equals = function( object ) {
+		// Try/Catch to avoid IE permission error when object is from different document.
+		try {
+			return ( object && object.$ === this.$ );
+		} catch ( er ) {
+			return false;
+		}
+	};
+
+	/**
+	 * Sets a data slot value for this object. These values are shared by all
+	 * instances pointing to that same DOM object.
+	 *
+	 * **Note:** The created data slot is only guarantied to be available on this unique dom node,
+	 * thus any wish to continue access it from other element clones (either created by
+	 * clone node or from `innerHtml`) will fail, for such usage, please use
+	 * {@link CKEDITOR.dom.element#setAttribute} instead.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'span' );
+	 *		element.setCustomData( 'hasCustomData', true );
+	 *
+	 * @param {String} key A key used to identify the data slot.
+	 * @param {Object} value The value to set to the data slot.
+	 * @returns {CKEDITOR.dom.domObject} This DOM object instance.
+	 * @chainable
+	 */
+	domObjectProto.setCustomData = function( key, value ) {
+		var expandoNumber = this.getUniqueId(),
+			dataSlot = customData[ expandoNumber ] || ( customData[ expandoNumber ] = {} );
+
+		dataSlot[ key ] = value;
+
+		return this;
+	};
+
+	/**
+	 * Gets the value set to a data slot in this object.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'span' );
+	 *		alert( element.getCustomData( 'hasCustomData' ) );		// e.g. 'true'
+	 *		alert( element.getCustomData( 'nonExistingKey' ) );		// null
+	 *
+	 * @param {String} key The key used to identify the data slot.
+	 * @returns {Object} This value set to the data slot.
+	 */
+	domObjectProto.getCustomData = function( key ) {
+		var expandoNumber = this.$[ 'data-cke-expando' ],
+			dataSlot = expandoNumber && customData[ expandoNumber ];
+
+		return ( dataSlot && key in dataSlot ) ? dataSlot[ key ] : null;
+	};
+
+	/**
+	 * Removes the value in data slot under given `key`.
+	 *
+	 * @param {String} key
+	 * @returns {Object} Removed value or `null` if not found.
+	 */
+	domObjectProto.removeCustomData = function( key ) {
+		var expandoNumber = this.$[ 'data-cke-expando' ],
+			dataSlot = expandoNumber && customData[ expandoNumber ],
+			retval, hadKey;
+
+		if ( dataSlot ) {
+			retval = dataSlot[ key ];
+			hadKey = key in dataSlot;
+			delete dataSlot[ key ];
+		}
+
+		return hadKey ? retval : null;
+	};
+
+	/**
+	 * Removes any data stored on this object.
+	 * To avoid memory leaks we must assure that there are no
+	 * references left after the object is no longer needed.
+	 */
+	domObjectProto.clearCustomData = function() {
+		// Clear all event listeners
+		this.removeAllListeners();
+
+		var expandoNumber = this.$[ 'data-cke-expando' ];
+		expandoNumber && delete customData[ expandoNumber ];
+	};
+
+	/**
+	 * Gets an ID that can be used to identiquely identify this DOM object in
+	 * the running session.
+	 *
+	 * @returns {Number} A unique ID.
+	 */
+	domObjectProto.getUniqueId = function() {
+		return this.$[ 'data-cke-expando' ] || ( this.$[ 'data-cke-expando' ] = CKEDITOR.tools.getNextNumber() );
+	};
+
+	// Implement CKEDITOR.event.
+	CKEDITOR.event.implementOn( domObjectProto );
+
+} )( CKEDITOR.dom.domObject.prototype );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/element.js b/lam/templates/lib/extra/ckeditor/core/dom/element.js
new file mode 100644
index 00000000..ba5416c2
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/element.js
@@ -0,0 +1,2009 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.element} class, which
+ *		represents a DOM element.
+ */
+
+/**
+ * Represents a DOM element.
+ *
+ *		// Create a new <span> element.
+ *		var element = new CKEDITOR.dom.element( 'span' );
+ *
+ *		// Create an element based on a native DOM element.
+ *		var element = new CKEDITOR.dom.element( document.getElementById( 'myId' ) );
+ *
+ * @class
+ * @extends CKEDITOR.dom.node
+ * @constructor Creates an element class instance.
+ * @param {Object/String} element A native DOM element or the element name for
+ * new elements.
+ * @param {CKEDITOR.dom.document} [ownerDocument] The document that will contain
+ * the element in case of element creation.
+ */
+CKEDITOR.dom.element = function( element, ownerDocument ) {
+	if ( typeof element == 'string' )
+		element = ( ownerDocument ? ownerDocument.$ : document ).createElement( element );
+
+	// Call the base constructor (we must not call CKEDITOR.dom.node).
+	CKEDITOR.dom.domObject.call( this, element );
+};
+
+// PACKAGER_RENAME( CKEDITOR.dom.element )
+/**
+ * The the {@link CKEDITOR.dom.element} representing and element. If the
+ * element is a native DOM element, it will be transformed into a valid
+ * CKEDITOR.dom.element object.
+ *
+ *		var element = new CKEDITOR.dom.element( 'span' );
+ *		alert( element == CKEDITOR.dom.element.get( element ) ); // true
+ *
+ *		var element = document.getElementById( 'myElement' );
+ *		alert( CKEDITOR.dom.element.get( element ).getName() ); // (e.g.) 'p'
+ *
+ * @static
+ * @param {String/Object} element Element's id or name or native DOM element.
+ * @returns {CKEDITOR.dom.element} The transformed element.
+ */
+CKEDITOR.dom.element.get = function( element ) {
+	var el = typeof element == 'string' ? document.getElementById( element ) || document.getElementsByName( element )[ 0 ] : element;
+
+	return el && ( el.$ ? el : new CKEDITOR.dom.element( el ) );
+};
+
+CKEDITOR.dom.element.prototype = new CKEDITOR.dom.node();
+
+/**
+ * Creates an instance of the {@link CKEDITOR.dom.element} class based on the
+ * HTML representation of an element.
+ *
+ *		var element = CKEDITOR.dom.element.createFromHtml( '<strong class="anyclass">My element</strong>' );
+ *		alert( element.getName() ); // 'strong'
+ *
+ * @static
+ * @param {String} html The element HTML. It should define only one element in
+ * the "root" level. The "root" element can have child nodes, but not siblings.
+ * @returns {CKEDITOR.dom.element} The element instance.
+ */
+CKEDITOR.dom.element.createFromHtml = function( html, ownerDocument ) {
+	var temp = new CKEDITOR.dom.element( 'div', ownerDocument );
+	temp.setHtml( html );
+
+	// When returning the node, remove it from its parent to detach it.
+	return temp.getFirst().remove();
+};
+
+/**
+ * @static
+ * @todo
+ */
+CKEDITOR.dom.element.setMarker = function( database, element, name, value ) {
+	var id = element.getCustomData( 'list_marker_id' ) || ( element.setCustomData( 'list_marker_id', CKEDITOR.tools.getNextNumber() ).getCustomData( 'list_marker_id' ) ),
+		markerNames = element.getCustomData( 'list_marker_names' ) || ( element.setCustomData( 'list_marker_names', {} ).getCustomData( 'list_marker_names' ) );
+	database[ id ] = element;
+	markerNames[ name ] = 1;
+
+	return element.setCustomData( name, value );
+};
+
+/**
+ * @static
+ * @todo
+ */
+CKEDITOR.dom.element.clearAllMarkers = function( database ) {
+	for ( var i in database )
+		CKEDITOR.dom.element.clearMarkers( database, database[ i ], 1 );
+};
+
+/**
+ * @static
+ * @todo
+ */
+CKEDITOR.dom.element.clearMarkers = function( database, element, removeFromDatabase ) {
+	var names = element.getCustomData( 'list_marker_names' ),
+		id = element.getCustomData( 'list_marker_id' );
+	for ( var i in names )
+		element.removeCustomData( i );
+	element.removeCustomData( 'list_marker_names' );
+	if ( removeFromDatabase ) {
+		element.removeCustomData( 'list_marker_id' );
+		delete database[ id ];
+	}
+};
+( function() {
+
+CKEDITOR.tools.extend( CKEDITOR.dom.element.prototype, {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_ELEMENT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_ELEMENT]
+	 */
+	type: CKEDITOR.NODE_ELEMENT,
+
+	/**
+	 * Adds a CSS class to the element. It appends the class to the
+	 * already existing names.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'div' );
+	 *		element.addClass( 'classA' ); // <div class="classA">
+	 *		element.addClass( 'classB' ); // <div class="classA classB">
+	 *		element.addClass( 'classA' ); // <div class="classA classB">
+	 *
+	 * @param {String} className The name of the class to be added.
+	 */
+	addClass: function( className ) {
+		var c = this.$.className;
+		if ( c ) {
+			var regex = new RegExp( '(?:^|\\s)' + className + '(?:\\s|$)', '' );
+			if ( !regex.test( c ) )
+				c += ' ' + className;
+		}
+		this.$.className = c || className;
+	},
+
+	/**
+	 * Removes a CSS class name from the elements classes. Other classes
+	 * remain untouched.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'div' );
+	 *		element.addClass( 'classA' );		// <div class="classA">
+	 *		element.addClass( 'classB' );		// <div class="classA classB">
+	 *		element.removeClass( 'classA' );	// <div class="classB">
+	 *		element.removeClass( 'classB' );	// <div>
+	 *
+	 * @chainable
+	 * @param {String} className The name of the class to remove.
+	 */
+	removeClass: function( className ) {
+		var c = this.getAttribute( 'class' );
+		if ( c ) {
+			var regex = new RegExp( '(?:^|\\s+)' + className + '(?=\\s|$)', 'i' );
+			if ( regex.test( c ) ) {
+				c = c.replace( regex, '' ).replace( /^\s+/, '' );
+
+				if ( c )
+					this.setAttribute( 'class', c );
+				else
+					this.removeAttribute( 'class' );
+			}
+		}
+
+		return this;
+	},
+
+	/**
+	 * Checks if element has class name.
+	 *
+	 * @param {String} className
+	 * @returns {Boolean}
+	 */
+	hasClass: function( className ) {
+		var regex = new RegExp( '(?:^|\\s+)' + className + '(?=\\s|$)', '' );
+		return regex.test( this.getAttribute( 'class' ) );
+	},
+
+	/**
+	 * Append a node as a child of this element.
+	 *
+	 *		var p = new CKEDITOR.dom.element( 'p' );
+	 *
+	 *		var strong = new CKEDITOR.dom.element( 'strong' );
+	 *		p.append( strong );
+	 *
+	 *		var em = p.append( 'em' );
+	 *
+	 *		// Result: '<p><strong></strong><em></em></p>'
+	 *
+	 * @param {CKEDITOR.dom.node/String} node The node or element name to be appended.
+	 * @param {Boolean} [toStart=false] Indicates that the element is to be appended at the start.
+	 * @returns {CKEDITOR.dom.node} The appended node.
+	 */
+	append: function( node, toStart ) {
+		if ( typeof node == 'string' )
+			node = this.getDocument().createElement( node );
+
+		if ( toStart )
+			this.$.insertBefore( node.$, this.$.firstChild );
+		else
+			this.$.appendChild( node.$ );
+
+		return node;
+	},
+
+	/**
+	 * Append HTML as a child(ren) of this element.
+	 *
+	 * @param {String} html
+	 */
+	appendHtml: function( html ) {
+		if ( !this.$.childNodes.length )
+			this.setHtml( html );
+		else {
+			var temp = new CKEDITOR.dom.element( 'div', this.getDocument() );
+			temp.setHtml( html );
+			temp.moveChildren( this );
+		}
+	},
+
+	/**
+	 * Append text to this element.
+	 *
+	 *		var p = new CKEDITOR.dom.element( 'p' );
+	 *		p.appendText( 'This is' );
+	 *		p.appendText( ' some text' );
+	 *
+	 *		// Result: '<p>This is some text</p>'
+	 *
+	 * @param {String} text The text to be appended.
+	 * @returns {CKEDITOR.dom.node} The appended node.
+	 */
+	appendText: function( text ) {
+		if ( this.$.text != undefined )
+			this.$.text += text;
+		else
+			this.append( new CKEDITOR.dom.text( text ) );
+	},
+
+	/**
+	 * Appends a `<br>` filler element to this element if the filler is not present already.
+	 * By default filler is appended only if {@link CKEDITOR.env#needsBrFiller} is `true`,
+	 * however when `force` is set to `true` filler will be appended regardless of the environment.
+	 *
+	 * @param {Boolean} [force] Append filler regardless of the environment.
+	 */
+	appendBogus: function( force ) {
+		if ( !force && !( CKEDITOR.env.needsBrFiller || CKEDITOR.env.opera ) )
+			return;
+
+		var lastChild = this.getLast();
+
+		// Ignore empty/spaces text.
+		while ( lastChild && lastChild.type == CKEDITOR.NODE_TEXT && !CKEDITOR.tools.rtrim( lastChild.getText() ) )
+			lastChild = lastChild.getPrevious();
+		if ( !lastChild || !lastChild.is || !lastChild.is( 'br' ) ) {
+			var bogus = CKEDITOR.env.opera ? this.getDocument().createText( '' ) : this.getDocument().createElement( 'br' );
+
+			CKEDITOR.env.gecko && bogus.setAttribute( 'type', '_moz' );
+
+			this.append( bogus );
+		}
+	},
+
+	/**
+	 * Breaks one of the ancestor element in the element position, moving
+	 * this element between the broken parts.
+	 *
+	 *		// Before breaking:
+	 *		//		<b>This <i>is some<span /> sample</i> test text</b>
+	 *		// If "element" is <span /> and "parent" is <i>:
+	 *		//		<b>This <i>is some</i><span /><i> sample</i> test text</b>
+	 *		element.breakParent( parent );
+	 *
+	 *		// Before breaking:
+	 *		//		<b>This <i>is some<span /> sample</i> test text</b>
+	 *		// If "element" is <span /> and "parent" is <b>:
+	 *		//		<b>This <i>is some</i></b><span /><b><i> sample</i> test text</b>
+	 *		element.breakParent( parent );
+	 *
+	 * @param {CKEDITOR.dom.element} parent The anscestor element to get broken.
+	 */
+	breakParent: function( parent ) {
+		var range = new CKEDITOR.dom.range( this.getDocument() );
+
+		// We'll be extracting part of this element, so let's use our
+		// range to get the correct piece.
+		range.setStartAfter( this );
+		range.setEndAfter( parent );
+
+		// Extract it.
+		var docFrag = range.extractContents();
+
+		// Move the element outside the broken element.
+		range.insertNode( this.remove() );
+
+		// Re-insert the extracted piece after the element.
+		docFrag.insertAfterNode( this );
+	},
+
+	/**
+	 * Checks if this element contains given node.
+	 *
+	 * @method
+	 * @param {CKEDITOR.dom.node} node
+	 * @returns {Boolean}
+	 */
+	contains: CKEDITOR.env.ie || CKEDITOR.env.webkit ?
+		function( node ) {
+			var $ = this.$;
+
+			return node.type != CKEDITOR.NODE_ELEMENT ? $.contains( node.getParent().$ ) : $ != node.$ && $.contains( node.$ );
+		} : function( node ) {
+			return !!( this.$.compareDocumentPosition( node.$ ) & 16 );
+		},
+
+	/**
+	 * Moves the selection focus to this element.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myTextarea' );
+	 *		element.focus();
+	 *
+	 * @method
+	 * @param  {Boolean} defer Whether to asynchronously defer the
+	 * execution by 100 ms.
+	 */
+	focus: ( function() {
+		function exec() {
+			// IE throws error if the element is not visible.
+			try {
+				this.$.focus();
+			} catch ( e ) {}
+		}
+
+		return function( defer ) {
+			if ( defer )
+				CKEDITOR.tools.setTimeout( exec, 100, this );
+			else
+				exec.call( this );
+		};
+	} )(),
+
+	/**
+	 * Gets the inner HTML of this element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div><b>Example</b></div>' );
+	 *		alert( element.getHtml() ); // '<b>Example</b>'
+	 *
+	 * @returns {String} The inner HTML of this element.
+	 */
+	getHtml: function() {
+		var retval = this.$.innerHTML;
+		// Strip <?xml:namespace> tags in IE. (#3341).
+		return CKEDITOR.env.ie ? retval.replace( /<\?[^>]*>/g, '' ) : retval;
+	},
+
+	/**
+	 * Gets the outer (inner plus tags) HTML of this element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div class="bold"><b>Example</b></div>' );
+	 *		alert( element.getOuterHtml() ); // '<div class="bold"><b>Example</b></div>'
+	 *
+	 * @returns {String} The outer HTML of this element.
+	 */
+	getOuterHtml: function() {
+		if ( this.$.outerHTML ) {
+			// IE includes the <?xml:namespace> tag in the outerHTML of
+			// namespaced element. So, we must strip it here. (#3341)
+			return this.$.outerHTML.replace( /<\?[^>]*>/, '' );
+		}
+
+		var tmpDiv = this.$.ownerDocument.createElement( 'div' );
+		tmpDiv.appendChild( this.$.cloneNode( true ) );
+		return tmpDiv.innerHTML;
+	},
+
+	/**
+	 * Retrieve the bounding rectangle of the current element, in pixels,
+	 * relative to the upper-left corner of the browser's client area.
+	 *
+	 * @returns {Object} The dimensions of the DOM element including
+	 * `left`, `top`, `right`, `bottom`, `width` and `height`.
+	 */
+	getClientRect: function() {
+		// http://help.dottoro.com/ljvmcrrn.php
+		var rect = CKEDITOR.tools.extend( {}, this.$.getBoundingClientRect() );
+
+		!rect.width && ( rect.width = rect.right - rect.left );
+		!rect.height && ( rect.height = rect.bottom - rect.top );
+
+		return rect;
+	},
+
+	/**
+	 * Sets the inner HTML of this element.
+	 *
+	 *		var p = new CKEDITOR.dom.element( 'p' );
+	 *		p.setHtml( '<b>Inner</b> HTML' );
+	 *
+	 *		// Result: '<p><b>Inner</b> HTML</p>'
+	 *
+	 * @method
+	 * @param {String} html The HTML to be set for this element.
+	 * @returns {String} The inserted HTML.
+	 */
+	setHtml: ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 ) ?
+			// old IEs throws error on HTML manipulation (through the "innerHTML" property)
+			// on the element which resides in an DTD invalid position,  e.g. <span><div></div></span>
+			// fortunately it can be worked around with DOM manipulation.
+			function( html ) {
+				try {
+					var $ = this.$;
+
+					// Fix the case when setHtml is called on detached element.
+					// HTML5 shiv used for document in which this element was created
+					// won't affect that detached element. So get document fragment with
+					// all HTML5 elements enabled and set innerHTML while this element is appended to it.
+					if ( this.getParent() )
+						return ( $.innerHTML = html );
+					else {
+						var $frag = this.getDocument()._getHtml5ShivFrag();
+						$frag.appendChild( $ );
+						$.innerHTML = html;
+						$frag.removeChild( $ );
+
+						return html;
+					}
+				}
+				catch ( e ) {
+					this.$.innerHTML = '';
+
+					var temp = new CKEDITOR.dom.element( 'body', this.getDocument() );
+					temp.$.innerHTML = html;
+
+					var children = temp.getChildren();
+					while ( children.count() )
+						this.append( children.getItem( 0 ) );
+
+					return html;
+				}
+			}
+		:
+			function( html ) {
+				return ( this.$.innerHTML = html );
+			},
+
+	/**
+	 * Sets the element contents as plain text.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'div' );
+	 *		element.setText( 'A > B & C < D' );
+	 *		alert( element.innerHTML ); // 'A &gt; B &amp; C &lt; D'
+	 *
+	 * @param {String} text The text to be set.
+	 * @returns {String} The inserted text.
+	 */
+	setText: function( text ) {
+		CKEDITOR.dom.element.prototype.setText = ( this.$.innerText != undefined ) ?
+			function( text ) {
+				return this.$.innerText = text;
+			} : function( text ) {
+				return this.$.textContent = text;
+			};
+
+		return this.setText( text );
+	},
+
+	/**
+	 * Gets the value of an element attribute.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<input type="text" />' );
+	 *		alert( element.getAttribute( 'type' ) ); // 'text'
+	 *
+	 * @method
+	 * @param {String} name The attribute name.
+	 * @returns {String} The attribute value or null if not defined.
+	 */
+	getAttribute: ( function() {
+		var standard = function( name ) {
+				return this.$.getAttribute( name, 2 );
+			};
+
+		if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) ) {
+			return function( name ) {
+				switch ( name ) {
+					case 'class':
+						name = 'className';
+						break;
+
+					case 'http-equiv':
+						name = 'httpEquiv';
+						break;
+
+					case 'name':
+						return this.$.name;
+
+					case 'tabindex':
+						var tabIndex = standard.call( this, name );
+
+						// IE returns tabIndex=0 by default for all
+						// elements. For those elements,
+						// getAtrribute( 'tabindex', 2 ) returns 32768
+						// instead. So, we must make this check to give a
+						// uniform result among all browsers.
+						if ( tabIndex !== 0 && this.$.tabIndex === 0 )
+							tabIndex = null;
+
+						return tabIndex;
+						break;
+
+					case 'checked':
+						{
+							var attr = this.$.attributes.getNamedItem( name ),
+								attrValue = attr.specified ? attr.nodeValue // For value given by parser.
+								: this.$.checked; // For value created via DOM interface.
+
+							return attrValue ? 'checked' : null;
+						}
+
+					case 'hspace':
+					case 'value':
+						return this.$[ name ];
+
+					case 'style':
+						// IE does not return inline styles via getAttribute(). See #2947.
+						return this.$.style.cssText;
+
+					case 'contenteditable':
+					case 'contentEditable':
+						return this.$.attributes.getNamedItem( 'contentEditable' ).specified ? this.$.getAttribute( 'contentEditable' ) : null;
+				}
+
+				return standard.call( this, name );
+			};
+		} else
+			return standard;
+	} )(),
+
+	/**
+	 * Gets the nodes list containing all children of this element.
+	 *
+	 * @returns {CKEDITOR.dom.nodeList}
+	 */
+	getChildren: function() {
+		return new CKEDITOR.dom.nodeList( this.$.childNodes );
+	},
+
+	/**
+	 * Gets the current computed value of one of the element CSS style
+	 * properties.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'span' );
+	 *		alert( element.getComputedStyle( 'display' ) ); // 'inline'
+	 *
+	 * @method
+	 * @param {String} propertyName The style property name.
+	 * @returns {String} The property value.
+	 */
+	getComputedStyle: CKEDITOR.env.ie ?
+		function( propertyName ) {
+			return this.$.currentStyle[ CKEDITOR.tools.cssStyleToDomStyle( propertyName ) ];
+		} : function( propertyName ) {
+			var style = this.getWindow().$.getComputedStyle( this.$, null );
+			// Firefox may return null if we call the above on a hidden iframe. (#9117)
+			return style ? style.getPropertyValue( propertyName ) : '';
+		},
+
+	/**
+	 * Gets the DTD entries for this element.
+	 *
+	 * @returns {Object} An object containing the list of elements accepted
+	 * by this element.
+	 */
+	getDtd: function() {
+		var dtd = CKEDITOR.dtd[ this.getName() ];
+
+		this.getDtd = function() {
+			return dtd;
+		};
+
+		return dtd;
+	},
+
+	/**
+	 * Gets all this element's descendants having given tag name.
+	 *
+	 * @method
+	 * @param {String} tagName
+	 */
+	getElementsByTag: CKEDITOR.dom.document.prototype.getElementsByTag,
+
+	/**
+	 * Gets the computed tabindex for this element.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myDiv' );
+	 *		alert( element.getTabIndex() ); // (e.g.) '-1'
+	 *
+	 * @method
+	 * @returns {Number} The tabindex value.
+	 */
+	getTabIndex: CKEDITOR.env.ie ?
+		function() {
+			var tabIndex = this.$.tabIndex;
+
+			// IE returns tabIndex=0 by default for all elements. In
+			// those cases we must check that the element really has
+			// the tabindex attribute set to zero, or it is one of
+			// those element that should have zero by default.
+			if ( tabIndex === 0 && !CKEDITOR.dtd.$tabIndex[ this.getName() ] && parseInt( this.getAttribute( 'tabindex' ), 10 ) !== 0 )
+				tabIndex = -1;
+
+			return tabIndex;
+		} : CKEDITOR.env.webkit ?
+		function() {
+			var tabIndex = this.$.tabIndex;
+
+			// Safari returns "undefined" for elements that should not
+			// have tabindex (like a div). So, we must try to get it
+			// from the attribute.
+			// https://bugs.webkit.org/show_bug.cgi?id=20596
+			if ( tabIndex == undefined ) {
+				tabIndex = parseInt( this.getAttribute( 'tabindex' ), 10 );
+
+				// If the element don't have the tabindex attribute,
+				// then we should return -1.
+				if ( isNaN( tabIndex ) )
+					tabIndex = -1;
+			}
+
+			return tabIndex;
+		} : function() {
+			return this.$.tabIndex;
+		},
+
+	/**
+	 * Gets the text value of this element.
+	 *
+	 * Only in IE (which uses innerText), `<br>` will cause linebreaks,
+	 * and sucessive whitespaces (including line breaks) will be reduced to
+	 * a single space. This behavior is ok for us, for now. It may change
+	 * in the future.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div>Sample <i>text</i>.</div>' );
+	 *		alert( <b>element.getText()</b> ); // 'Sample text.'
+	 *
+	 * @returns {String} The text value.
+	 */
+	getText: function() {
+		return this.$.textContent || this.$.innerText || '';
+	},
+
+	/**
+	 * Gets the window object that contains this element.
+	 *
+	 * @returns {CKEDITOR.dom.window} The window object.
+	 */
+	getWindow: function() {
+		return this.getDocument().getWindow();
+	},
+
+	/**
+	 * Gets the value of the `id` attribute of this element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<p id="myId"></p>' );
+	 *		alert( element.getId() ); // 'myId'
+	 *
+	 * @returns {String} The element id, or null if not available.
+	 */
+	getId: function() {
+		return this.$.id || null;
+	},
+
+	/**
+	 * Gets the value of the `name` attribute of this element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<input name="myName"></input>' );
+	 *		alert( <b>element.getNameAtt()</b> ); // 'myName'
+	 *
+	 * @returns {String} The element name, or null if not available.
+	 */
+	getNameAtt: function() {
+		return this.$.name || null;
+	},
+
+	/**
+	 * Gets the element name (tag name). The returned name is guaranteed to
+	 * be always full lowercased.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'span' );
+	 *		alert( element.getName() ); // 'span'
+	 *
+	 * @returns {String} The element name.
+	 */
+	getName: function() {
+		// Cache the lowercased name inside a closure.
+		var nodeName = this.$.nodeName.toLowerCase();
+
+		if ( CKEDITOR.env.ie && !( document.documentMode > 8 ) ) {
+			var scopeName = this.$.scopeName;
+			if ( scopeName != 'HTML' )
+				nodeName = scopeName.toLowerCase() + ':' + nodeName;
+		}
+
+		return ( this.getName = function() {
+			return nodeName;
+		} )();
+	},
+
+	/**
+	 * Gets the value set to this element. This value is usually available
+	 * for form field elements.
+	 *
+	 * @returns {String} The element value.
+	 */
+	getValue: function() {
+		return this.$.value;
+	},
+
+	/**
+	 * Gets the first child node of this element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div><b>Example</b></div>' );
+	 *		var first = element.getFirst();
+	 *		alert( first.getName() ); // 'b'
+	 *
+	 * @param {Function} evaluator Filtering the result node.
+	 * @returns {CKEDITOR.dom.node} The first child node or null if not available.
+	 */
+	getFirst: function( evaluator ) {
+		var first = this.$.firstChild,
+			retval = first && new CKEDITOR.dom.node( first );
+		if ( retval && evaluator && !evaluator( retval ) )
+			retval = retval.getNext( evaluator );
+
+		return retval;
+	},
+
+	/**
+	 * See {@link #getFirst}.
+	 *
+	 * @param {Function} evaluator Filtering the result node.
+	 * @returns {CKEDITOR.dom.node}
+	 */
+	getLast: function( evaluator ) {
+		var last = this.$.lastChild,
+			retval = last && new CKEDITOR.dom.node( last );
+		if ( retval && evaluator && !evaluator( retval ) )
+			retval = retval.getPrevious( evaluator );
+
+		return retval;
+	},
+
+	/**
+	 * Gets CSS style value.
+	 *
+	 * @param {String} name The CSS property name.
+	 * @returns {String} Style value.
+	 */
+	getStyle: function( name ) {
+		return this.$.style[ CKEDITOR.tools.cssStyleToDomStyle( name ) ];
+	},
+
+	/**
+	 * Checks if the element name matches the specified criteria.
+	 *
+	 *		var element = new CKEDITOR.element( 'span' );
+	 *		alert( element.is( 'span' ) );			// true
+	 *		alert( element.is( 'p', 'span' ) );		// true
+	 *		alert( element.is( 'p' ) );				// false
+	 *		alert( element.is( 'p', 'div' ) );		// false
+	 *		alert( element.is( { p:1,span:1 } ) );	// true
+	 *
+	 * @param {String.../Object} name One or more names to be checked, or a {@link CKEDITOR.dtd} object.
+	 * @returns {Boolean} `true` if the element name matches any of the names.
+	 */
+	is: function() {
+		var name = this.getName();
+
+		// Check against the specified DTD liternal.
+		if ( typeof arguments[ 0 ] == 'object' )
+			return !!arguments[ 0 ][ name ];
+
+		// Check for tag names
+		for ( var i = 0; i < arguments.length; i++ ) {
+			if ( arguments[ i ] == name )
+				return true;
+		}
+		return false;
+	},
+
+	/**
+	 * Decide whether one element is able to receive cursor.
+	 *
+	 * @param {Boolean} [textCursor=true] Only consider element that could receive text child.
+	 */
+	isEditable: function( textCursor ) {
+		var name = this.getName();
+
+		if ( this.isReadOnly() || this.getComputedStyle( 'display' ) == 'none' ||
+				 this.getComputedStyle( 'visibility' ) == 'hidden' ||
+				 CKEDITOR.dtd.$nonEditable[ name ] ||
+				 CKEDITOR.dtd.$empty[ name ] ||
+				 ( this.is( 'a' ) &&
+					 ( this.data( 'cke-saved-name' ) || this.hasAttribute( 'name' ) ) &&
+					 !this.getChildCount()
+				 ) )
+		{
+			return false;
+		}
+
+		if ( textCursor !== false ) {
+			// Get the element DTD (defaults to span for unknown elements).
+			var dtd = CKEDITOR.dtd[ name ] || CKEDITOR.dtd.span;
+			// In the DTD # == text node.
+			return !!( dtd && dtd[ '#' ] );
+		}
+
+		return true;
+	},
+
+	/**
+	 * Compare this element's inner html, tag name, attributes, etc. with other one.
+	 *
+	 * See [W3C's DOM Level 3 spec - node#isEqualNode](http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isEqualNode)
+	 * for more details.
+	 *
+	 * @param {CKEDITOR.dom.element} otherElement Element to compare.
+	 * @returns {Boolean}
+	 */
+	isIdentical: function( otherElement ) {
+		// do shallow clones, but with IDs
+		var thisEl = this.clone( 0, 1 ),
+			otherEl = otherElement.clone( 0, 1 );
+
+		// Remove distractions.
+		thisEl.removeAttributes( [ '_moz_dirty', 'data-cke-expando', 'data-cke-saved-href', 'data-cke-saved-name' ] );
+		otherEl.removeAttributes( [ '_moz_dirty', 'data-cke-expando', 'data-cke-saved-href', 'data-cke-saved-name' ] );
+
+		// Native comparison available.
+		if ( thisEl.$.isEqualNode ) {
+			// Styles order matters.
+			thisEl.$.style.cssText = CKEDITOR.tools.normalizeCssText( thisEl.$.style.cssText );
+			otherEl.$.style.cssText = CKEDITOR.tools.normalizeCssText( otherEl.$.style.cssText );
+			return thisEl.$.isEqualNode( otherEl.$ );
+		} else {
+			thisEl = thisEl.getOuterHtml();
+			otherEl = otherEl.getOuterHtml();
+
+			// Fix tiny difference between link href in older IEs.
+			if ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 && this.is( 'a' ) ) {
+				var parent = this.getParent();
+				if ( parent.type == CKEDITOR.NODE_ELEMENT ) {
+					var el = parent.clone();
+					el.setHtml( thisEl ), thisEl = el.getHtml();
+					el.setHtml( otherEl ), otherEl = el.getHtml();
+				}
+			}
+
+			return thisEl == otherEl;
+		}
+	},
+
+	/**
+	 * Checks if this element is visible. May not work if the element is
+	 * child of an element with visibility set to `hidden`, but works well
+	 * on the great majority of cases.
+	 *
+	 * @returns {Boolean} True if the element is visible.
+	 */
+	isVisible: function() {
+		var isVisible = ( this.$.offsetHeight || this.$.offsetWidth ) && this.getComputedStyle( 'visibility' ) != 'hidden',
+			elementWindow, elementWindowFrame;
+
+		// Webkit and Opera report non-zero offsetHeight despite that
+		// element is inside an invisible iframe. (#4542)
+		if ( isVisible && ( CKEDITOR.env.webkit || CKEDITOR.env.opera ) ) {
+			elementWindow = this.getWindow();
+
+			if ( !elementWindow.equals( CKEDITOR.document.getWindow() ) && ( elementWindowFrame = elementWindow.$.frameElement ) )
+				isVisible = new CKEDITOR.dom.element( elementWindowFrame ).isVisible();
+
+		}
+
+		return !!isVisible;
+	},
+
+	/**
+	 * Whether it's an empty inline elements which has no visual impact when removed.
+	 *
+	 * @returns {Boolean}
+	 */
+	isEmptyInlineRemoveable: function() {
+		if ( !CKEDITOR.dtd.$removeEmpty[ this.getName() ] )
+			return false;
+
+		var children = this.getChildren();
+		for ( var i = 0, count = children.count(); i < count; i++ ) {
+			var child = children.getItem( i );
+
+			if ( child.type == CKEDITOR.NODE_ELEMENT && child.data( 'cke-bookmark' ) )
+				continue;
+
+			if ( child.type == CKEDITOR.NODE_ELEMENT && !child.isEmptyInlineRemoveable() || child.type == CKEDITOR.NODE_TEXT && CKEDITOR.tools.trim( child.getText() ) )
+				return false;
+
+		}
+		return true;
+	},
+
+	/**
+	 * Checks if the element has any defined attributes.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div title="Test">Example</div>' );
+	 *		alert( element.hasAttributes() ); // true
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div>Example</div>' );
+	 *		alert( element.hasAttributes() ); // false
+	 *
+	 * @method
+	 * @returns {Boolean} True if the element has attributes.
+	 */
+	hasAttributes: CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) ?
+		function() {
+			var attributes = this.$.attributes;
+
+			for ( var i = 0; i < attributes.length; i++ ) {
+				var attribute = attributes[ i ];
+
+				switch ( attribute.nodeName ) {
+					case 'class':
+						// IE has a strange bug. If calling removeAttribute('className'),
+						// the attributes collection will still contain the "class"
+						// attribute, which will be marked as "specified", even if the
+						// outerHTML of the element is not displaying the class attribute.
+						// Note : I was not able to reproduce it outside the editor,
+						// but I've faced it while working on the TC of #1391.
+						if ( this.getAttribute( 'class' ) )
+							return true;
+
+						// Attributes to be ignored.
+					case 'data-cke-expando':
+						continue;
+
+						/*jsl:fallthru*/
+
+					default:
+						if ( attribute.specified )
+							return true;
+				}
+			}
+
+			return false;
+		} : function() {
+			var attrs = this.$.attributes,
+				attrsNum = attrs.length;
+
+			// The _moz_dirty attribute might get into the element after pasting (#5455)
+			var execludeAttrs = { 'data-cke-expando': 1, _moz_dirty: 1 };
+
+			return attrsNum > 0 && ( attrsNum > 2 || !execludeAttrs[ attrs[ 0 ].nodeName ] || ( attrsNum == 2 && !execludeAttrs[ attrs[ 1 ].nodeName ] ) );
+		},
+
+	/**
+	 * Checks if the specified attribute is defined for this element.
+	 *
+	 * @method
+	 * @param {String} name The attribute name.
+	 * @returns {Boolean} `true` if the specified attribute is defined.
+	 */
+	hasAttribute: ( function() {
+		function standard( name ) {
+			var $attr = this.$.attributes.getNamedItem( name );
+			return !!( $attr && $attr.specified );
+		}
+
+		return ( CKEDITOR.env.ie && CKEDITOR.env.version < 8 ) ?
+		function( name ) {
+			// On IE < 8 the name attribute cannot be retrieved
+			// right after the element creation and setting the
+			// name with setAttribute.
+			if ( name == 'name' )
+				return !!this.$.name;
+
+			return standard.call( this, name );
+		} : standard;
+	} )(),
+
+	/**
+	 * Hides this element (sets `display: none`).
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.hide();
+	 */
+	hide: function() {
+		this.setStyle( 'display', 'none' );
+	},
+
+	/**
+	 * Moves this element's children to the target element.
+	 *
+	 * @param {CKEDITOR.dom.element} target
+	 * @param {Boolean} [toStart=false] Insert moved children at the
+	 * beginning of the target element.
+	 */
+	moveChildren: function( target, toStart ) {
+		var $ = this.$;
+		target = target.$;
+
+		if ( $ == target )
+			return;
+
+		var child;
+
+		if ( toStart ) {
+			while ( ( child = $.lastChild ) )
+				target.insertBefore( $.removeChild( child ), target.firstChild );
+		} else {
+			while ( ( child = $.firstChild ) )
+				target.appendChild( $.removeChild( child ) );
+		}
+	},
+
+	/**
+	 * Merges sibling elements that are identical to this one.
+	 *
+	 * Identical child elements are also merged. For example:
+	 *
+	 *		<b><i></i></b><b><i></i></b> => <b><i></i></b>
+	 *
+	 * @method
+	 * @param {Boolean} [inlineOnly=true] Allow only inline elements to be merged.
+	 */
+	mergeSiblings: ( function() {
+		function mergeElements( element, sibling, isNext ) {
+			if ( sibling && sibling.type == CKEDITOR.NODE_ELEMENT ) {
+				// Jumping over bookmark nodes and empty inline elements, e.g. <b><i></i></b>,
+				// queuing them to be moved later. (#5567)
+				var pendingNodes = [];
+
+				while ( sibling.data( 'cke-bookmark' ) || sibling.isEmptyInlineRemoveable() ) {
+					pendingNodes.push( sibling );
+					sibling = isNext ? sibling.getNext() : sibling.getPrevious();
+					if ( !sibling || sibling.type != CKEDITOR.NODE_ELEMENT )
+						return;
+				}
+
+				if ( element.isIdentical( sibling ) ) {
+					// Save the last child to be checked too, to merge things like
+					// <b><i></i></b><b><i></i></b> => <b><i></i></b>
+					var innerSibling = isNext ? element.getLast() : element.getFirst();
+
+					// Move pending nodes first into the target element.
+					while ( pendingNodes.length )
+						pendingNodes.shift().move( element, !isNext );
+
+					sibling.moveChildren( element, !isNext );
+					sibling.remove();
+
+					// Now check the last inner child (see two comments above).
+					if ( innerSibling && innerSibling.type == CKEDITOR.NODE_ELEMENT )
+						innerSibling.mergeSiblings();
+				}
+			}
+		}
+
+		return function( inlineOnly ) {
+			if ( !( inlineOnly === false || CKEDITOR.dtd.$removeEmpty[ this.getName() ] || this.is( 'a' ) ) ) // Merge empty links and anchors also. (#5567)
+			{
+				return;
+			}
+
+			mergeElements( this, this.getNext(), true );
+			mergeElements( this, this.getPrevious() );
+		};
+	} )(),
+
+	/**
+	 * Shows this element (displays it).
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.show();
+	 */
+	show: function() {
+		this.setStyles( {
+			display: '',
+			visibility: ''
+		} );
+	},
+
+	/**
+	 * Sets the value of an element attribute.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.setAttribute( 'class', 'myClass' );
+	 *		element.setAttribute( 'title', 'This is an example' );
+	 *
+	 * @method
+	 * @param {String} name The name of the attribute.
+	 * @param {String} value The value to be set to the attribute.
+	 * @returns {CKEDITOR.dom.element} This element instance.
+	 */
+	setAttribute: ( function() {
+		var standard = function( name, value ) {
+				this.$.setAttribute( name, value );
+				return this;
+			};
+
+		if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) ) {
+			return function( name, value ) {
+				if ( name == 'class' )
+					this.$.className = value;
+				else if ( name == 'style' )
+					this.$.style.cssText = value;
+				else if ( name == 'tabindex' ) // Case sensitive.
+				this.$.tabIndex = value;
+				else if ( name == 'checked' )
+					this.$.checked = value;
+				else if ( name == 'contenteditable' )
+					standard.call( this, 'contentEditable', value );
+				else
+					standard.apply( this, arguments );
+				return this;
+			};
+		} else if ( CKEDITOR.env.ie8Compat && CKEDITOR.env.secure ) {
+			return function( name, value ) {
+				// IE8 throws error when setting src attribute to non-ssl value. (#7847)
+				if ( name == 'src' && value.match( /^http:\/\// ) )
+					try {
+					standard.apply( this, arguments );
+				} catch ( e ) {} else
+					standard.apply( this, arguments );
+				return this;
+			};
+		} else
+			return standard;
+	} )(),
+
+	/**
+	 * Sets the value of several element attributes.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.setAttributes( {
+	 *			'class':	'myClass',
+	 *			title:		'This is an example'
+	 *		} );
+	 *
+	 * @chainable
+	 * @param {Object} attributesPairs An object containing the names and
+	 * values of the attributes.
+	 * @returns {CKEDITOR.dom.element} This element instance.
+	 */
+	setAttributes: function( attributesPairs ) {
+		for ( var name in attributesPairs )
+			this.setAttribute( name, attributesPairs[ name ] );
+		return this;
+	},
+
+	/**
+	 * Sets the element value. This function is usually used with form
+	 * field element.
+	 *
+	 * @chainable
+	 * @param {String} value The element value.
+	 * @returns {CKEDITOR.dom.element} This element instance.
+	 */
+	setValue: function( value ) {
+		this.$.value = value;
+		return this;
+	},
+
+	/**
+	 * Removes an attribute from the element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div class="classA"></div>' );
+	 *		element.removeAttribute( 'class' );
+	 *
+	 * @method
+	 * @param {String} name The attribute name.
+	 */
+	removeAttribute: ( function() {
+		var standard = function( name ) {
+				this.$.removeAttribute( name );
+			};
+
+		if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) ) {
+			return function( name ) {
+				if ( name == 'class' )
+					name = 'className';
+				else if ( name == 'tabindex' )
+					name = 'tabIndex';
+				else if ( name == 'contenteditable' )
+					name = 'contentEditable';
+				standard.call( this, name );
+			};
+		} else
+			return standard;
+	} )(),
+
+	/**
+	 * Removes all element's attributes or just given ones.
+	 *
+	 * @param {Array} [attributes] The array with attributes names.
+	 */
+	removeAttributes: function( attributes ) {
+		if ( CKEDITOR.tools.isArray( attributes ) ) {
+			for ( var i = 0; i < attributes.length; i++ )
+				this.removeAttribute( attributes[ i ] );
+		} else {
+			for ( var attr in attributes )
+				attributes.hasOwnProperty( attr ) && this.removeAttribute( attr );
+		}
+	},
+
+	/**
+	 * Removes a style from the element.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div style="display:none"></div>' );
+	 *		element.removeStyle( 'display' );
+	 *
+	 * @method
+	 * @param {String} name The style name.
+	 */
+	removeStyle: function( name ) {
+		// Removes the specified property from the current style object.
+		var $ = this.$.style;
+
+		// "removeProperty" need to be specific on the following styles.
+		if ( !$.removeProperty && ( name == 'border' || name == 'margin' || name == 'padding' ) ) {
+			var names = expandedRules( name );
+			for ( var i = 0 ; i < names.length ; i++ )
+				this.removeStyle( names[ i ] );
+			return;
+		}
+
+		$.removeProperty ? $.removeProperty( name ) : $.removeAttribute( CKEDITOR.tools.cssStyleToDomStyle( name ) );
+
+		// Eventually remove empty style attribute.
+		if ( !this.$.style.cssText )
+			this.removeAttribute( 'style' );
+	},
+
+	/**
+	 * Sets the value of an element style.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.setStyle( 'background-color', '#ff0000' );
+	 *		element.setStyle( 'margin-top', '10px' );
+	 *		element.setStyle( 'float', 'right' );
+	 *
+	 * @param {String} name The name of the style. The CSS naming notation
+	 * must be used (e.g. `background-color`).
+	 * @param {String} value The value to be set to the style.
+	 * @returns {CKEDITOR.dom.element} This element instance.
+	 */
+	setStyle: function( name, value ) {
+		this.$.style[ CKEDITOR.tools.cssStyleToDomStyle( name ) ] = value;
+		return this;
+	},
+
+	/**
+	 * Sets the value of several element styles.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.setStyles( {
+	 *			position:	'absolute',
+	 *			float:		'right'
+	 *		} );
+	 *
+	 * @param {Object} stylesPairs An object containing the names and
+	 * values of the styles.
+	 * @returns {CKEDITOR.dom.element} This element instance.
+	 */
+	setStyles: function( stylesPairs ) {
+		for ( var name in stylesPairs )
+			this.setStyle( name, stylesPairs[ name ] );
+		return this;
+	},
+
+	/**
+	 * Sets the opacity of an element.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.setOpacity( 0.75 );
+	 *
+	 * @param {Number} opacity A number within the range `[0.0, 1.0]`.
+	 */
+	setOpacity: function( opacity ) {
+		if ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 ) {
+			opacity = Math.round( opacity * 100 );
+			this.setStyle( 'filter', opacity >= 100 ? '' : 'progid:DXImageTransform.Microsoft.Alpha(opacity=' + opacity + ')' );
+		} else
+			this.setStyle( 'opacity', opacity );
+	},
+
+	/**
+	 * Makes the element and its children unselectable.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.unselectable();
+	 *
+	 * @method
+	 */
+	unselectable: function() {
+		// CSS unselectable.
+		this.setStyles( CKEDITOR.tools.cssVendorPrefix( 'user-select', 'none' ) );
+
+		// For IE/Opera which doesn't support for the above CSS style,
+		// the unselectable="on" attribute only specifies the selection
+		// process cannot start in the element itself, and it doesn't inherit.
+		if ( CKEDITOR.env.ie || CKEDITOR.env.opera ) {
+			this.setAttribute( 'unselectable', 'on' );
+
+			var element,
+				elements = this.getElementsByTag( "*" );
+
+			for ( var i = 0, count = elements.count() ; i < count ; i++ ) {
+				element = elements.getItem( i );
+				element.setAttribute( 'unselectable', 'on' );
+			}
+		}
+	},
+
+	/**
+	 * Gets closest positioned (`position != static`) ancestor.
+	 *
+	 * @returns {CKEDITOR.dom.element} Positioned ancestor or `null`.
+	 */
+	getPositionedAncestor: function() {
+		var current = this;
+		while ( current.getName() != 'html' ) {
+			if ( current.getComputedStyle( 'position' ) != 'static' )
+				return current;
+
+			current = current.getParent();
+		}
+		return null;
+	},
+
+	/**
+	 * Gets this element's position in document.
+	 *
+	 * @param {CKEDITOR.dom.document} [refDocument]
+	 * @returns {Object} Element's position.
+	 * @returns {Number} return.x
+	 * @returns {Number} return.y
+	 * @todo refDocument
+	 */
+	getDocumentPosition: function( refDocument ) {
+		var x = 0,
+			y = 0,
+			doc = this.getDocument(),
+			body = doc.getBody(),
+			quirks = doc.$.compatMode == 'BackCompat';
+
+		if ( document.documentElement[ "getBoundingClientRect" ] ) {
+			var box = this.$.getBoundingClientRect(),
+				$doc = doc.$,
+				$docElem = $doc.documentElement;
+
+			var clientTop = $docElem.clientTop || body.$.clientTop || 0,
+				clientLeft = $docElem.clientLeft || body.$.clientLeft || 0,
+				needAdjustScrollAndBorders = true;
+
+			// #3804: getBoundingClientRect() works differently on IE and non-IE
+			// browsers, regarding scroll positions.
+			//
+			// On IE, the top position of the <html> element is always 0, no matter
+			// how much you scrolled down.
+			//
+			// On other browsers, the top position of the <html> element is negative
+			// scrollTop.
+			if ( CKEDITOR.env.ie ) {
+				var inDocElem = doc.getDocumentElement().contains( this ),
+					inBody = doc.getBody().contains( this );
+
+				needAdjustScrollAndBorders = ( quirks && inBody ) || ( !quirks && inDocElem );
+			}
+
+			if ( needAdjustScrollAndBorders ) {
+				x = box.left + ( !quirks && $docElem.scrollLeft || body.$.scrollLeft );
+				x -= clientLeft;
+				y = box.top + ( !quirks && $docElem.scrollTop || body.$.scrollTop );
+				y -= clientTop;
+			}
+		} else {
+			var current = this,
+				previous = null,
+				offsetParent;
+			while ( current && !( current.getName() == 'body' || current.getName() == 'html' ) ) {
+				x += current.$.offsetLeft - current.$.scrollLeft;
+				y += current.$.offsetTop - current.$.scrollTop;
+
+				// Opera includes clientTop|Left into offsetTop|Left.
+				if ( !current.equals( this ) ) {
+					x += ( current.$.clientLeft || 0 );
+					y += ( current.$.clientTop || 0 );
+				}
+
+				var scrollElement = previous;
+				while ( scrollElement && !scrollElement.equals( current ) ) {
+					x -= scrollElement.$.scrollLeft;
+					y -= scrollElement.$.scrollTop;
+					scrollElement = scrollElement.getParent();
+				}
+
+				previous = current;
+				current = ( offsetParent = current.$.offsetParent ) ? new CKEDITOR.dom.element( offsetParent ) : null;
+			}
+		}
+
+		if ( refDocument ) {
+			var currentWindow = this.getWindow(),
+				refWindow = refDocument.getWindow();
+
+			if ( !currentWindow.equals( refWindow ) && currentWindow.$.frameElement ) {
+				var iframePosition = ( new CKEDITOR.dom.element( currentWindow.$.frameElement ) ).getDocumentPosition( refDocument );
+
+				x += iframePosition.x;
+				y += iframePosition.y;
+			}
+		}
+
+		if ( !document.documentElement[ "getBoundingClientRect" ] ) {
+			// In Firefox, we'll endup one pixel before the element positions,
+			// so we must add it here.
+			if ( CKEDITOR.env.gecko && !quirks ) {
+				x += this.$.clientLeft ? 1 : 0;
+				y += this.$.clientTop ? 1 : 0;
+			}
+		}
+
+		return { x: x, y: y };
+	},
+
+	/**
+	 * Make any page element visible inside the browser viewport.
+	 *
+	 * @param {Boolean} [alignToTop=false]
+	 */
+	scrollIntoView: function( alignToTop ) {
+		var parent = this.getParent();
+		if ( !parent )
+			return;
+
+		// Scroll the element into parent container from the inner out.
+		do {
+			// Check ancestors that overflows.
+			var overflowed =
+				parent.$.clientWidth && parent.$.clientWidth < parent.$.scrollWidth ||
+				parent.$.clientHeight && parent.$.clientHeight < parent.$.scrollHeight;
+
+			// Skip body element, which will report wrong clientHeight when containing
+			// floated content. (#9523)
+			if ( overflowed && !parent.is( 'body' ) )
+				this.scrollIntoParent( parent, alignToTop, 1 );
+
+			// Walk across the frame.
+			if ( parent.is( 'html' ) ) {
+				var win = parent.getWindow();
+
+				// Avoid security error.
+				try {
+					var iframe = win.$.frameElement;
+					iframe && ( parent = new CKEDITOR.dom.element( iframe ) );
+				} catch ( er ) {}
+			}
+		}
+		while ( ( parent = parent.getParent() ) );
+	},
+
+	/**
+	 * Make any page element visible inside one of the ancestors by scrolling the parent.
+	 *
+	 * @param {CKEDITOR.dom.element/CKEDITOR.dom.window} parent The container to scroll into.
+	 * @param {Boolean} [alignToTop] Align the element's top side with the container's
+	 * when `true` is specified; align the bottom with viewport bottom when
+	 * `false` is specified. Otherwise scroll on either side with the minimum
+	 * amount to show the element.
+	 * @param {Boolean} [hscroll] Whether horizontal overflow should be considered.
+	 */
+	scrollIntoParent: function( parent, alignToTop, hscroll ) {
+		!parent && ( parent = this.getWindow() );
+
+		var doc = parent.getDocument();
+		var isQuirks = doc.$.compatMode == 'BackCompat';
+
+		// On window <html> is scrolled while quirks scrolls <body>.
+		if ( parent instanceof CKEDITOR.dom.window )
+			parent = isQuirks ? doc.getBody() : doc.getDocumentElement();
+
+		// Scroll the parent by the specified amount.
+		function scrollBy( x, y ) {
+			// Webkit doesn't support "scrollTop/scrollLeft"
+			// on documentElement/body element.
+			if ( /body|html/.test( parent.getName() ) )
+				parent.getWindow().$.scrollBy( x, y );
+			else {
+				parent.$[ 'scrollLeft' ] += x;
+				parent.$[ 'scrollTop' ] += y;
+			}
+		}
+
+		// Figure out the element position relative to the specified window.
+		function screenPos( element, refWin ) {
+			var pos = { x: 0, y: 0 };
+
+			if ( !( element.is( isQuirks ? 'body' : 'html' ) ) ) {
+				var box = element.$.getBoundingClientRect();
+				pos.x = box.left, pos.y = box.top;
+			}
+
+			var win = element.getWindow();
+			if ( !win.equals( refWin ) ) {
+				var outerPos = screenPos( CKEDITOR.dom.element.get( win.$.frameElement ), refWin );
+				pos.x += outerPos.x, pos.y += outerPos.y;
+			}
+
+			return pos;
+		}
+
+		// calculated margin size.
+		function margin( element, side ) {
+			return parseInt( element.getComputedStyle( 'margin-' + side ) || 0, 10 ) || 0;
+		}
+
+		var win = parent.getWindow();
+
+		var thisPos = screenPos( this, win ),
+			parentPos = screenPos( parent, win ),
+			eh = this.$.offsetHeight,
+			ew = this.$.offsetWidth,
+			ch = parent.$.clientHeight,
+			cw = parent.$.clientWidth,
+			lt, br;
+
+		// Left-top margins.
+		lt = {
+			x: thisPos.x - margin( this, 'left' ) - parentPos.x || 0,
+			y: thisPos.y - margin( this, 'top' ) - parentPos.y || 0
+		};
+
+		// Bottom-right margins.
+		br = {
+			x: thisPos.x + ew + margin( this, 'right' ) - ( ( parentPos.x ) + cw ) || 0,
+			y: thisPos.y + eh + margin( this, 'bottom' ) - ( ( parentPos.y ) + ch ) || 0
+		};
+
+		// 1. Do the specified alignment as much as possible;
+		// 2. Otherwise be smart to scroll only the minimum amount;
+		// 3. Never cut at the top;
+		// 4. DO NOT scroll when already visible.
+		if ( lt.y < 0 || br.y > 0 )
+			scrollBy( 0, alignToTop === true ? lt.y : alignToTop === false ? br.y : lt.y < 0 ? lt.y : br.y );
+
+		if ( hscroll && ( lt.x < 0 || br.x > 0 ) )
+			scrollBy( lt.x < 0 ? lt.x : br.x, 0 );
+	},
+
+	/**
+	 * Switch the `class` attribute to reflect one of the triple states of an
+	 * element in one of {@link CKEDITOR#TRISTATE_ON}, {@link CKEDITOR#TRISTATE_OFF}
+	 * or {@link CKEDITOR#TRISTATE_DISABLED}.
+	 *
+	 *		link.setState( CKEDITOR.TRISTATE_ON );
+	 *		// <a class="cke_on" aria-pressed="true">...</a>
+	 *		link.setState( CKEDITOR.TRISTATE_OFF );
+	 *		// <a class="cke_off">...</a>
+	 *		link.setState( CKEDITOR.TRISTATE_DISABLED );
+	 *		// <a class="cke_disabled" aria-disabled="true">...</a>
+	 *
+	 *		span.setState( CKEDITOR.TRISTATE_ON, 'cke_button' );
+	 *		// <span class="cke_button_on">...</span>
+	 *
+	 * @param {Number} state Indicate the element state. One of {@link CKEDITOR#TRISTATE_ON},
+	 * {@link CKEDITOR#TRISTATE_OFF}, {@link CKEDITOR#TRISTATE_DISABLED}.
+	 * @param [base='cke'] The prefix apply to each of the state class name.
+	 * @param [useAria=true] Whether toggle the ARIA state attributes besides of class name change.
+	 */
+	setState: function( state, base, useAria ) {
+		base = base || 'cke';
+
+		switch ( state ) {
+			case CKEDITOR.TRISTATE_ON:
+				this.addClass( base + '_on' );
+				this.removeClass( base + '_off' );
+				this.removeClass( base + '_disabled' );
+				useAria && this.setAttribute( 'aria-pressed', true );
+				useAria && this.removeAttribute( 'aria-disabled' );
+				break;
+
+			case CKEDITOR.TRISTATE_DISABLED:
+				this.addClass( base + '_disabled' );
+				this.removeClass( base + '_off' );
+				this.removeClass( base + '_on' );
+				useAria && this.setAttribute( 'aria-disabled', true );
+				useAria && this.removeAttribute( 'aria-pressed' );
+				break;
+
+			default:
+				this.addClass( base + '_off' );
+				this.removeClass( base + '_on' );
+				this.removeClass( base + '_disabled' );
+				useAria && this.removeAttribute( 'aria-pressed' );
+				useAria && this.removeAttribute( 'aria-disabled' );
+				break;
+		}
+	},
+
+	/**
+	 * Returns the inner document of this `<iframe>` element.
+	 *
+	 * @returns {CKEDITOR.dom.document} The inner document.
+	 */
+	getFrameDocument: function() {
+		var $ = this.$;
+
+		try {
+			// In IE, with custom document.domain, it may happen that
+			// the iframe is not yet available, resulting in "Access
+			// Denied" for the following property access.
+			$.contentWindow.document;
+		} catch ( e ) {
+			// Trick to solve this issue, forcing the iframe to get ready
+			// by simply setting its "src" property.
+			$.src = $.src;
+		}
+
+		return $ && new CKEDITOR.dom.document( $.contentWindow.document );
+	},
+
+	/**
+	 * Copy all the attributes from one node to the other, kinda like a clone
+	 * skipAttributes is an object with the attributes that must **not** be copied.
+	 *
+	 * @param {CKEDITOR.dom.element} dest The destination element.
+	 * @param {Object} skipAttributes A dictionary of attributes to skip.
+	 */
+	copyAttributes: function( dest, skipAttributes ) {
+		var attributes = this.$.attributes;
+		skipAttributes = skipAttributes || {};
+
+		for ( var n = 0; n < attributes.length; n++ ) {
+			var attribute = attributes[ n ];
+
+			// Lowercase attribute name hard rule is broken for
+			// some attribute on IE, e.g. CHECKED.
+			var attrName = attribute.nodeName.toLowerCase(),
+				attrValue;
+
+			// We can set the type only once, so do it with the proper value, not copying it.
+			if ( attrName in skipAttributes )
+				continue;
+
+			if ( attrName == 'checked' && ( attrValue = this.getAttribute( attrName ) ) )
+				dest.setAttribute( attrName, attrValue );
+			// IE BUG: value attribute is never specified even if it exists.
+			else if ( attribute.specified || ( CKEDITOR.env.ie && attribute.nodeValue && attrName == 'value' ) ) {
+				attrValue = this.getAttribute( attrName );
+				if ( attrValue === null )
+					attrValue = attribute.nodeValue;
+
+				dest.setAttribute( attrName, attrValue );
+			}
+		}
+
+		// The style:
+		if ( this.$.style.cssText !== '' )
+			dest.$.style.cssText = this.$.style.cssText;
+	},
+
+	/**
+	 * Changes the tag name of the current element.
+	 *
+	 * @param {String} newTag The new tag for the element.
+	 */
+	renameNode: function( newTag ) {
+		// If it's already correct exit here.
+		if ( this.getName() == newTag )
+			return;
+
+		var doc = this.getDocument();
+
+		// Create the new node.
+		var newNode = new CKEDITOR.dom.element( newTag, doc );
+
+		// Copy all attributes.
+		this.copyAttributes( newNode );
+
+		// Move children to the new node.
+		this.moveChildren( newNode );
+
+		// Replace the node.
+		this.getParent() && this.$.parentNode.replaceChild( newNode.$, this.$ );
+		newNode.$[ 'data-cke-expando' ] = this.$[ 'data-cke-expando' ];
+		this.$ = newNode.$;
+		// Bust getName's cache. (#8663)
+		delete this.getName;
+	},
+
+	/**
+	 * Gets a DOM tree descendant under the current node.
+	 *
+	 *		var strong = p.getChild( 0 );
+	 *
+	 * @method
+	 * @param {Array/Number} indices The child index or array of child indices under the node.
+	 * @returns {CKEDITOR.dom.node} The specified DOM child under the current node. Null if child does not exist.
+	 */
+	getChild: ( function() {
+		function getChild( rawNode, index ) {
+			var childNodes = rawNode.childNodes;
+
+			if ( index >= 0 && index < childNodes.length )
+				return childNodes[ index ];
+		}
+
+		return function( indices ) {
+			var rawNode = this.$;
+
+			if ( !indices.slice )
+				rawNode = getChild( rawNode, indices );
+			else {
+				while ( indices.length > 0 && rawNode )
+					rawNode = getChild( rawNode, indices.shift() );
+			}
+
+			return rawNode ? new CKEDITOR.dom.node( rawNode ) : null;
+		};
+	} )(),
+
+	/**
+	 * Gets number of element's children.
+	 *
+	 * @returns {Number}
+	 */
+	getChildCount: function() {
+		return this.$.childNodes.length;
+	},
+
+	/**
+	 * Disables browser's context menu in this element.
+	 */
+	disableContextMenu: function() {
+		this.on( 'contextmenu', function( event ) {
+			// Cancel the browser context menu.
+			if ( !event.data.getTarget().hasClass( 'cke_enable_context_menu' ) )
+				event.data.preventDefault();
+		} );
+	},
+
+	/**
+	 * Gets element's direction. Supports both CSS `direction` prop and `dir` attr.
+	 */
+	getDirection: function( useComputed ) {
+		if ( useComputed ) {
+			return this.getComputedStyle( 'direction' ) ||
+					this.getDirection() ||
+					this.getParent() && this.getParent().getDirection( 1 ) ||
+					this.getDocument().$.dir ||
+					'ltr';
+		}
+		else
+			return this.getStyle( 'direction' ) || this.getAttribute( 'dir' );
+	},
+
+	/**
+	 * Gets, sets and removes custom data to be stored as HTML5 data-* attributes.
+	 *
+	 *		element.data( 'extra-info', 'test' );	// Appended the attribute data-extra-info="test" to the element.
+	 *		alert( element.data( 'extra-info' ) );	// 'test'
+	 *		element.data( 'extra-info', false );	// Remove the data-extra-info attribute from the element.
+	 *
+	 * @param {String} name The name of the attribute, excluding the `data-` part.
+	 * @param {String} [value] The value to set. If set to false, the attribute will be removed.
+	 */
+	data: function( name, value ) {
+		name = 'data-' + name;
+		if ( value === undefined )
+			return this.getAttribute( name );
+		else if ( value === false )
+			this.removeAttribute( name );
+		else
+			this.setAttribute( name, value );
+
+		return null;
+	},
+
+	/**
+	 * Retrieves an editor instance which is based on this element (if any).
+	 * It basically loops over {@link CKEDITOR#instances} in search for an instance
+	 * that uses the element.
+	 *
+	 *		var element = new CKEDITOR.dom.element( 'div' );
+	 *		element.appendTo( CKEDITOR.document.getBody() );
+	 *		CKEDITOR.replace( element );
+	 *		alert( element.getEditor().name ); // 'editor1'
+	 *
+	 * @returns {CKEDITOR.editor} An editor instance or null if nothing has been found.
+	 */
+	getEditor: function() {
+		var instances = CKEDITOR.instances,
+			name, instance;
+
+		for ( name in instances ) {
+			instance = instances[ name ];
+
+			if ( instance.element.equals( this ) && instance.elementMode != CKEDITOR.ELEMENT_MODE_APPENDTO )
+				return instance;
+		}
+
+		return null;
+	},
+
+	/**
+	 * Returns list of elements within this element that match specified `selector`.
+	 *
+	 * **Notes:**
+	 *
+	 *	* Not available in IE7.
+	 *	* Returned list is not a live collection (like a result of native `querySelectorAll`).
+	 *	* Unlike native `querySelectorAll` this method ensures selector contextualization. This is:
+	 *
+	 *			HTML:		'<body><div><i>foo</i></div></body>'
+	 *			Native:		div.querySelectorAll( 'body i' ) // ->		[ <i>foo</i> ]
+	 *			Method:		div.find( 'body i' ) // ->					[]
+	 *						div.find( 'i' ) // ->						[ <i>foo</i> ]
+	 *
+	 * @since 4.3
+	 * @param {String} selector
+	 * @returns {CKEDITOR.dom.nodeList}
+	 */
+	find: function( selector ) {
+		var removeTmpId = createTmpId( this ),
+			list = new CKEDITOR.dom.nodeList(
+				this.$.querySelectorAll( getContextualizedSelector( this, selector ) )
+			);
+
+		removeTmpId();
+
+		return list;
+	},
+
+	/**
+	 * Returns first element within this element that matches specified `selector`.
+	 *
+	 * **Notes:**
+	 *
+	 *	* Not available in IE7.
+	 *	* Unlike native `querySelectorAll` this method ensures selector contextualization. This is:
+	 *
+	 *			HTML:		'<body><div><i>foo</i></div></body>'
+	 *			Native:		div.querySelector( 'body i' ) // ->			<i>foo</i>
+	 *			Method:		div.findOne( 'body i' ) // ->				null
+	 *						div.findOne( 'i' ) // ->					<i>foo</i>
+	 *
+	 * @since 4.3
+	 * @param {String} selector
+	 * @returns {CKEDITOR.dom.element}
+	 */
+	findOne: function( selector ) {
+		var removeTmpId = createTmpId( this ),
+			found = this.$.querySelector( getContextualizedSelector( this, selector ) );
+
+		removeTmpId();
+
+		return found ? new CKEDITOR.dom.element( found ) : null;
+	},
+
+	/**
+	 * Traverse the DOM of this element (inclusive), executing a callback for
+	 * each node.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div><p>foo<b>bar</b>bom</p></div>' );
+	 *		element.forEach( function( node ) {
+	 *			console.log( node );
+	 *		} );
+	 *		// Will log:
+	 *		// 1. <div> element,
+	 *		// 2. <p> element,
+	 *		// 3. "foo" text node,
+	 *		// 4. <b> element,
+	 *		// 5. "bar" text node,
+	 *		// 6. "bom" text node.
+	 *
+	 * @since 4.3
+	 * @param {Function} callback Function to be executed on every node.
+	 * If `callback` returns `false` descendants of the node will be ignored.
+	 * @param {CKEDITOR.htmlParser.node} callback.node Node passed as argument.
+	 * @param {Number} [type] If specified `callback` will be executed only on
+	 * nodes of this type.
+	 * @param {Boolean} [skipRoot] Don't execute `callback` on this element.
+	 */
+	forEach: function( callback, type, skipRoot ) {
+		if ( !skipRoot && ( !type || this.type == type ) )
+				var ret = callback( this );
+
+		// Do not filter children if callback returned false.
+		if ( ret === false )
+			return;
+
+		var children = this.getChildren(),
+			node,
+			i = 0;
+
+		// We do not cache the size, because the live list of nodes may be changed by the callback.
+		for ( ; i < children.count(); i++ ) {
+			node = children.getItem( i );
+			if ( node.type == CKEDITOR.NODE_ELEMENT )
+				node.forEach( callback, type );
+			else if ( !type || node.type == type )
+				callback( node );
+		}
+	}
+} );
+
+	function createTmpId( element ) {
+		var hadId = true;
+
+		if ( !element.$.id ) {
+			element.$.id = 'cke_tmp_' + CKEDITOR.tools.getNextNumber();
+			hadId = false;
+		}
+
+		return function() {
+			if ( !hadId )
+				element.removeAttribute( 'id' );
+		};
+	}
+
+	function getContextualizedSelector( element, selector ) {
+		return '#' + element.$.id + ' ' + selector.split( /,\s*/ ).join( ', #' + element.$.id + ' ' );
+	}
+
+	var sides = {
+		width: [ 'border-left-width', 'border-right-width', 'padding-left', 'padding-right' ],
+		height: [ 'border-top-width', 'border-bottom-width', 'padding-top', 'padding-bottom' ]
+	};
+
+	// Generate list of specific style rules, applicable to margin/padding/border.
+	function expandedRules( style ) {
+		var sides = [ 'top', 'left', 'right', 'bottom' ], components;
+
+		if ( style == 'border' )
+				components = [ 'color', 'style', 'width' ];
+
+		var styles = [];
+		for ( var i = 0 ; i < sides.length ; i++ ) {
+
+			if ( components ) {
+				for ( var j = 0 ; j < components.length ; j++ )
+					styles.push( [ style, sides[ i ], components[ j ] ].join( '-' ) );
+			}
+			else
+				styles.push( [ style, sides[ i ] ].join( '-' ) );
+		}
+
+		return styles;
+	}
+
+	function marginAndPaddingSize( type ) {
+		var adjustment = 0;
+		for ( var i = 0, len = sides[ type ].length; i < len; i++ )
+			adjustment += parseInt( this.getComputedStyle( sides[ type ][ i ] ) || 0, 10 ) || 0;
+		return adjustment;
+	}
+
+	/**
+	 * Sets the element size considering the box model.
+	 *
+	 * @param {'width'/'height'} type The dimension to set.
+	 * @param {Number} size The length unit in px.
+	 * @param {Boolean} isBorderBox Apply the size based on the border box model.
+	 */
+	CKEDITOR.dom.element.prototype.setSize = function( type, size, isBorderBox ) {
+		if ( typeof size == 'number' ) {
+			if ( isBorderBox && !( CKEDITOR.env.ie && CKEDITOR.env.quirks ) )
+				size -= marginAndPaddingSize.call( this, type );
+
+			this.setStyle( type, size + 'px' );
+		}
+	};
+
+	/**
+	 * Gets the element size, possibly considering the box model.
+	 *
+	 * @param {'width'/'height'} type The dimension to get.
+	 * @param {Boolean} isBorderBox Get the size based on the border box model.
+	 */
+	CKEDITOR.dom.element.prototype.getSize = function( type, isBorderBox ) {
+		var size = Math.max( this.$[ 'offset' + CKEDITOR.tools.capitalize( type ) ], this.$[ 'client' + CKEDITOR.tools.capitalize( type ) ] ) || 0;
+
+		if ( isBorderBox )
+			size -= marginAndPaddingSize.call( this, type );
+
+		return size;
+	};
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/elementpath.js b/lam/templates/lib/extra/ckeditor/core/dom/elementpath.js
new file mode 100644
index 00000000..db807237
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/elementpath.js
@@ -0,0 +1,251 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+'use strict';
+
+( function() {
+
+	var pathBlockLimitElements = {},
+		pathBlockElements = {},
+		tag;
+
+	// Elements that are considered the "Block limit" in an element path.
+	for ( tag in CKEDITOR.dtd.$blockLimit ) {
+		// Exclude from list roots.
+		if ( !( tag in CKEDITOR.dtd.$list ) )
+			pathBlockLimitElements[ tag ] = 1;
+	}
+
+	// Elements that are considered the "End level Block" in an element path.
+	for ( tag in CKEDITOR.dtd.$block ) {
+		// Exclude block limits, and empty block element, e.g. hr.
+		if ( !( tag in CKEDITOR.dtd.$blockLimit || tag in CKEDITOR.dtd.$empty ) )
+			pathBlockElements[ tag ] = 1;
+	}
+
+	// Check if an element contains any block element.
+	function checkHasBlock( element ) {
+		var childNodes = element.getChildren();
+
+		for ( var i = 0, count = childNodes.count(); i < count; i++ ) {
+			var child = childNodes.getItem( i );
+
+			if ( child.type == CKEDITOR.NODE_ELEMENT && CKEDITOR.dtd.$block[ child.getName() ] )
+				return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Retrieve the list of nodes walked from the start node up to the editable element of the editor.
+	 *
+	 * @class
+	 * @constructor Creates an element path class instance.
+	 * @param {CKEDITOR.dom.element} startNode From which the path should start.
+	 * @param {CKEDITOR.dom.element} root To which element the path should stop, defaults to the `body` element.
+	 */
+	CKEDITOR.dom.elementPath = function( startNode, root ) {
+		var block = null,
+			blockLimit = null,
+			elements = [],
+			e = startNode,
+			elementName;
+
+		// Backward compact.
+		root = root || startNode.getDocument().getBody();
+
+		do {
+			if ( e.type == CKEDITOR.NODE_ELEMENT ) {
+				elements.push( e );
+
+				if ( !this.lastElement ) {
+					this.lastElement = e;
+
+					// If an object or non-editable element is fully selected at the end of the element path,
+					// it must not become the block limit.
+					if ( e.is( CKEDITOR.dtd.$object ) || e.getAttribute( 'contenteditable' ) == 'false' )
+						continue;
+				}
+
+				if ( e.equals( root ) )
+					break;
+
+				if ( !blockLimit ) {
+					elementName = e.getName();
+
+					// First editable element becomes a block limit, because it cannot be split.
+					if ( e.getAttribute( 'contenteditable' ) == 'true' )
+						blockLimit = e;
+					// "Else" because element cannot be both - block and block levelimit.
+					else if ( !block && pathBlockElements[ elementName ] )
+						block = e;
+
+					if ( pathBlockLimitElements[ elementName ] ) {
+						// End level DIV is considered as the block, if no block is available. (#525)
+						// But it must NOT be the root element (checked above).
+						if ( !block && elementName == 'div' && !checkHasBlock( e ) )
+							block = e;
+						else
+							blockLimit = e;
+					}
+				}
+			}
+		}
+		while ( ( e = e.getParent() ) );
+
+		// Block limit defaults to root.
+		if ( !blockLimit )
+			blockLimit = root;
+
+		/**
+		 * First non-empty block element which:
+		 *
+		 * * is not a {@link CKEDITOR.dtd#$blockLimit},
+		 * * or is a `div` which does not contain block elements and is not a `root`.
+		 *
+		 * This means a first, splittable block in elements path.
+		 *
+		 * @readonly
+		 * @property {CKEDITOR.dom.element}
+		 */
+		this.block = block;
+
+		/**
+		 * See the {@link CKEDITOR.dtd#$blockLimit} description.
+		 *
+		 * @readonly
+		 * @property {CKEDITOR.dom.element}
+		 */
+		this.blockLimit = blockLimit;
+
+		/**
+		 * The root of the elements path - `root` argument passed to class constructor or a `body` element.
+		 *
+		 * @readonly
+		 * @property {CKEDITOR.dom.element}
+		 */
+		this.root = root;
+
+		/**
+		 * An array of elements (from `startNode` to `root`) in the path.
+		 *
+		 * @readonly
+		 * @property {CKEDITOR.dom.element[]}
+		 */
+		this.elements = elements;
+
+		/**
+		 * The last element of the elements path - `startNode` or its parent.
+		 *
+		 * @readonly
+		 * @property {CKEDITOR.dom.element} lastElement
+		 */
+	};
+
+} )();
+
+CKEDITOR.dom.elementPath.prototype = {
+	/**
+	 * Compares this element path with another one.
+	 *
+	 * @param {CKEDITOR.dom.elementPath} otherPath The elementPath object to be
+	 * compared with this one.
+	 * @returns {Boolean} `true` if the paths are equal, containing the same
+	 * number of elements and the same elements in the same order.
+	 */
+	compare: function( otherPath ) {
+		var thisElements = this.elements;
+		var otherElements = otherPath && otherPath.elements;
+
+		if ( !otherElements || thisElements.length != otherElements.length )
+			return false;
+
+		for ( var i = 0; i < thisElements.length; i++ ) {
+			if ( !thisElements[ i ].equals( otherElements[ i ] ) )
+				return false;
+		}
+
+		return true;
+	},
+
+	/**
+	 * Search the path elements that meets the specified criteria.
+	 *
+	 * @param {String/Array/Function/Object/CKEDITOR.dom.element} query The criteria that can be
+	 * either a tag name, list (array and object) of tag names, element or an node evaluator function.
+	 * @param {Boolean} [excludeRoot] Not taking path root element into consideration.
+	 * @param {Boolean} [fromTop] Search start from the topmost element instead of bottom.
+	 * @returns {CKEDITOR.dom.element} The first matched dom element or `null`.
+	 */
+	contains: function( query, excludeRoot, fromTop ) {
+		var evaluator;
+		if ( typeof query == 'string' )
+			evaluator = function( node ) {
+				return node.getName() == query;
+			};
+		if ( query instanceof CKEDITOR.dom.element )
+			evaluator = function( node ) {
+				return node.equals( query );
+			};
+		else if ( CKEDITOR.tools.isArray( query ) )
+			evaluator = function( node ) {
+				return CKEDITOR.tools.indexOf( query, node.getName() ) > -1;
+			};
+		else if ( typeof query == 'function' )
+			evaluator = query;
+		else if ( typeof query == 'object' )
+			evaluator = function( node ) {
+				return node.getName() in query;
+			};
+
+		var elements = this.elements,
+			length = elements.length;
+		excludeRoot && length--;
+
+		if ( fromTop ) {
+			elements = Array.prototype.slice.call( elements, 0 );
+			elements.reverse();
+		}
+
+		for ( var i = 0; i < length; i++ ) {
+			if ( evaluator( elements[ i ] ) )
+				return elements[ i ];
+		}
+
+		return null;
+	},
+
+	/**
+	 * Check whether the elements path is the proper context for the specified
+	 * tag name in the DTD.
+	 *
+	 * @param {String} tag The tag name.
+	 * @returns {Boolean}
+	 */
+	isContextFor: function( tag ) {
+		var holder;
+
+		// Check for block context.
+		if ( tag in CKEDITOR.dtd.$block ) {
+			// Indeterminate elements which are not subjected to be splitted or surrounded must be checked first.
+			var inter = this.contains( CKEDITOR.dtd.$intermediate );
+			holder = inter || ( this.root.equals( this.block ) && this.block ) || this.blockLimit;
+			return !!holder.getDtd()[ tag ];
+		}
+
+		return true;
+	},
+
+	/**
+	 * Retrieve the text direction for this elements path.
+	 *
+	 * @returns {'ltr'/'rtl'}
+	 */
+	direction: function() {
+		var directionNode = this.block || this.blockLimit || this.root;
+		return directionNode.getDirection( 1 );
+	}
+};
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/event.js b/lam/templates/lib/extra/ckeditor/core/dom/event.js
new file mode 100644
index 00000000..54a8cefa
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/event.js
@@ -0,0 +1,208 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.event} class, which
+ *		represents the a native DOM event object.
+ */
+
+/**
+ * Represents a native DOM event object.
+ *
+ * @class
+ * @constructor Creates an event class instance.
+ * @param {Object} domEvent A native DOM event object.
+ */
+CKEDITOR.dom.event = function( domEvent ) {
+	/**
+	 * The native DOM event object represented by this class instance.
+	 *
+	 * @readonly
+	 */
+	this.$ = domEvent;
+};
+
+CKEDITOR.dom.event.prototype = {
+	/**
+	 * Gets the key code associated to the event.
+	 *
+	 *		alert( event.getKey() ); // '65' is 'a' has been pressed
+	 *
+	 * @returns {Number} The key code.
+	 */
+	getKey: function() {
+		return this.$.keyCode || this.$.which;
+	},
+
+	/**
+	 * Gets a number represeting the combination of the keys pressed during the
+	 * event. It is the sum with the current key code and the {@link CKEDITOR#CTRL},
+	 * {@link CKEDITOR#SHIFT} and {@link CKEDITOR#ALT} constants.
+	 *
+	 *		alert( event.getKeystroke() == 65 );									// 'a' key
+	 *		alert( event.getKeystroke() == CKEDITOR.CTRL + 65 );					// CTRL + 'a' key
+	 *		alert( event.getKeystroke() == CKEDITOR.CTRL + CKEDITOR.SHIFT + 65 );	// CTRL + SHIFT + 'a' key
+	 *
+	 * @returns {Number} The number representing the keys combination.
+	 */
+	getKeystroke: function() {
+		var keystroke = this.getKey();
+
+		if ( this.$.ctrlKey || this.$.metaKey )
+			keystroke += CKEDITOR.CTRL;
+
+		if ( this.$.shiftKey )
+			keystroke += CKEDITOR.SHIFT;
+
+		if ( this.$.altKey )
+			keystroke += CKEDITOR.ALT;
+
+		return keystroke;
+	},
+
+	/**
+	 * Prevents the original behavior of the event to happen. It can optionally
+	 * stop propagating the event in the event chain.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.on( 'click', function( ev ) {
+	 *			// The DOM event object is passed by the 'data' property.
+	 *			var domEvent = ev.data;
+	 *			// Prevent the click to chave any effect in the element.
+	 *			domEvent.preventDefault();
+	 *		} );
+	 *
+	 * @param {Boolean} [stopPropagation=false] Stop propagating this event in the
+	 * event chain.
+	 */
+	preventDefault: function( stopPropagation ) {
+		var $ = this.$;
+		if ( $.preventDefault )
+			$.preventDefault();
+		else
+			$.returnValue = false;
+
+		if ( stopPropagation )
+			this.stopPropagation();
+	},
+
+	/**
+	 * Stops this event propagation in the event chain.
+	 */
+	stopPropagation: function() {
+		var $ = this.$;
+		if ( $.stopPropagation )
+			$.stopPropagation();
+		else
+			$.cancelBubble = true;
+	},
+
+	/**
+	 * Returns the DOM node where the event was targeted to.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'myElement' );
+	 *		element.on( 'click', function( ev ) {
+	 *			// The DOM event object is passed by the 'data' property.
+	 *			var domEvent = ev.data;
+	 *			// Add a CSS class to the event target.
+	 *			domEvent.getTarget().addClass( 'clicked' );
+	 *		} );
+	 *
+	 * @returns {CKEDITOR.dom.node} The target DOM node.
+	 */
+	getTarget: function() {
+		var rawNode = this.$.target || this.$.srcElement;
+		return rawNode ? new CKEDITOR.dom.node( rawNode ) : null;
+	},
+
+	/**
+	 * Returns an integer value that indicates the current processing phase of an event.
+	 * For browsers that doesn't support event phase, {@link CKEDITOR#EVENT_PHASE_AT_TARGET} is always returned.
+	 *
+	 * @returns {Number} One of {@link CKEDITOR#EVENT_PHASE_CAPTURING},
+	 * {@link CKEDITOR#EVENT_PHASE_AT_TARGET}, or {@link CKEDITOR#EVENT_PHASE_BUBBLING}.
+	 */
+	getPhase: function() {
+		return this.$.eventPhase || 2;
+	},
+
+	/**
+	 * Retrieves the coordinates of the mouse pointer relative to the top-left
+	 * corner of the document, in mouse related event.
+	 *
+	 *		element.on( 'mousemouse', function( ev ) {
+	 *			var pageOffset = ev.data.getPageOffset();
+	 *			alert( pageOffset.x );			// page offset X
+	 *			alert( pageOffset.y );			// page offset Y
+	 *     } );
+	 *
+	 * @returns {Object} The object contains the position.
+	 * @returns {Number} return.x
+	 * @returns {Number} return.y
+	 */
+	getPageOffset : function() {
+		var doc = this.getTarget().getDocument().$;
+		var pageX = this.$.pageX || this.$.clientX + ( doc.documentElement.scrollLeft || doc.body.scrollLeft );
+		var pageY = this.$.pageY || this.$.clientY + ( doc.documentElement.scrollTop || doc.body.scrollTop );
+		return { x : pageX, y : pageY };
+	}
+};
+
+// For the followind constants, we need to go over the Unicode boundaries
+// (0x10FFFF) to avoid collision.
+
+/**
+ * CTRL key (0x110000).
+ *
+ * @readonly
+ * @property {Number} [=0x110000]
+ * @member CKEDITOR
+ */
+CKEDITOR.CTRL = 0x110000;
+
+/**
+ * SHIFT key (0x220000).
+ *
+ * @readonly
+ * @property {Number} [=0x220000]
+ * @member CKEDITOR
+ */
+CKEDITOR.SHIFT = 0x220000;
+
+/**
+ * ALT key (0x440000).
+ *
+ * @readonly
+ * @property {Number} [=0x440000]
+ * @member CKEDITOR
+ */
+CKEDITOR.ALT = 0x440000;
+
+/**
+ * Capturing phase.
+ *
+ * @readonly
+ * @property {Number} [=1]
+ * @member CKEDITOR
+ */
+CKEDITOR.EVENT_PHASE_CAPTURING = 1;
+
+/**
+ * Event at target.
+ *
+ * @readonly
+ * @property {Number} [=2]
+ * @member CKEDITOR
+ */
+CKEDITOR.EVENT_PHASE_AT_TARGET = 2;
+
+/**
+ * Bubbling phase.
+ *
+ * @readonly
+ * @property {Number} [=3]
+ * @member CKEDITOR
+ */
+CKEDITOR.EVENT_PHASE_BUBBLING = 3;
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/iterator.js b/lam/templates/lib/extra/ckeditor/core/dom/iterator.js
new file mode 100644
index 00000000..1c5aea04
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/iterator.js
@@ -0,0 +1,500 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @ignore
+ * File overview: DOM iterator, which iterates over list items, lines and paragraphs.
+ */
+
+'use strict';
+
+( function() {
+	/**
+	 * Represents iterator class. It can be used to iterate
+	 * over all elements (or even text nodes in case of {@link #enlargeBr} set to `false`)
+	 * which establish "paragraph-like" spaces within passed range.
+	 *
+	 *		// <h1>[foo</h1><p>bar]</p>
+	 *		var iterator = range.createIterator();
+	 *		iterator.getNextParagraph(); // h1 element
+	 *		iterator.getNextParagraph(); // p element
+	 *
+	 *		// <ul><li>[foo</li><li>bar]</li>
+	 *		// With enforceRealBlocks set to false iterator will return two list item elements.
+	 *		// With enforceRealBlocks set to true iterator will return two paragraphs and the DOM will be changed to:
+	 *		// <ul><li><p>foo</p></li><li><p>bar</p></li>
+	 *
+	 * @class CKEDITOR.dom.iterator
+	 * @constructor Creates an iterator class instance.
+	 * @param {CKEDITOR.dom.range} range
+	 */
+	function iterator( range ) {
+		if ( arguments.length < 1 )
+			return;
+
+		this.range = range;
+		this.forceBrBreak = 0;
+
+		// (#3730).
+		/**
+		 * Whether include `<br>`s into the enlarged range. Should be
+		 * set to `false` when using iterator in {@link CKEDITOR#ENTER_BR} mode.
+		 *
+		 * @property {Boolean} [enlargeBr=true]
+		 */
+		this.enlargeBr = 1;
+
+		/**
+		 * Whether iterator should create transformable block
+		 * if the current one contains text and it cannot be transformed.
+		 * For example new blocks will be established in elements like
+		 * `<li>` or `<td>`.
+		 *
+		 * @property {Boolean} [enforceRealBlocks=false]
+		 */
+		this.enforceRealBlocks = 0;
+
+		this._ || ( this._ = {} );
+	}
+
+	/**
+	 * Default iterator's filter. It is set only for nested iterators.
+	 *
+	 * @since 4.3
+	 * @readonly
+	 * @property {CKEDITOR.filter} filter
+	 */
+
+	/**
+	 * Iterator's active filter. It is set by the {@link #getNextParagraph} method
+	 * when it enters nested editable.
+	 *
+	 * @since 4.3
+	 * @readonly
+	 * @property {CKEDITOR.filter} activeFilter
+	 */
+
+	var beginWhitespaceRegex = /^[\r\n\t ]+$/,
+		// Ignore bookmark nodes.(#3783)
+		bookmarkGuard = CKEDITOR.dom.walker.bookmark( false, true ),
+		whitespacesGuard = CKEDITOR.dom.walker.whitespaces( true ),
+		skipGuard = function( node ) {
+			return bookmarkGuard( node ) && whitespacesGuard( node );
+		};
+
+	// Get a reference for the next element, bookmark nodes are skipped.
+	function getNextSourceNode( node, startFromSibling, lastNode ) {
+		var next = node.getNextSourceNode( startFromSibling, null, lastNode );
+		while ( !bookmarkGuard( next ) )
+			next = next.getNextSourceNode( startFromSibling, null, lastNode );
+		return next;
+	}
+
+	iterator.prototype = {
+		/**
+		 * Returns next paragraph-like element or `null` if reached the end of range.
+		 *
+		 * @param {String} [blockTag='p'] Name of a block element which will be established by
+		 * iterator in block-less elements (see {@link #enforceRealBlocks}).
+		 */
+		getNextParagraph: function( blockTag ) {
+			// The block element to be returned.
+			var block;
+
+			// The range object used to identify the paragraph contents.
+			var range;
+
+			// Indicats that the current element in the loop is the last one.
+			var isLast;
+
+			// Instructs to cleanup remaining BRs.
+			var removePreviousBr, removeLastBr;
+
+			blockTag = blockTag || 'p';
+
+			// We're iterating over nested editable.
+			if ( this._.nestedEditable ) {
+				// Get next block from nested iterator and returns it if was found.
+				block = this._.nestedEditable.iterator.getNextParagraph( blockTag );
+				if ( block ) {
+					// Inherit activeFilter from the nested iterator.
+					this.activeFilter = this._.nestedEditable.iterator.activeFilter;
+					return block;
+				}
+
+				// No block in nested iterator means that we reached the end of the nested editable.
+				// Reset the active filter to the default filter (or undefined if this iterator didn't have it).
+				this.activeFilter = this.filter;
+
+				// Try to find next nested editable or get back to parent (this) iterator.
+				if ( startNestedEditableIterator( this, blockTag, this._.nestedEditable.container, this._.nestedEditable.remaining ) ) {
+					// Inherit activeFilter from the nested iterator.
+					this.activeFilter = this._.nestedEditable.iterator.activeFilter;
+					return this._.nestedEditable.iterator.getNextParagraph( blockTag );
+				} else
+					this._.nestedEditable = null;
+			}
+
+			// Block-less range should be checked first.
+			if ( !this.range.root.getDtd()[ blockTag ] )
+				return null;
+
+			// This is the first iteration. Let's initialize it.
+			if ( !this._.started )
+				range = startIterator.call( this );
+
+			var currentNode = this._.nextNode,
+				lastNode = this._.lastNode;
+
+			this._.nextNode = null;
+			while ( currentNode ) {
+				// closeRange indicates that a paragraph boundary has been found,
+				// so the range can be closed.
+				var closeRange = 0,
+					parentPre = currentNode.hasAscendant( 'pre' );
+
+				// includeNode indicates that the current node is good to be part
+				// of the range. By default, any non-element node is ok for it.
+				var includeNode = ( currentNode.type != CKEDITOR.NODE_ELEMENT ),
+					continueFromSibling = 0;
+
+				// If it is an element node, let's check if it can be part of the range.
+				if ( !includeNode ) {
+					var nodeName = currentNode.getName();
+
+					// Non-editable block was found - return it and move to processing
+					// its nested editables if they exist.
+					if ( CKEDITOR.dtd.$block[ nodeName ] && currentNode.getAttribute( 'contenteditable' ) == 'false' ) {
+						block = currentNode;
+
+						// Setup iterator for first of nested editables.
+						// If there's no editable, then algorithm will move to next element after current block.
+						startNestedEditableIterator( this, blockTag, block );
+
+						// Gets us straight to the end of getParagraph() because block variable is set.
+						break;
+					} else if ( currentNode.isBlockBoundary( this.forceBrBreak && !parentPre && { br: 1 } ) ) {
+						// <br> boundaries must be part of the range. It will
+						// happen only if ForceBrBreak.
+						if ( nodeName == 'br' )
+							includeNode = 1;
+						else if ( !range && !currentNode.getChildCount() && nodeName != 'hr' ) {
+							// If we have found an empty block, and haven't started
+							// the range yet, it means we must return this block.
+							block = currentNode;
+							isLast = currentNode.equals( lastNode );
+							break;
+						}
+
+						// The range must finish right before the boundary,
+						// including possibly skipped empty spaces. (#1603)
+						if ( range ) {
+							range.setEndAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+
+							// The found boundary must be set as the next one at this
+							// point. (#1717)
+							if ( nodeName != 'br' )
+								this._.nextNode = currentNode;
+						}
+
+						closeRange = 1;
+					} else {
+						// If we have child nodes, let's check them.
+						if ( currentNode.getFirst() ) {
+							// If we don't have a range yet, let's start it.
+							if ( !range ) {
+								range = this.range.clone();
+								range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+							}
+
+							currentNode = currentNode.getFirst();
+							continue;
+						}
+						includeNode = 1;
+					}
+				} else if ( currentNode.type == CKEDITOR.NODE_TEXT ) {
+					// Ignore normal whitespaces (i.e. not including &nbsp; or
+					// other unicode whitespaces) before/after a block node.
+					if ( beginWhitespaceRegex.test( currentNode.getText() ) )
+						includeNode = 0;
+				}
+
+				// The current node is good to be part of the range and we are
+				// starting a new range, initialize it first.
+				if ( includeNode && !range ) {
+					range = this.range.clone();
+					range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+				}
+
+				// The last node has been found.
+				isLast = ( ( !closeRange || includeNode ) && currentNode.equals( lastNode ) );
+
+				// If we are in an element boundary, let's check if it is time
+				// to close the range, otherwise we include the parent within it.
+				if ( range && !closeRange ) {
+					while ( !currentNode.getNext( skipGuard ) && !isLast ) {
+						var parentNode = currentNode.getParent();
+
+						if ( parentNode.isBlockBoundary( this.forceBrBreak && !parentPre && { br: 1 } ) ) {
+							closeRange = 1;
+							includeNode = 0;
+							isLast = isLast || ( parentNode.equals( lastNode ) );
+							// Make sure range includes bookmarks at the end of the block. (#7359)
+							range.setEndAt( parentNode, CKEDITOR.POSITION_BEFORE_END );
+							break;
+						}
+
+						currentNode = parentNode;
+						includeNode = 1;
+						isLast = ( currentNode.equals( lastNode ) );
+						continueFromSibling = 1;
+					}
+				}
+
+				// Now finally include the node.
+				if ( includeNode )
+					range.setEndAt( currentNode, CKEDITOR.POSITION_AFTER_END );
+
+				currentNode = getNextSourceNode( currentNode, continueFromSibling, lastNode );
+				isLast = !currentNode;
+
+				// We have found a block boundary. Let's close the range and move out of the
+				// loop.
+				if ( isLast || ( closeRange && range ) )
+					break;
+			}
+
+			// Now, based on the processed range, look for (or create) the block to be returned.
+			if ( !block ) {
+				// If no range has been found, this is the end.
+				if ( !range ) {
+					this._.docEndMarker && this._.docEndMarker.remove();
+					this._.nextNode = null;
+					return null;
+				}
+
+				var startPath = new CKEDITOR.dom.elementPath( range.startContainer, range.root );
+				var startBlockLimit = startPath.blockLimit,
+					checkLimits = { div: 1, th: 1, td: 1 };
+				block = startPath.block;
+
+				if ( !block && startBlockLimit && !this.enforceRealBlocks && checkLimits[ startBlockLimit.getName() ] && range.checkStartOfBlock() && range.checkEndOfBlock() && !startBlockLimit.equals( range.root ) )
+					block = startBlockLimit;
+				else if ( !block || ( this.enforceRealBlocks && block.getName() == 'li' ) ) {
+					// Create the fixed block.
+					block = this.range.document.createElement( blockTag );
+
+					// Move the contents of the temporary range to the fixed block.
+					range.extractContents().appendTo( block );
+					block.trim();
+
+					// Insert the fixed block into the DOM.
+					range.insertNode( block );
+
+					removePreviousBr = removeLastBr = true;
+				} else if ( block.getName() != 'li' ) {
+					// If the range doesn't includes the entire contents of the
+					// block, we must split it, isolating the range in a dedicated
+					// block.
+					if ( !range.checkStartOfBlock() || !range.checkEndOfBlock() ) {
+						// The resulting block will be a clone of the current one.
+						block = block.clone( false );
+
+						// Extract the range contents, moving it to the new block.
+						range.extractContents().appendTo( block );
+						block.trim();
+
+						// Split the block. At this point, the range will be in the
+						// right position for our intents.
+						var splitInfo = range.splitBlock();
+
+						removePreviousBr = !splitInfo.wasStartOfBlock;
+						removeLastBr = !splitInfo.wasEndOfBlock;
+
+						// Insert the new block into the DOM.
+						range.insertNode( block );
+					}
+				} else if ( !isLast ) {
+					// LIs are returned as is, with all their children (due to the
+					// nested lists). But, the next node is the node right after
+					// the current range, which could be an <li> child (nested
+					// lists) or the next sibling <li>.
+
+					this._.nextNode = ( block.equals( lastNode ) ? null : getNextSourceNode( range.getBoundaryNodes().endNode, 1, lastNode ) );
+				}
+			}
+
+			if ( removePreviousBr ) {
+				var previousSibling = block.getPrevious();
+				if ( previousSibling && previousSibling.type == CKEDITOR.NODE_ELEMENT ) {
+					if ( previousSibling.getName() == 'br' )
+						previousSibling.remove();
+					else if ( previousSibling.getLast() && previousSibling.getLast().$.nodeName.toLowerCase() == 'br' )
+						previousSibling.getLast().remove();
+				}
+			}
+
+			if ( removeLastBr ) {
+				var lastChild = block.getLast();
+				if ( lastChild && lastChild.type == CKEDITOR.NODE_ELEMENT && lastChild.getName() == 'br' ) {
+					// Remove br filler on browser which do not need it.
+					if ( !CKEDITOR.env.needsBrFiller || lastChild.getPrevious( bookmarkGuard ) || lastChild.getNext( bookmarkGuard ) )
+						lastChild.remove();
+				}
+			}
+
+			// Get a reference for the next element. This is important because the
+			// above block can be removed or changed, so we can rely on it for the
+			// next interation.
+			if ( !this._.nextNode )
+				this._.nextNode = ( isLast || block.equals( lastNode ) || !lastNode ) ? null : getNextSourceNode( block, 1, lastNode );
+
+			return block;
+		}
+	};
+
+	// @context CKEDITOR.dom.iterator
+	// @returns Collapsed range which will be reused when during furter processing.
+	function startIterator() {
+		var range = this.range.clone(),
+			// Indicate at least one of the range boundaries is inside a preformat block.
+			touchPre;
+
+		// Shrink the range to exclude harmful "noises" (#4087, #4450, #5435).
+		range.shrink( CKEDITOR.SHRINK_ELEMENT, true );
+
+		touchPre = range.endContainer.hasAscendant( 'pre', true ) || range.startContainer.hasAscendant( 'pre', true );
+
+		range.enlarge( this.forceBrBreak && !touchPre || !this.enlargeBr ? CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS : CKEDITOR.ENLARGE_BLOCK_CONTENTS );
+
+		if ( !range.collapsed ) {
+			var walker = new CKEDITOR.dom.walker( range.clone() ),
+				ignoreBookmarkTextEvaluator = CKEDITOR.dom.walker.bookmark( true, true );
+			// Avoid anchor inside bookmark inner text.
+			walker.evaluator = ignoreBookmarkTextEvaluator;
+			this._.nextNode = walker.next();
+			// TODO: It's better to have walker.reset() used here.
+			walker = new CKEDITOR.dom.walker( range.clone() );
+			walker.evaluator = ignoreBookmarkTextEvaluator;
+			var lastNode = walker.previous();
+			this._.lastNode = lastNode.getNextSourceNode( true );
+
+			// We may have an empty text node at the end of block due to [3770].
+			// If that node is the lastNode, it would cause our logic to leak to the
+			// next block.(#3887)
+			if ( this._.lastNode && this._.lastNode.type == CKEDITOR.NODE_TEXT && !CKEDITOR.tools.trim( this._.lastNode.getText() ) && this._.lastNode.getParent().isBlockBoundary() ) {
+				var testRange = this.range.clone();
+				testRange.moveToPosition( this._.lastNode, CKEDITOR.POSITION_AFTER_END );
+				if ( testRange.checkEndOfBlock() ) {
+					var path = new CKEDITOR.dom.elementPath( testRange.endContainer, testRange.root ),
+						lastBlock = path.block || path.blockLimit;
+					this._.lastNode = lastBlock.getNextSourceNode( true );
+				}
+			}
+
+			// The end of document or range.root was reached, so we need a marker node inside.
+			if ( !this._.lastNode || !range.root.contains( this._.lastNode ) ) {
+				this._.lastNode = this._.docEndMarker = range.document.createText( '' );
+				this._.lastNode.insertAfter( lastNode );
+			}
+
+			// Let's reuse this variable.
+			range = null;
+		}
+
+		this._.started = 1;
+
+		return range;
+	}
+
+	// Does a nested editables lookup inside editablesContainer.
+	// If remainingEditables is set will lookup inside this array.
+	// @param {CKEDITOR.dom.element} editablesContainer
+	// @param {CKEDITOR.dom.element[]} [remainingEditables]
+	function getNestedEditableIn( editablesContainer, remainingEditables ) {
+		if ( remainingEditables == undefined )
+			remainingEditables = findNestedEditables( editablesContainer );
+
+		var editable;
+
+		while ( ( editable = remainingEditables.shift() ) ) {
+			if ( isIterableEditable( editable ) )
+				return { element: editable, remaining: remainingEditables };
+		}
+
+		return null;
+	}
+
+	// Checkes whether we can iterate over this editable.
+	function isIterableEditable( editable ) {
+		// Reject blockless editables.
+		return editable.getDtd().p;
+	}
+
+	// Finds nested editables within container. Does not return
+	// editables nested in another editable (twice).
+	function findNestedEditables( container ) {
+		var editables = [];
+
+		container.forEach( function( element ) {
+			if ( element.getAttribute( 'contenteditable' ) == 'true' ) {
+				editables.push( element );
+				return false; // Skip children.
+			}
+		}, CKEDITOR.NODE_ELEMENT, true );
+
+		return editables;
+	}
+
+	// Looks for a first nested editable after previousEditable (if passed) and creates
+	// nested iterator for it.
+	function startNestedEditableIterator( parentIterator, blockTag, editablesContainer, remainingEditables ) {
+		var editable = getNestedEditableIn( editablesContainer, remainingEditables );
+
+		if ( !editable )
+			return 0;
+
+		var filter = CKEDITOR.filter.instances[ editable.element.data( 'cke-filter' ) ];
+
+		// If current editable has a filter and this filter does not allow for block tag,
+		// search for next nested editable in remaining ones.
+		if ( filter && !filter.check( blockTag ) )
+			return startNestedEditableIterator( parentIterator, blockTag, editablesContainer, editable.remaining );
+
+		var range = new CKEDITOR.dom.range( editable.element );
+		range.selectNodeContents( editable.element );
+
+		var iterator = range.createIterator();
+		// This setting actually does not change anything in this case,
+		// because entire range contents is selected, so there're no <br>s to be included.
+		// But it seems right to copy it too.
+		iterator.enlargeBr = parentIterator.enlargeBr;
+		// Inherit configuration from parent iterator.
+		iterator.enforceRealBlocks = parentIterator.enforceRealBlocks;
+		// Set the activeFilter (which can be overriden when this iteator will start nested iterator)
+		// and the default filter, which will make it possible to reset to
+		// current iterator's activeFilter after leaving nested editable.
+		iterator.activeFilter = iterator.filter = filter;
+
+		parentIterator._.nestedEditable = {
+			element: editable.element,
+			container: editablesContainer,
+			remaining: editable.remaining,
+			iterator: iterator
+		};
+
+		return 1;
+	}
+
+	/**
+	 * Creates {CKEDITOR.dom.iterator} instance for this range.
+	 *
+	 * @member CKEDITOR.dom.range
+	 * @returns {CKEDITOR.dom.iterator}
+	 */
+	CKEDITOR.dom.range.prototype.createIterator = function() {
+		return new iterator( this );
+	};
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/node.js b/lam/templates/lib/extra/ckeditor/core/dom/node.js
new file mode 100644
index 00000000..05a531de
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/node.js
@@ -0,0 +1,748 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.node} class which is the base
+ *		class for classes that represent DOM nodes.
+ */
+
+/**
+ * Base class for classes representing DOM nodes. This constructor may return
+ * an instance of a class that inherits from this class, like
+ * {@link CKEDITOR.dom.element} or {@link CKEDITOR.dom.text}.
+ *
+ * @class
+ * @extends CKEDITOR.dom.domObject
+ * @constructor Creates a node class instance.
+ * @param {Object} domNode A native DOM node.
+ * @see CKEDITOR.dom.element
+ * @see CKEDITOR.dom.text
+ */
+CKEDITOR.dom.node = function( domNode ) {
+	if ( domNode ) {
+		var type = domNode.nodeType == CKEDITOR.NODE_DOCUMENT ? 'document' : domNode.nodeType == CKEDITOR.NODE_ELEMENT ? 'element' : domNode.nodeType == CKEDITOR.NODE_TEXT ? 'text' : domNode.nodeType == CKEDITOR.NODE_COMMENT ? 'comment' : domNode.nodeType == CKEDITOR.NODE_DOCUMENT_FRAGMENT ? 'documentFragment' : 'domObject'; // Call the base constructor otherwise.
+
+		return new CKEDITOR.dom[ type ]( domNode );
+	}
+
+	return this;
+};
+
+CKEDITOR.dom.node.prototype = new CKEDITOR.dom.domObject();
+
+/**
+ * Element node type.
+ *
+ * @readonly
+ * @property {Number} [=1]
+ * @member CKEDITOR
+ */
+CKEDITOR.NODE_ELEMENT = 1;
+
+/**
+ * Document node type.
+ *
+ * @readonly
+ * @property {Number} [=9]
+ * @member CKEDITOR
+ */
+CKEDITOR.NODE_DOCUMENT = 9;
+
+/**
+ * Text node type.
+ *
+ * @readonly
+ * @property {Number} [=3]
+ * @member CKEDITOR
+ */
+CKEDITOR.NODE_TEXT = 3;
+
+/**
+ * Comment node type.
+ *
+ * @readonly
+ * @property {Number} [=8]
+ * @member CKEDITOR
+ */
+CKEDITOR.NODE_COMMENT = 8;
+
+/**
+ * Document fragment node type.
+ *
+ * @readonly
+ * @property {Number} [=11]
+ * @member CKEDITOR
+ */
+CKEDITOR.NODE_DOCUMENT_FRAGMENT = 11;
+
+CKEDITOR.POSITION_IDENTICAL = 0;
+CKEDITOR.POSITION_DISCONNECTED = 1;
+CKEDITOR.POSITION_FOLLOWING = 2;
+CKEDITOR.POSITION_PRECEDING = 4;
+CKEDITOR.POSITION_IS_CONTAINED = 8;
+CKEDITOR.POSITION_CONTAINS = 16;
+
+CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype, {
+	/**
+	 * Makes this node a child of another element.
+	 *
+	 *		var p = new CKEDITOR.dom.element( 'p' );
+	 *		var strong = new CKEDITOR.dom.element( 'strong' );
+	 *		strong.appendTo( p );
+	 *
+	 *		// Result: '<p><strong></strong></p>'.
+	 *
+	 * @param {CKEDITOR.dom.element} element The target element to which this node will be appended.
+	 * @returns {CKEDITOR.dom.element} The target element.
+	 */
+	appendTo: function( element, toStart ) {
+		element.append( this, toStart );
+		return element;
+	},
+
+	/**
+	 * Clone this node.
+	 *
+	 * **Note**: Values set by {#setCustomData} won't be available in the clone.
+	 *
+	 * @param {Boolean} [includeChildren=false] If `true` then all node's
+	 * children will be cloned recursively.
+	 * @param {Boolean} [cloneId=false] Whether ID attributes should be cloned too.
+	 * @returns {CKEDITOR.dom.node} Clone of this node.
+	 */
+	clone: function( includeChildren, cloneId ) {
+		var $clone = this.$.cloneNode( includeChildren );
+
+		var removeIds = function( node ) {
+				// Reset data-cke-expando only when has been cloned (IE and only for some types of objects).
+				if ( node[ 'data-cke-expando' ] )
+					node[ 'data-cke-expando' ] = false;
+
+				if ( node.nodeType != CKEDITOR.NODE_ELEMENT )
+					return;
+				if ( !cloneId )
+					node.removeAttribute( 'id', false );
+
+				if ( includeChildren ) {
+					var childs = node.childNodes;
+					for ( var i = 0; i < childs.length; i++ )
+						removeIds( childs[ i ] );
+				}
+			};
+
+		// The "id" attribute should never be cloned to avoid duplication.
+		removeIds( $clone );
+
+		return new CKEDITOR.dom.node( $clone );
+	},
+
+	/**
+	 * Check if node is preceded by any sibling.
+	 *
+	 * @returns {Boolean}
+	 */
+	hasPrevious: function() {
+		return !!this.$.previousSibling;
+	},
+
+	/**
+	 * Check if node is succeeded by any sibling.
+	 *
+	 * @returns {Boolean}
+	 */
+	hasNext: function() {
+		return !!this.$.nextSibling;
+	},
+
+	/**
+	 * Inserts this element after a node.
+	 *
+	 *		var em = new CKEDITOR.dom.element( 'em' );
+	 *		var strong = new CKEDITOR.dom.element( 'strong' );
+	 *		strong.insertAfter( em );
+	 *
+	 *		// Result: '<em></em><strong></strong>'
+	 *
+	 * @param {CKEDITOR.dom.node} node The node that will precede this element.
+	 * @returns {CKEDITOR.dom.node} The node preceding this one after insertion.
+	 */
+	insertAfter: function( node ) {
+		node.$.parentNode.insertBefore( this.$, node.$.nextSibling );
+		return node;
+	},
+
+	/**
+	 * Inserts this element before a node.
+	 *
+	 *		var em = new CKEDITOR.dom.element( 'em' );
+	 *		var strong = new CKEDITOR.dom.element( 'strong' );
+	 *		strong.insertBefore( em );
+	 *
+	 *		// result: '<strong></strong><em></em>'
+	 *
+	 * @param {CKEDITOR.dom.node} node The node that will succeed this element.
+	 * @returns {CKEDITOR.dom.node} The node being inserted.
+	 */
+	insertBefore: function( node ) {
+		node.$.parentNode.insertBefore( this.$, node.$ );
+		return node;
+	},
+
+	/**
+	 * Inserts node before this node.
+	 *
+	 *		var em = new CKEDITOR.dom.element( 'em' );
+	 *		var strong = new CKEDITOR.dom.element( 'strong' );
+	 *		strong.insertBeforeMe( em );
+	 *
+	 *		// result: '<em></em><strong></strong>'
+	 *
+	 * @param {CKEDITOR.dom.node} node The node that will preceed this element.
+	 * @returns {CKEDITOR.dom.node} The node being inserted.
+	 */
+	insertBeforeMe: function( node ) {
+		this.$.parentNode.insertBefore( node.$, this.$ );
+		return node;
+	},
+
+	/**
+	 * Retrieves a uniquely identifiable tree address for this node.
+	 * The tree address returned is an array of integers, with each integer
+	 * indicating a child index of a DOM node, starting from
+	 * `document.documentElement`.
+	 *
+	 * For example, assuming `<body>` is the second child
+	 * of `<html>` (`<head>` being the first),
+	 * and we would like to address the third child under the
+	 * fourth child of `<body>`, the tree address returned would be:
+	 * `[1, 3, 2]`.
+	 *
+	 * The tree address cannot be used for finding back the DOM tree node once
+	 * the DOM tree structure has been modified.
+	 *
+	 * @param {Boolean} [normalized=false] See {@link #getIndex}.
+	 * @returns {Array} The address.
+	 */
+	getAddress: function( normalized ) {
+		var address = [];
+		var $documentElement = this.getDocument().$.documentElement;
+		var node = this.$;
+
+		while ( node && node != $documentElement ) {
+			var parentNode = node.parentNode;
+
+			if ( parentNode ) {
+				// Get the node index. For performance, call getIndex
+				// directly, instead of creating a new node object.
+				address.unshift( this.getIndex.call( { $: node }, normalized ) );
+			}
+
+			node = parentNode;
+		}
+
+		return address;
+	},
+
+	/**
+	 * Gets the document containing this element.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'example' );
+	 *		alert( element.getDocument().equals( CKEDITOR.document ) ); // true
+	 *
+	 * @returns {CKEDITOR.dom.document} The document.
+	 */
+	getDocument: function() {
+		return new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );
+	},
+
+	/**
+	 * Get index of a node in an array of its parent.childNodes.
+	 *
+	 * Let's assume having childNodes array:
+	 *
+	 *		[ emptyText, element1, text, text, element2 ]
+	 *		element1.getIndex();		// 1
+	 *		element1.getIndex( true );	// 0
+	 *		element2.getIndex();		// 4
+	 *		element2.getIndex( true );	// 2
+	 *
+	 * @param {Boolean} normalized When `true` empty text nodes and one followed
+	 * by another one text node are not counted in.
+	 * @returns {Number} Index of a node.
+	 */
+	getIndex: function( normalized ) {
+		// Attention: getAddress depends on this.$
+		// getIndex is called on a plain object: { $ : node }
+
+		var current = this.$,
+			index = -1,
+			isNormalizing;
+
+		if ( !this.$.parentNode )
+			return index;
+
+		do {
+			// Bypass blank node and adjacent text nodes.
+			if ( normalized && current != this.$ && current.nodeType == CKEDITOR.NODE_TEXT && ( isNormalizing || !current.nodeValue ) )
+				continue;
+
+			index++;
+			isNormalizing = current.nodeType == CKEDITOR.NODE_TEXT;
+		}
+		while ( ( current = current.previousSibling ) )
+
+		return index;
+	},
+
+	/**
+	 * @todo
+	 */
+	getNextSourceNode: function( startFromSibling, nodeType, guard ) {
+		// If "guard" is a node, transform it in a function.
+		if ( guard && !guard.call ) {
+			var guardNode = guard;
+			guard = function( node ) {
+				return !node.equals( guardNode );
+			};
+		}
+
+		var node = ( !startFromSibling && this.getFirst && this.getFirst() ),
+			parent;
+
+		// Guarding when we're skipping the current element( no children or 'startFromSibling' ).
+		// send the 'moving out' signal even we don't actually dive into.
+		if ( !node ) {
+			if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guard( this, true ) === false )
+				return null;
+			node = this.getNext();
+		}
+
+		while ( !node && ( parent = ( parent || this ).getParent() ) ) {
+			// The guard check sends the "true" paramenter to indicate that
+			// we are moving "out" of the element.
+			if ( guard && guard( parent, true ) === false )
+				return null;
+
+			node = parent.getNext();
+		}
+
+		if ( !node )
+			return null;
+
+		if ( guard && guard( node ) === false )
+			return null;
+
+		if ( nodeType && nodeType != node.type )
+			return node.getNextSourceNode( false, nodeType, guard );
+
+		return node;
+	},
+
+	/**
+	 * @todo
+	 */
+	getPreviousSourceNode: function( startFromSibling, nodeType, guard ) {
+		if ( guard && !guard.call ) {
+			var guardNode = guard;
+			guard = function( node ) {
+				return !node.equals( guardNode );
+			};
+		}
+
+		var node = ( !startFromSibling && this.getLast && this.getLast() ),
+			parent;
+
+		// Guarding when we're skipping the current element( no children or 'startFromSibling' ).
+		// send the 'moving out' signal even we don't actually dive into.
+		if ( !node ) {
+			if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guard( this, true ) === false )
+				return null;
+			node = this.getPrevious();
+		}
+
+		while ( !node && ( parent = ( parent || this ).getParent() ) ) {
+			// The guard check sends the "true" paramenter to indicate that
+			// we are moving "out" of the element.
+			if ( guard && guard( parent, true ) === false )
+				return null;
+
+			node = parent.getPrevious();
+		}
+
+		if ( !node )
+			return null;
+
+		if ( guard && guard( node ) === false )
+			return null;
+
+		if ( nodeType && node.type != nodeType )
+			return node.getPreviousSourceNode( false, nodeType, guard );
+
+		return node;
+	},
+
+	/**
+	 * Gets the node that preceed this element in its parent's child list.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div><i>prev</i><b>Example</b></div>' );
+	 *		var first = element.getLast().getPrev();
+	 *		alert( first.getName() ); // 'i'
+	 *
+	 * @param {Function} [evaluator] Filtering the result node.
+	 * @returns {CKEDITOR.dom.node} The previous node or null if not available.
+	 */
+	getPrevious: function( evaluator ) {
+		var previous = this.$,
+			retval;
+		do {
+			previous = previous.previousSibling;
+
+			// Avoid returning the doc type node.
+			// http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-412266927
+			retval = previous && previous.nodeType != 10 && new CKEDITOR.dom.node( previous );
+		}
+		while ( retval && evaluator && !evaluator( retval ) )
+		return retval;
+	},
+
+	/**
+	 * Gets the node that follows this element in its parent's child list.
+	 *
+	 *		var element = CKEDITOR.dom.element.createFromHtml( '<div><b>Example</b><i>next</i></div>' );
+	 *		var last = element.getFirst().getNext();
+	 *		alert( last.getName() ); // 'i'
+	 *
+	 * @param {Function} [evaluator] Filtering the result node.
+	 * @returns {CKEDITOR.dom.node} The next node or null if not available.
+	 */
+	getNext: function( evaluator ) {
+		var next = this.$,
+			retval;
+		do {
+			next = next.nextSibling;
+			retval = next && new CKEDITOR.dom.node( next );
+		}
+		while ( retval && evaluator && !evaluator( retval ) )
+		return retval;
+	},
+
+	/**
+	 * Gets the parent element for this node.
+	 *
+	 *		var node = editor.document.getBody().getFirst();
+	 *		var parent = node.getParent();
+	 *		alert( parent.getName() ); // 'body'
+	 *
+	 * @param {Boolean} [allowFragmentParent=false] Consider also parent node that is of
+	 * fragment type {@link CKEDITOR#NODE_DOCUMENT_FRAGMENT}.
+	 * @returns {CKEDITOR.dom.element} The parent element.
+	 */
+	getParent: function( allowFragmentParent ) {
+		var parent = this.$.parentNode;
+		return ( parent && ( parent.nodeType == CKEDITOR.NODE_ELEMENT || allowFragmentParent && parent.nodeType == CKEDITOR.NODE_DOCUMENT_FRAGMENT ) ) ? new CKEDITOR.dom.node( parent ) : null;
+	},
+
+	/**
+	 * Returns array containing node parents and node itself. By default nodes are in _descending_ order.
+	 *
+	 *		// Assuming that body has paragraph as first child.
+	 *		var node = editor.document.getBody().getFirst();
+	 *		var parents = node.getParents();
+	 *		alert( parents[ 0 ].getName() + ',' + parents[ 2 ].getName() ); // 'html,p'
+	 *
+	 * @param {Boolean} [closerFirst=false] Determines order of returned nodes.
+	 * @returns {Array} Returns array of {@link CKEDITOR.dom.node}.
+	 */
+	getParents: function( closerFirst ) {
+		var node = this;
+		var parents = [];
+
+		do {
+			parents[ closerFirst ? 'push' : 'unshift' ]( node );
+		}
+		while ( ( node = node.getParent() ) )
+
+		return parents;
+	},
+
+	/**
+	 * @todo
+	 */
+	getCommonAncestor: function( node ) {
+		if ( node.equals( this ) )
+			return this;
+
+		if ( node.contains && node.contains( this ) )
+			return node;
+
+		var start = this.contains ? this : this.getParent();
+
+		do {
+			if ( start.contains( node ) ) return start;
+		}
+		while ( ( start = start.getParent() ) );
+
+		return null;
+	},
+
+	/**
+	 * @todo
+	 */
+	getPosition: function( otherNode ) {
+		var $ = this.$;
+		var $other = otherNode.$;
+
+		if ( $.compareDocumentPosition )
+			return $.compareDocumentPosition( $other );
+
+		// IE and Safari have no support for compareDocumentPosition.
+
+		if ( $ == $other )
+			return CKEDITOR.POSITION_IDENTICAL;
+
+		// Only element nodes support contains and sourceIndex.
+		if ( this.type == CKEDITOR.NODE_ELEMENT && otherNode.type == CKEDITOR.NODE_ELEMENT ) {
+			if ( $.contains ) {
+				if ( $.contains( $other ) )
+					return CKEDITOR.POSITION_CONTAINS + CKEDITOR.POSITION_PRECEDING;
+
+				if ( $other.contains( $ ) )
+					return CKEDITOR.POSITION_IS_CONTAINED + CKEDITOR.POSITION_FOLLOWING;
+			}
+
+			if ( 'sourceIndex' in $ )
+				return ( $.sourceIndex < 0 || $other.sourceIndex < 0 ) ? CKEDITOR.POSITION_DISCONNECTED : ( $.sourceIndex < $other.sourceIndex ) ? CKEDITOR.POSITION_PRECEDING : CKEDITOR.POSITION_FOLLOWING;
+
+		}
+
+		// For nodes that don't support compareDocumentPosition, contains
+		// or sourceIndex, their "address" is compared.
+
+		var addressOfThis = this.getAddress(),
+			addressOfOther = otherNode.getAddress(),
+			minLevel = Math.min( addressOfThis.length, addressOfOther.length );
+
+		// Determinate preceed/follow relationship.
+		for ( var i = 0; i <= minLevel - 1; i++ ) {
+			if ( addressOfThis[ i ] != addressOfOther[ i ] ) {
+				if ( i < minLevel )
+					return addressOfThis[ i ] < addressOfOther[ i ] ? CKEDITOR.POSITION_PRECEDING : CKEDITOR.POSITION_FOLLOWING;
+
+				break;
+			}
+		}
+
+		// Determinate contains/contained relationship.
+		return ( addressOfThis.length < addressOfOther.length ) ? CKEDITOR.POSITION_CONTAINS + CKEDITOR.POSITION_PRECEDING : CKEDITOR.POSITION_IS_CONTAINED + CKEDITOR.POSITION_FOLLOWING;
+	},
+
+	/**
+	 * Gets the closest ancestor node of this node, specified by its name.
+	 *
+	 *		// Suppose we have the following HTML structure:
+	 *		// <div id="outer"><div id="inner"><p><b>Some text</b></p></div></div>
+	 *		// If node == <b>
+	 *		ascendant = node.getAscendant( 'div' );				// ascendant == <div id="inner">
+	 *		ascendant = node.getAscendant( 'b' );				// ascendant == null
+	 *		ascendant = node.getAscendant( 'b', true );			// ascendant == <b>
+	 *		ascendant = node.getAscendant( { div:1,p:1 } );		// Searches for the first 'div' or 'p': ascendant == <div id="inner">
+	 *
+	 * @since 3.6.1
+	 * @param {String} reference The name of the ancestor node to search or
+	 * an object with the node names to search for.
+	 * @param {Boolean} [includeSelf] Whether to include the current
+	 * node in the search.
+	 * @returns {CKEDITOR.dom.node} The located ancestor node or null if not found.
+	 */
+	getAscendant: function( reference, includeSelf ) {
+		var $ = this.$,
+			name;
+
+		if ( !includeSelf )
+			$ = $.parentNode;
+
+		while ( $ ) {
+			if ( $.nodeName && ( name = $.nodeName.toLowerCase(), ( typeof reference == 'string' ? name == reference : name in reference ) ) )
+				return new CKEDITOR.dom.node( $ );
+
+			try {
+				$ = $.parentNode;
+			} catch ( e ) {
+				$ = null;
+			}
+		}
+		return null;
+	},
+
+	/**
+	 * @todo
+	 */
+	hasAscendant: function( name, includeSelf ) {
+		var $ = this.$;
+
+		if ( !includeSelf )
+			$ = $.parentNode;
+
+		while ( $ ) {
+			if ( $.nodeName && $.nodeName.toLowerCase() == name )
+				return true;
+
+			$ = $.parentNode;
+		}
+		return false;
+	},
+
+	/**
+	 * @todo
+	 */
+	move: function( target, toStart ) {
+		target.append( this.remove(), toStart );
+	},
+
+	/**
+	 * Removes this node from the document DOM.
+	 *
+	 *		var element = CKEDITOR.document.getById( 'MyElement' );
+	 *		element.remove();
+	 *
+	 * @param {Boolean} [preserveChildren=false] Indicates that the children
+	 * elements must remain in the document, removing only the outer tags.
+	 */
+	remove: function( preserveChildren ) {
+		var $ = this.$;
+		var parent = $.parentNode;
+
+		if ( parent ) {
+			if ( preserveChildren ) {
+				// Move all children before the node.
+				for ( var child;
+				( child = $.firstChild ); ) {
+					parent.insertBefore( $.removeChild( child ), $ );
+				}
+			}
+
+			parent.removeChild( $ );
+		}
+
+		return this;
+	},
+
+	/**
+	 * @todo
+	 */
+	replace: function( nodeToReplace ) {
+		this.insertBefore( nodeToReplace );
+		nodeToReplace.remove();
+	},
+
+	/**
+	 * @todo
+	 */
+	trim: function() {
+		this.ltrim();
+		this.rtrim();
+	},
+
+	/**
+	 * @todo
+	 */
+	ltrim: function() {
+		var child;
+		while ( this.getFirst && ( child = this.getFirst() ) ) {
+			if ( child.type == CKEDITOR.NODE_TEXT ) {
+				var trimmed = CKEDITOR.tools.ltrim( child.getText() ),
+					originalLength = child.getLength();
+
+				if ( !trimmed ) {
+					child.remove();
+					continue;
+				} else if ( trimmed.length < originalLength ) {
+					child.split( originalLength - trimmed.length );
+
+					// IE BUG: child.remove() may raise JavaScript errors here. (#81)
+					this.$.removeChild( this.$.firstChild );
+				}
+			}
+			break;
+		}
+	},
+
+	/**
+	 * @todo
+	 */
+	rtrim: function() {
+		var child;
+		while ( this.getLast && ( child = this.getLast() ) ) {
+			if ( child.type == CKEDITOR.NODE_TEXT ) {
+				var trimmed = CKEDITOR.tools.rtrim( child.getText() ),
+					originalLength = child.getLength();
+
+				if ( !trimmed ) {
+					child.remove();
+					continue;
+				} else if ( trimmed.length < originalLength ) {
+					child.split( trimmed.length );
+
+					// IE BUG: child.getNext().remove() may raise JavaScript errors here.
+					// (#81)
+					this.$.lastChild.parentNode.removeChild( this.$.lastChild );
+				}
+			}
+			break;
+		}
+
+		if ( CKEDITOR.env.needsBrFiller ) {
+			child = this.$.lastChild;
+
+			if ( child && child.type == 1 && child.nodeName.toLowerCase() == 'br' ) {
+				// Use "eChildNode.parentNode" instead of "node" to avoid IE bug (#324).
+				child.parentNode.removeChild( child );
+			}
+		}
+	},
+
+	/**
+	 * Checks if this node is read-only (should not be changed).
+	 *
+	 * **Note:** When `attributeCheck` is not used, this method only work for elements
+	 * that are already presented in the document, otherwise the result
+	 * is not guaranteed, it's mainly for performance consideration.
+	 *
+	 *		// For the following HTML:
+	 *		// <div contenteditable="false">Some <b>text</b></div>
+	 *
+	 *		// If "ele" is the above <div>
+	 *		element.isReadOnly(); // true
+	 *
+	 * @since 3.5
+	 * @returns {Boolean}
+	 */
+	isReadOnly: function() {
+		var element = this;
+		if ( this.type != CKEDITOR.NODE_ELEMENT )
+			element = this.getParent();
+
+		if ( element && typeof element.$.isContentEditable != 'undefined' )
+			return !( element.$.isContentEditable || element.data( 'cke-editable' ) );
+		else {
+			// Degrade for old browsers which don't support "isContentEditable", e.g. FF3
+
+			while ( element ) {
+				if ( element.data( 'cke-editable' ) )
+					break;
+
+				if ( element.getAttribute( 'contentEditable' ) == 'false' )
+					return true;
+				else if ( element.getAttribute( 'contentEditable' ) == 'true' )
+					break;
+
+				element = element.getParent();
+			}
+
+			// Reached the root of DOM tree, no editable found.
+			return !element;
+		}
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/nodelist.js b/lam/templates/lib/extra/ckeditor/core/dom/nodelist.js
new file mode 100644
index 00000000..b6f19a52
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/nodelist.js
@@ -0,0 +1,43 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * Represents a list of {@link CKEDITOR.dom.node} objects.
+ * It's a wrapper for native nodes list.
+ *
+ *		var nodeList = CKEDITOR.document.getBody().getChildren();
+ *		alert( nodeList.count() ); // number [0;N]
+ *
+ * @class
+ * @constructor Creates a document class instance.
+ * @param {Object} nativeList
+ */
+CKEDITOR.dom.nodeList = function( nativeList ) {
+	this.$ = nativeList;
+};
+
+CKEDITOR.dom.nodeList.prototype = {
+	/**
+	 * Get count of nodes in this list.
+	 *
+	 * @returns {Number}
+	 */
+	count: function() {
+		return this.$.length;
+	},
+
+	/**
+	 * Get node from the list.
+	 *
+	 * @returns {CKEDITOR.dom.node}
+	 */
+	getItem: function( index ) {
+		if ( index < 0 || index >= this.$.length )
+			return null;
+
+		var $node = this.$[ index ];
+		return $node ? new CKEDITOR.dom.node( $node ) : null;
+	}
+};
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/range.js b/lam/templates/lib/extra/ckeditor/core/dom/range.js
new file mode 100644
index 00000000..b50a8891
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/range.js
@@ -0,0 +1,2391 @@
+/**
+ * @license Copyright (c) 2003-2014, 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();
+ *
+ * @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.
+	var updateCollapsed = function( 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
+	// contents.
+	// V2
+	var execContentsAction = function( range, action, docFrag, mergeThen ) {
+			range.optimizeBookmark();
+
+			var startNode = range.startContainer;
+			var endNode = range.endContainer;
+
+			var startOffset = range.startOffset;
+			var endOffset = range.endOffset;
+
+			var removeStartNode;
+			var removeEndNode;
+
+			// 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 )
+				endNode = endNode.split( endOffset );
+			else {
+				// If the end container has children and the offset is pointing
+				// to a child, then we should start from it.
+				if ( endNode.getChildCount() > 0 ) {
+					// If the offset points after the last node.
+					if ( endOffset >= endNode.getChildCount() ) {
+						// Let's create a temporary node and mark it for removal.
+						endNode = endNode.append( range.document.createText( '' ) );
+						removeEndNode = true;
+					} else
+						endNode = endNode.getChild( endOffset );
+				}
+			}
+
+			// 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 ) {
+				startNode.split( startOffset );
+
+				// In cases the end node is the same as the start node, the above
+				// splitting will also split the end, so me must move the end to
+				// the second part of the split.
+				if ( startNode.equals( endNode ) )
+					endNode = startNode.getNext();
+			} else {
+				// If the start container has children and the offset is pointing
+				// to a child, then we should start from its previous sibling.
+
+				// If the offset points to the first node, we don't have a
+				// sibling, so let's use the first one, but mark it for removal.
+				if ( !startOffset ) {
+					// Let's create a temporary node and mark it for removal.
+					startNode = startNode.append( range.document.createText( '' ), 1 );
+					removeStartNode = true;
+				} else if ( startOffset >= startNode.getChildCount() ) {
+					// Let's create a temporary node and mark it for removal.
+					startNode = startNode.append( range.document.createText( '' ) );
+					removeStartNode = true;
+				} else
+					startNode = startNode.getChild( startOffset ).getPrevious();
+			}
+
+			// Get the parent nodes tree for the start and end boundaries.
+			var startParents = startNode.getParents();
+			var endParents = endNode.getParents();
+
+			// Compare them, to find the top most siblings.
+			var i, topStart, topEnd;
+
+			for ( i = 0; i < startParents.length; 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 ) )
+					break;
+			}
+
+			var clone = docFrag,
+				levelStartNode, levelClone, currentNode, currentSibling;
+
+			// Remove all successive sibling nodes for every node in the
+			// startParents tree.
+			for ( var j = i; j < startParents.length; j++ ) {
+				levelStartNode = startParents[ j ];
+
+				// For Extract and Clone, we must clone this level.
+				if ( clone && !levelStartNode.equals( startNode ) ) // action = 0 = Delete
+				levelClone = clone.append( levelStartNode.clone() );
+
+				currentNode = levelStartNode.getNext();
+
+				while ( currentNode ) {
+					// Stop processing when the current node matches a node in the
+					// endParents tree or if it is the endNode.
+					if ( currentNode.equals( endParents[ j ] ) || currentNode.equals( endNode ) )
+						break;
+
+					// Cache the next sibling.
+					currentSibling = currentNode.getNext();
+
+					// If cloning, just clone it.
+					if ( action == 2 ) // 2 = Clone
+					clone.append( currentNode.clone( true ) );
+					else {
+						// Both Delete and Extract will remove the node.
+						currentNode.remove();
+
+						// When Extracting, move the removed node to the docFrag.
+						if ( action == 1 ) // 1 = Extract
+						clone.append( currentNode );
+					}
+
+					currentNode = currentSibling;
+				}
+
+				if ( clone )
+					clone = levelClone;
+			}
+
+			clone = docFrag;
+
+			// Remove all previous sibling nodes for every node in the
+			// endParents tree.
+			for ( var k = i; k < endParents.length; k++ ) {
+				levelStartNode = endParents[ k ];
+
+				// For Extract and Clone, we must clone this level.
+				if ( action > 0 && !levelStartNode.equals( endNode ) ) // action = 0 = Delete
+				levelClone = clone.append( levelStartNode.clone() );
+
+				// The processing of siblings may have already been done by the parent.
+				if ( !startParents[ k ] || levelStartNode.$.parentNode != startParents[ k ].$.parentNode ) {
+					currentNode = levelStartNode.getPrevious();
+
+					while ( currentNode ) {
+						// Stop processing when the current node matches a node in the
+						// startParents tree or if it is the startNode.
+						if ( currentNode.equals( startParents[ k ] ) || currentNode.equals( startNode ) )
+							break;
+
+						// Cache the next sibling.
+						currentSibling = currentNode.getPrevious();
+
+						// If cloning, just clone it.
+						if ( action == 2 ) // 2 = Clone
+						clone.$.insertBefore( currentNode.$.cloneNode( true ), clone.$.firstChild );
+						else {
+							// Both Delete and Extract will remove the node.
+							currentNode.remove();
+
+							// When Extracting, mode the removed node to the docFrag.
+							if ( action == 1 ) // 1 = Extract
+							clone.$.insertBefore( currentNode.$, clone.$.firstChild );
+						}
+
+						currentNode = currentSibling;
+					}
+				}
+
+				if ( clone )
+					clone = levelClone;
+			}
+
+			if ( action == 2 ) // 2 = Clone.
+			{
+				// No changes in the DOM should be done, so fix the split text (if any).
+
+				var startTextNode = range.startContainer;
+				if ( startTextNode.type == CKEDITOR.NODE_TEXT ) {
+					startTextNode.$.data += startTextNode.$.nextSibling.data;
+					startTextNode.$.parentNode.removeChild( startTextNode.$.nextSibling );
+				}
+
+				var endTextNode = range.endContainer;
+				if ( endTextNode.type == CKEDITOR.NODE_TEXT && endTextNode.$.nextSibling ) {
+					endTextNode.$.data += endTextNode.$.nextSibling.data;
+					endTextNode.$.parentNode.removeChild( endTextNode.$.nextSibling );
+				}
+			} else {
+				// Collapse the range.
+
+				// If a node has been partially selected, collapse the range between
+				// topStart and topEnd. Otherwise, simply collapse it to the start. (W3C specs).
+				if ( topStart && topEnd && ( startNode.$.parentNode != topStart.$.parentNode || endNode.$.parentNode != topEnd.$.parentNode ) ) {
+					var endIndex = topEnd.getIndex();
+
+					// If the start node is to be removed, we must correct the
+					// index to reflect the removal.
+					if ( removeStartNode && topEnd.$.parentNode == startNode.$.parentNode )
+						endIndex--;
+
+					// Merge splitted parents.
+					if ( mergeThen && topStart.type == CKEDITOR.NODE_ELEMENT ) {
+						var span = CKEDITOR.dom.element.createFromHtml( '<span ' +
+							'data-cke-bookmark="1" style="display:none">&nbsp;</span>', range.document );
+						span.insertAfter( topStart );
+						topStart.mergeSiblings( false );
+						range.moveToBookmark( { startNode: span } );
+					} else
+						range.setStart( topEnd.getParent(), endIndex );
+				}
+
+				// Collapse it to the start.
+				range.collapse( true );
+			}
+
+			// Cleanup any marked node.
+			if ( removeStartNode )
+				startNode.remove();
+
+			if ( removeEndNode && endNode.$.parentNode )
+				endNode.remove();
+		};
+
+	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.startContainer = this.startContainer;
+			clone.startOffset = this.startOffset;
+			clone.endContainer = this.endContainer;
+			clone.endOffset = this.endOffset;
+			clone.collapsed = this.collapsed;
+
+			return clone;
+		},
+
+		/**
+		 * Makes 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.endContainer = this.startContainer;
+				this.endOffset = this.startOffset;
+			} else {
+				this.startContainer = this.endContainer;
+				this.startOffset = this.endOffset;
+			}
+
+			this.collapsed = true;
+		},
+
+		/**
+		 * The content nodes of the range are cloned and added to a document fragment, which is returned.
+		 *
+		 * **Note:** Text selection may lost after invoking this method (caused by text node splitting).
+		 *
+		 * @returns {CKEDITOR.dom.documentFragment} Document fragment containing clone of range's content.
+		 */
+		cloneContents: function() {
+			var docFrag = new CKEDITOR.dom.documentFragment( this.document );
+
+			if ( !this.collapsed )
+				execContentsAction( this, 2, docFrag );
+
+			return docFrag;
+		},
+
+		/**
+		 * Deletes the content nodes of the range permanently from the DOM tree.
+		 *
+		 * @param {Boolean} [mergeThen] Merge any splitted 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.
+		 *
+		 * @param {Boolean} [mergeThen] Merge any splitted elements result in DOM true due to partial selection.
+		 * @returns {CKEDITOR.dom.documentFragment} Document fragment containing extracted content.
+		 */
+		extractContents: function( mergeThen ) {
+			var docFrag = new CKEDITOR.dom.documentFragment( this.document );
+
+			if ( !this.collapsed )
+				execContentsAction( this, 1, docFrag, mergeThen );
+
+			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() {
+			// 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.getLength();
+
+				return sum;
+			}
+
+			function normalize( 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 two nodes before it,
+				// it may happen that some of them will be merged. Normalize the offset
+				// by setting it to normalized index of its preceding node.
+				if ( container.type == CKEDITOR.NODE_ELEMENT && offset > 1 )
+					offset = container.getChild( offset - 1 ).getIndex( true ) + 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 )
+					offset += getLengthOfPrecedingTextNodes( container );
+
+				limit.container = container;
+				limit.offset = offset;
+			}
+
+			return function( normalized ) {
+				var collapsed = this.collapsed,
+					bmStart = {
+						container: this.startContainer,
+						offset: this.startOffset
+					},
+					bmEnd = {
+						container: this.endContainer,
+						offset: this.endOffset
+					};
+
+				if ( normalized ) {
+					normalize( bmStart );
+
+					if ( !collapsed )
+						normalize( bmEnd );
+				}
+
+				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 ) {
+			if ( bookmark.is2 ) // Created with createBookmark2().
+			{
+				// 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 );
+			} else // Created with createBookmark().
+			{
+				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();
+				else // startOffset > childCount but childCount is not 0
+				{
+					// 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();
+				else // endOffset > childCount but childCount is not 0
+				{
+					// 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 unit {Number} The unit type to expand with.
+		 * @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;
+					/*jsl:fallthru*/
+				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 {
+								// 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 ) ) // 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, movingOut ) {
+							// 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.
+					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 = 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,
+					collapsed = this.collapsed;
+
+				// 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 );
+		},
+
+		/**
+		 * @todo
+		 */
+		moveToPosition: function( node, position ) {
+			this.setStartAt( node, position );
+			this.collapse( true );
+		},
+
+		/**
+		 * @todo
+		 */
+		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.startContainer = startNode;
+			this.startOffset = startOffset;
+
+			if ( !this.endContainer ) {
+				this.endContainer = 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.endContainer = endNode;
+			this.endOffset = endOffset;
+
+			if ( !this.startContainer ) {
+				this.startContainer = endNode;
+				this.startOffset = endOffset;
+			}
+
+			updateCollapsed( this );
+		},
+
+		/**
+		 * @todo
+		 */
+		setStartAfter: function( node ) {
+			this.setStart( node.getParent(), node.getIndex() + 1 );
+		},
+
+		/**
+		 * @todo
+		 */
+		setStartBefore: function( node ) {
+			this.setStart( node.getParent(), node.getIndex() );
+		},
+
+		/**
+		 * @todo
+		 */
+		setEndAfter: function( node ) {
+			this.setEnd( node.getParent(), node.getIndex() + 1 );
+		},
+
+		/**
+		 * @todo
+		 */
+		setEndBefore: function( node ) {
+			this.setEnd( node.getParent(), node.getIndex() );
+		},
+
+		/**
+		 * @todo
+		 */
+		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 );
+		},
+
+		/**
+		 * @todo
+		 */
+		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 );
+		},
+
+		/**
+		 * @todo
+		 */
+		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();
+
+			fixedBlock.appendBogus();
+
+			this.insertNode( fixedBlock );
+
+			this.moveToBookmark( bookmark );
+
+			return fixedBlock;
+		},
+
+		/**
+		 * @todo
+		 */
+		splitBlock: function( blockTag ) {
+			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 );
+
+					// 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
+		 * @returns {CKEDITOR.dom.element} Root element of the new branch after the split.
+		 */
+		splitElement: function( toSplit ) {
+			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();
+
+			// Duplicate the element after it.
+			var clone = toSplit.clone( 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.
+		 *
+		 * 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.
+		 * @param {Boolean} isMoveToEnd Whether move to the end of editable. Otherwise, look back.
+		 * @returns {Boolean} Whether the range was moved.
+		 */
+		moveToClosestEditablePosition: function( element, isMoveToEnd ) {
+			// We don't want to modify original range if there's no editable position.
+			var range = new CKEDITOR.dom.range( this.root ),
+				found = 0,
+				sibling,
+				positions = [ CKEDITOR.POSITION_AFTER_END, CKEDITOR.POSITION_BEFORE_START ];
+
+			// Set collapsed range at one of ends of element.
+			range.moveToPosition( element, positions[ isMoveToEnd ? 0 : 1 ] );
+
+			// Start element isn't a block, so we can automatically place range
+			// next to it.
+			if ( !element.is( CKEDITOR.dtd.$block ) )
+				found = 1;
+			else {
+				// Look for first node that fulfills eval function and place range next to it.
+				sibling = range[ isMoveToEnd ? 'getNextEditableNode' : 'getPreviousEditableNode' ]();
+				if ( sibling ) {
+					found = 1;
+
+					// 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 ( sibling.type == CKEDITOR.NODE_ELEMENT && sibling.is( CKEDITOR.dtd.$block ) && sibling.getAttribute( 'contenteditable' ) == 'false' ) {
+						range.setStartAt( sibling, CKEDITOR.POSITION_BEFORE_START );
+						range.setEndAt( sibling, CKEDITOR.POSITION_AFTER_END );
+					}
+					else
+						range.moveToPosition( sibling, positions[ isMoveToEnd ? 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();
+		}
+	};
+} )();
+
+CKEDITOR.POSITION_AFTER_START = 1; // <element>^contents</element>		"^text"
+CKEDITOR.POSITION_BEFORE_END = 2; // <element>contents^</element>		"text^"
+CKEDITOR.POSITION_BEFORE_START = 3; // ^<element>contents</element>		^"text"
+CKEDITOR.POSITION_AFTER_END = 4; // <element>contents</element>^		"text"
+
+CKEDITOR.ENLARGE_ELEMENT = 1;
+CKEDITOR.ENLARGE_BLOCK_CONTENTS = 2;
+CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS = 3;
+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;
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/rangelist.js b/lam/templates/lib/extra/ckeditor/core/dom/rangelist.js
new file mode 100644
index 00000000..15447d75
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/rangelist.js
@@ -0,0 +1,201 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	/**
+	 * Represents a list os CKEDITOR.dom.range objects, which can be easily
+	 * iterated sequentially.
+	 *
+	 * @class
+	 * @extends Array
+	 * @constructor Creates a rangeList class instance.
+	 * @param {CKEDITOR.dom.range/CKEDITOR.dom.range[]} [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 = {
+		/**
+		 * 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;
+
+			return {
+				/**
+				 * Retrieves the next range in the list.
+				 *
+				 * @member CKEDITOR.dom.rangeListIterator
+				 * @param {Boolean} [mergeConsequent=false] 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;
+				}
+			};
+		},
+
+		/**
+		 * Create bookmarks for all ranges. See {@link CKEDITOR.dom.range#createBookmark}.
+		 *
+		 * @param {Boolean} [serializable=false] See {@link CKEDITOR.dom.range#createBookmark}.
+		 * @returns {Array} Array of bookmarks.
+		 */
+		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;
+		},
+
+		/**
+		 * Create "unobtrusive" bookmarks for all ranges. See {@link CKEDITOR.dom.range#createBookmark2}.
+		 *
+		 * @param {Boolean} [normalized=false] See {@link CKEDITOR.dom.range#createBookmark2}.
+		 * @returns {Array} Array of bookmarks.
+		 */
+		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}.
+ *
+ * @class CKEDITOR.dom.rangeListIterator
+ */
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/text.js b/lam/templates/lib/extra/ckeditor/core/dom/text.js
new file mode 100644
index 00000000..b620a425
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/text.js
@@ -0,0 +1,139 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.text} class, which represents
+ *		a DOM text node.
+ */
+
+/**
+ * Represents a DOM text node.
+ *
+ *		var nativeNode = document.createTextNode( 'Example' );
+ *		var text = CKEDITOR.dom.text( nativeNode );
+ *
+ *		var text = CKEDITOR.dom.text( 'Example' );
+ *
+ * @class
+ * @extends CKEDITOR.dom.node
+ * @constructor Creates a text class instance.
+ * @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.
+ */
+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 );
+
+	this.$ = text;
+};
+
+CKEDITOR.dom.text.prototype = new CKEDITOR.dom.node();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.text.prototype, {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_TEXT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_TEXT]
+	 */
+	type: CKEDITOR.NODE_TEXT,
+
+	/**
+	 * Gets length of node's value.
+	 *
+	 * @returns {Number}
+	 */
+	getLength: function() {
+		return this.$.nodeValue.length;
+	},
+
+	/**
+	 * Gets node's value.
+	 *
+	 * @returns {String}
+	 */
+	getText: function() {
+		return this.$.nodeValue;
+	},
+
+	/**
+	 * Sets node's value.
+	 *
+	 * @param {String} text
+	 */
+	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 ) {
+
+		// Saved the children count and text length beforehand.
+		var parent = this.$.parentNode,
+			count = parent.childNodes.length,
+			length = this.getLength();
+
+		var doc = this.getDocument();
+		var retval = new CKEDITOR.dom.text( this.$.splitText( offset ), doc );
+
+		if ( parent.childNodes.length == count )
+		{
+			// 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 ( offset >= length )
+			{
+				retval = doc.createText( '' );
+				retval.insertAfter( this );
+			}
+			else
+			{
+				// 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)
+				var workaround = doc.createText( '' );
+				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 );
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/walker.js b/lam/templates/lib/extra/ckeditor/core/dom/walker.js
new file mode 100644
index 00000000..9ac1cd3a
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/walker.js
@@ -0,0 +1,616 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	// This function is to be called under a "walker" instance scope.
+	function iterate( rtl, breakOnFalse ) {
+		var range = this.range;
+
+		// Return null if we have reached the end.
+		if ( this._.end )
+			return null;
+
+		// This is the first call. Initialize it.
+		if ( !this._.start ) {
+			this._.start = 1;
+
+			// A collapsed range must return null at first call.
+			if ( range.collapsed ) {
+				this.end();
+				return null;
+			}
+
+			// Move outside of text node edges.
+			range.optimize();
+		}
+
+		var node,
+			startCt = range.startContainer,
+			endCt = range.endContainer,
+			startOffset = range.startOffset,
+			endOffset = range.endOffset,
+			guard,
+			userGuard = this.guard,
+			type = this.type,
+			getSourceNodeFn = ( rtl ? 'getPreviousSourceNode' : 'getNextSourceNode' );
+
+		// Create the LTR guard function, if necessary.
+		if ( !rtl && !this._.guardLTR ) {
+			// The node that stops walker from moving up.
+			var limitLTR = endCt.type == CKEDITOR.NODE_ELEMENT ? endCt : endCt.getParent();
+
+			// The node that stops the walker from going to next.
+			var blockerLTR = endCt.type == CKEDITOR.NODE_ELEMENT ? endCt.getChild( endOffset ) : endCt.getNext();
+
+			this._.guardLTR = function( node, movingOut ) {
+				return ( ( !movingOut || !limitLTR.equals( node ) ) && ( !blockerLTR || !node.equals( blockerLTR ) ) && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || !node.equals( range.root ) ) );
+			};
+		}
+
+		// Create the RTL guard function, if necessary.
+		if ( rtl && !this._.guardRTL ) {
+			// The node that stops walker from moving up.
+			var limitRTL = startCt.type == CKEDITOR.NODE_ELEMENT ? startCt : startCt.getParent();
+
+			// The node that stops the walker from going to next.
+			var blockerRTL = startCt.type == CKEDITOR.NODE_ELEMENT ? startOffset ? startCt.getChild( startOffset - 1 ) : null : startCt.getPrevious();
+
+			this._.guardRTL = function( node, movingOut ) {
+				return ( ( !movingOut || !limitRTL.equals( node ) ) && ( !blockerRTL || !node.equals( blockerRTL ) ) && ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || !node.equals( range.root ) ) );
+			};
+		}
+
+		// Define which guard function to use.
+		var stopGuard = rtl ? this._.guardRTL : this._.guardLTR;
+
+		// Make the user defined guard function participate in the process,
+		// otherwise simply use the boundary guard.
+		if ( userGuard ) {
+			guard = function( node, movingOut ) {
+				if ( stopGuard( node, movingOut ) === false )
+					return false;
+
+				return userGuard( node, movingOut );
+			};
+		} else
+			guard = stopGuard;
+
+		if ( this.current )
+			node = this.current[ getSourceNodeFn ]( false, type, guard );
+		else {
+			// Get the first node to be returned.
+			if ( rtl ) {
+				node = endCt;
+
+				if ( node.type == CKEDITOR.NODE_ELEMENT ) {
+					if ( endOffset > 0 )
+						node = node.getChild( endOffset - 1 );
+					else
+						node = ( guard( node, true ) === false ) ? null : node.getPreviousSourceNode( true, type, guard );
+				}
+			} else {
+				node = startCt;
+
+				if ( node.type == CKEDITOR.NODE_ELEMENT ) {
+					if ( !( node = node.getChild( startOffset ) ) )
+						node = ( guard( startCt, true ) === false ) ? null : startCt.getNextSourceNode( true, type, guard );
+				}
+			}
+
+			if ( node && guard( node ) === false )
+				node = null;
+		}
+
+		while ( node && !this._.end ) {
+			this.current = node;
+
+			if ( !this.evaluator || this.evaluator( node ) !== false ) {
+				if ( !breakOnFalse )
+					return node;
+			} else if ( breakOnFalse && this.evaluator )
+				return false;
+
+			node = node[ getSourceNodeFn ]( false, type, guard );
+		}
+
+		this.end();
+		return this.current = null;
+	}
+
+	function iterateToLast( rtl ) {
+		var node,
+			last = null;
+
+		while ( ( node = iterate.call( this, rtl ) ) )
+			last = node;
+
+		return last;
+	}
+
+	/**
+	 * Utility class to "walk" the DOM inside a range boundaries. If the
+	 * range starts or ends in the middle of the text node this node will
+	 * be included as a whole. 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.
+	 *
+	 * @class
+	 */
+	CKEDITOR.dom.walker = CKEDITOR.tools.createClass( {
+		/**
+		 * Creates a walker class instance.
+		 *
+		 * @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.
+			 *
+			 * @property {Function} evaluator
+			 */
+			// 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.
+
+			 * @property {Function} guard
+			 */
+			// 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
+		//			 *		&lt;body&gt; 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: {
+			/**
+			 * Stops 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 function.
+			 *
+			 * @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 function.
+			 *
+			 * @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 );
+			},
+
+			/**
+			 * Resets walker.
+			 */
+			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 },
+		outOfFlowPositions = { absolute: 1, fixed: 1 };
+
+	/**
+	 * Checks whether element is displayed as a block.
+	 *
+	 * @member CKEDITOR.dom.element
+	 * @param [customNodeNames] Custom list of nodes which will extend
+	 * default {@link CKEDITOR.dtd#$block} list.
+	 * @returns {Boolean}
+	 */
+	CKEDITOR.dom.element.prototype.isBlockBoundary = function( customNodeNames ) {
+		// Whether element is in normal page flow. Floated or positioned elements are out of page flow.
+		// Don't consider floated or positioned formatting as block boundary, fall back to dtd check in that case. (#6297)
+		var inPageFlow = this.getComputedStyle( 'float' ) == 'none' && !( this.getComputedStyle( 'position' ) in outOfFlowPositions );
+
+		if ( inPageFlow && blockBoundaryDisplayMatch[ this.getComputedStyle( 'display' ) ] )
+			return true;
+
+		// Either in $block or in customNodeNames if defined.
+		return !!( this.is( CKEDITOR.dtd.$block ) || customNodeNames && this.is( customNodeNames ) );
+	};
+
+	/**
+	 * Returns a function which checks whether the node is a block boundary.
+	 * See {@link CKEDITOR.dom.element#isBlockBoundary}.
+	 *
+	 * @static
+	 * @param customNodeNames
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.blockBoundary = function( customNodeNames ) {
+		return function( node, type ) {
+			return !( node.type == CKEDITOR.NODE_ELEMENT && node.isBlockBoundary( customNodeNames ) );
+		};
+	};
+
+	/**
+	 * @static
+	 * @todo
+	 */
+	CKEDITOR.dom.walker.listItemBoundary = function() {
+		return this.blockBoundary( { br: 1 } );
+	};
+
+	/**
+	 * Returns a function which checks whether the node is a bookmark node OR bookmark node
+	 * inner contents.
+	 *
+	 * @static
+	 * @param {Boolean} [contentOnly=false] Whether only test against the text content of
+	 * bookmark node instead of the element itself (default).
+	 * @param {Boolean} [isReject=false] Whether should return `false` for the bookmark
+	 * node instead of `true` (default).
+	 * @returns {Function}
+	 */
+	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.type != CKEDITOR.NODE_ELEMENT && ( parent = node.getParent() ) && isBookmarkNode( parent ) );
+			// Is bookmark node?
+			isBookmark = contentOnly ? isBookmark : isBookmark || isBookmarkNode( node );
+			return !!( isReject ^ isBookmark );
+		};
+	};
+
+	/**
+	 * Returns a function which checks whether the node is a text node containing only whitespaces characters.
+	 *
+	 * @static
+	 * @param {Boolean} [isReject=false]
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.whitespaces = function( isReject ) {
+		return function( node ) {
+			var isWhitespace;
+			if ( node && node.type == CKEDITOR.NODE_TEXT ) {
+				// whitespace, as well as the text cursor filler node we used in Webkit. (#9384)
+				isWhitespace = !CKEDITOR.tools.trim( node.getText() ) ||
+					CKEDITOR.env.webkit && node.getText() == '\u200b';
+			}
+
+			return !!( isReject ^ isWhitespace );
+		};
+	};
+
+	/**
+	 * Returns a function which checks whether the node is invisible in wysiwyg mode.
+	 *
+	 * @static
+	 * @param {Boolean} [isReject=false]
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.invisible = function( isReject ) {
+		var whitespace = CKEDITOR.dom.walker.whitespaces();
+		return function( node ) {
+			var invisible;
+
+			if ( whitespace( node ) )
+				invisible = 1;
+			else {
+				// Visibility should be checked on element.
+				if ( node.type == CKEDITOR.NODE_TEXT )
+					node = node.getParent();
+
+			// 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 />.
+				invisible = !node.$.offsetHeight;
+			}
+
+			return !!( isReject ^ invisible );
+		};
+	};
+
+	/**
+	 * Returns a function which checks whether node's type is equal to passed one.
+	 *
+	 * @static
+	 * @param {Number} type
+	 * @param {Boolean} [isReject=false]
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.nodeType = function( type, isReject ) {
+		return function( node ) {
+			return !!( isReject ^ ( node.type == type ) );
+		};
+	};
+
+	/**
+	 * Returns a function which checks whether node is a bogus (filler) node from
+	 * contenteditable element's point of view.
+	 *
+	 * @static
+	 * @param {Boolean} [isReject=false]
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.bogus = function( isReject ) {
+		function nonEmpty( node ) {
+			return !isWhitespaces( node ) && !isBookmark( node );
+		}
+
+		return function( node ) {
+			var isBogus = CKEDITOR.env.needsBrFiller ? node.is && node.is( 'br' ) : node.getText && tailNbspRegex.test( node.getText() );
+
+			if ( isBogus ) {
+				var parent = node.getParent(),
+					next = node.getNext( nonEmpty );
+
+				isBogus = parent.isBlockBoundary() && ( !next || next.type == CKEDITOR.NODE_ELEMENT && next.isBlockBoundary() );
+			}
+
+			return !!( isReject ^ isBogus );
+		};
+	};
+
+	/**
+	 * Returns a function which checks whether node is a temporary element
+	 * (element with `data-cke-temp` attribute) or its child.
+	 *
+	 * @since 4.3
+	 * @static
+	 * @param {Boolean} [isReject=false] Whether should return `false` for the
+	 * temporary element instead of `true` (default).
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.temp = function( isReject ) {
+		return function( node ) {
+			if ( node.type != CKEDITOR.NODE_ELEMENT )
+				node = node.getParent();
+
+			var isTemp = node && node.hasAttribute( 'data-cke-temp' );
+
+			return !!( isReject ^ isTemp );
+		};
+	};
+
+	var tailNbspRegex = /^[\t\r\n ]*(?:&nbsp;|\xa0)$/,
+		isWhitespaces = CKEDITOR.dom.walker.whitespaces(),
+		isBookmark = CKEDITOR.dom.walker.bookmark(),
+		isTemp = CKEDITOR.dom.walker.temp(),
+		toSkip = function( node ) {
+			return isBookmark( node ) ||
+				isWhitespaces( node ) ||
+				node.type == CKEDITOR.NODE_ELEMENT && node.is( CKEDITOR.dtd.$inline ) && !node.is( CKEDITOR.dtd.$empty );
+		};
+
+	/**
+	 * Returns a function which checks whether node should be ignored in terms of "editability".
+	 *
+	 * This includes:
+	 *
+	 * * whitespaces (see {@link CKEDITOR.dom.walker#whitespaces}),
+	 * * bookmarks (see {@link CKEDITOR.dom.walker#bookmark}),
+	 * * temporary elements (see {@link CKEDITOR.dom.walker#temp}).
+	 *
+	 * @since 4.3
+	 * @static
+	 * @param {Boolean} [isReject=false] Whether should return `false` for the
+	 * ignored element instead of `true` (default).
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.ignored = function( isReject ) {
+		return function( node ) {
+			var isIgnored = isWhitespaces( node ) || isBookmark( node ) || isTemp( node );
+
+			return !!( isReject ^ isIgnored );
+		};
+	};
+
+	var isIgnored = CKEDITOR.dom.walker.ignored();
+
+	function isEmpty( node ) {
+		var i = 0,
+			l = node.getChildCount();
+
+		for ( ; i < l; ++i ) {
+			if ( !isIgnored( node.getChild( i ) ) )
+				return false;
+		}
+		return true;
+	}
+
+	function filterTextContainers( dtd ) {
+		var hash = {},
+			name;
+
+		for ( name in dtd ) {
+			if ( CKEDITOR.dtd[ name ][ '#' ] )
+				hash[ name ] = 1;
+		}
+		return hash;
+	}
+
+	// Block elements which can contain text nodes (without ul, ol, dl, etc.).
+	var dtdTextBlock = filterTextContainers( CKEDITOR.dtd.$block );
+
+	function isEditable( node ) {
+		// Skip temporary elements, bookmarks and whitespaces.
+		if ( isIgnored( node ) )
+			return false;
+
+		if ( node.type == CKEDITOR.NODE_TEXT )
+			return true;
+
+		if ( node.type == CKEDITOR.NODE_ELEMENT ) {
+			// All inline and non-editable elements are valid editable places.
+			// Note: non-editable block has to be treated differently (should be selected entirely).
+			if ( node.is( CKEDITOR.dtd.$inline ) || node.getAttribute( 'contenteditable' ) == 'false' )
+				return true;
+
+			// Empty blocks are editable on IE.
+			if ( !CKEDITOR.env.needsBrFiller && node.is( dtdTextBlock ) && isEmpty( node ) )
+				return true;
+		}
+
+		// Skip all other nodes.
+		return false;
+	}
+
+	/**
+	 * Returns a function which checks whether node can be a container or a sibling
+	 * of selection end.
+	 *
+	 * This includes:
+	 *
+	 * * text nodes (but not whitespaces),
+	 * * inline elements,
+	 * * non-editable blocks (special case - such blocks cannot be containers nor
+	 * siblings, they need to be selected entirely),
+	 * * empty blocks which can contain text (IE only).
+	 *
+	 * @since 4.3
+	 * @static
+	 * @param {Boolean} [isReject=false] Whether should return `false` for the
+	 * ignored element instead of `true` (default).
+	 * @returns {Function}
+	 */
+	CKEDITOR.dom.walker.editable = function( isReject ) {
+		return function( node ) {
+			return !!( isReject ^ isEditable( node ) );
+		};
+	};
+
+	/**
+	 * Checks if there's a filler node at the end of an element, and returns it.
+	 *
+	 * @member CKEDITOR.dom.element
+	 * @returns {CKEDITOR.dom.node/Boolean} Bogus node or `false`.
+	 */
+	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.needsBrFiller ? tail.is && tail.is( 'br' ) : tail.getText && tailNbspRegex.test( tail.getText() ) ) )
+			return tail;
+
+		return false;
+	};
+
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/dom/window.js b/lam/templates/lib/extra/ckeditor/core/dom/window.js
new file mode 100644
index 00000000..c371e486
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/dom/window.js
@@ -0,0 +1,95 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.dom.document} class, which
+ *		represents a DOM document.
+ */
+
+/**
+ * Represents a DOM window.
+ *
+ *		var document = new CKEDITOR.dom.window( window );
+ *
+ * @class
+ * @extends CKEDITOR.dom.domObject
+ * @constructor Creates a window class instance.
+ * @param {Object} domWindow A native DOM window.
+ */
+CKEDITOR.dom.window = function( domWindow ) {
+	CKEDITOR.dom.domObject.call( this, domWindow );
+};
+
+CKEDITOR.dom.window.prototype = new CKEDITOR.dom.domObject();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.window.prototype, {
+	/**
+	 * Moves the selection focus to this window.
+	 *
+	 *		var win = new CKEDITOR.dom.window( window );
+	 *		win.focus();
+	 */
+	focus: function() {
+		this.$.focus();
+	},
+
+	/**
+	 * Gets the width and height of this window's viewable area.
+	 *
+	 *		var win = new CKEDITOR.dom.window( window );
+	 *		var size = win.getViewPaneSize();
+	 *		alert( size.width );
+	 *		alert( size.height );
+	 *
+	 * @returns {Object} An object with the `width` and `height`
+	 * properties containing the size.
+	 */
+	getViewPaneSize: function() {
+		var doc = this.$.document,
+			stdMode = doc.compatMode == 'CSS1Compat';
+		return {
+			width: ( stdMode ? doc.documentElement.clientWidth : doc.body.clientWidth ) || 0,
+			height: ( stdMode ? doc.documentElement.clientHeight : doc.body.clientHeight ) || 0
+		};
+	},
+
+	/**
+	 * Gets the current position of the window's scroll.
+	 *
+	 *		var win = new CKEDITOR.dom.window( window );
+	 *		var pos = win.getScrollPosition();
+	 *		alert( pos.x );
+	 *		alert( pos.y );
+	 *
+	 * @returns {Object} An object with the `x` and `y` properties
+	 * containing the scroll position.
+	 */
+	getScrollPosition: function() {
+		var $ = this.$;
+
+		if ( 'pageXOffset' in $ ) {
+			return {
+				x: $.pageXOffset || 0,
+				y: $.pageYOffset || 0
+			};
+		} else {
+			var doc = $.document;
+			return {
+				x: doc.documentElement.scrollLeft || doc.body.scrollLeft || 0,
+				y: doc.documentElement.scrollTop || doc.body.scrollTop || 0
+			};
+		}
+	},
+
+	/**
+	 * Gets the frame element containing this window context.
+	 *
+	 * @returns {CKEDITOR.dom.element} The frame element or `null` if not in a frame context.
+	 */
+	getFrame: function() {
+		var iframe = this.$.frameElement;
+		return iframe ? new CKEDITOR.dom.element.get( iframe ) : null;
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/basicwriter.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/basicwriter.js
new file mode 100644
index 00000000..27651b60
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/basicwriter.js
@@ -0,0 +1,152 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * TODO
+ *
+ * @class
+ * @todo
+ */
+CKEDITOR.htmlParser.basicWriter = CKEDITOR.tools.createClass( {
+	/**
+	 * Creates a basicWriter class instance.
+	 *
+	 * @constructor
+	 */
+	$: function() {
+		this._ = {
+			output: []
+		};
+	},
+
+	proto: {
+		/**
+		 * Writes the tag opening part for a opener tag.
+		 *
+		 *		// Writes '<p'.
+		 *		writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 * @param {Object} attributes The attributes defined for this tag. The
+		 * attributes could be used to inspect the tag.
+		 */
+		openTag: function( tagName, attributes ) {
+			this._.output.push( '<', tagName );
+		},
+
+		/**
+		 * Writes the tag closing part for a opener tag.
+		 *
+		 *		// Writes '>'.
+		 *		writer.openTagClose( 'p', false );
+		 *
+		 *		// Writes ' />'.
+		 *		writer.openTagClose( 'br', true );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 * @param {Boolean} isSelfClose Indicates that this is a self-closing tag,
+		 * like `<br>` or `<img>`.
+		 */
+		openTagClose: function( tagName, isSelfClose ) {
+			if ( isSelfClose )
+				this._.output.push( ' />' );
+			else
+				this._.output.push( '>' );
+		},
+
+		/**
+		 * Writes an attribute. This function should be called after opening the
+		 * tag with {@link #openTagClose}.
+		 *
+		 *		// Writes ' class="MyClass"'.
+		 *		writer.attribute( 'class', 'MyClass' );
+		 *
+		 * @param {String} attName The attribute name.
+		 * @param {String} attValue The attribute value.
+		 */
+		attribute: function( attName, attValue ) {
+			// Browsers don't always escape special character in attribute values. (#4683, #4719).
+			if ( typeof attValue == 'string' )
+				attValue = CKEDITOR.tools.htmlEncodeAttr( attValue );
+
+			this._.output.push( ' ', attName, '="', attValue, '"' );
+		},
+
+		/**
+		 * Writes a closer tag.
+		 *
+		 *		// Writes '</p>'.
+		 *		writer.closeTag( 'p' );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 */
+		closeTag: function( tagName ) {
+			this._.output.push( '</', tagName, '>' );
+		},
+
+		/**
+		 * Writes text.
+		 *
+		 *		// Writes 'Hello Word'.
+		 *		writer.text( 'Hello Word' );
+		 *
+		 * @param {String} text The text value.
+		 */
+		text: function( text ) {
+			this._.output.push( text );
+		},
+
+		/**
+		 * Writes a comment.
+		 *
+		 *		// Writes '<!-- My comment -->'.
+		 *		writer.comment( ' My comment ' );
+		 *
+		 * @param {String} comment The comment text.
+		 */
+		comment: function( comment ) {
+			this._.output.push( '<!--', comment, '-->' );
+		},
+
+		/**
+		 * Writes any kind of data to the ouput.
+		 *
+		 *		writer.write( 'This is an <b>example</b>.' );
+		 *
+		 * @param {String} data
+		 */
+		write: function( data ) {
+			this._.output.push( data );
+		},
+
+		/**
+		 * Empties the current output buffer.
+		 *
+		 *		writer.reset();
+		 */
+		reset: function() {
+			this._.output = [];
+			this._.indent = false;
+		},
+
+		/**
+		 * Empties the current output buffer.
+		 *
+		 *		var html = writer.getHtml();
+		 *
+		 * @param {Boolean} reset Indicates that the {@link #reset} method is to
+		 * be automatically called after retrieving the HTML.
+		 * @returns {String} The HTML written to the writer so far.
+		 */
+		getHtml: function( reset ) {
+			var html = this._.output.join( '' );
+
+			if ( reset )
+				this.reset();
+
+			return html;
+		}
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/cdata.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/cdata.js
new file mode 100644
index 00000000..01172531
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/cdata.js
@@ -0,0 +1,48 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+ 'use strict';
+
+( function() {
+
+	/**
+	 * A lightweight representation of HTML CDATA.
+	 *
+	 * @class
+	 * @extends CKEDITOR.htmlParser.node
+	 * @constructor Creates a cdata class instance.
+	 * @param {String} value The CDATA section value.
+	 */
+	CKEDITOR.htmlParser.cdata = function( value ) {
+		/**
+		 * The CDATA value.
+		 *
+		 * @property {String}
+		 */
+		this.value = value;
+	};
+
+	CKEDITOR.htmlParser.cdata.prototype = CKEDITOR.tools.extend( new CKEDITOR.htmlParser.node(), {
+		/**
+		 * CDATA has the same type as {@link CKEDITOR.htmlParser.text} This is
+		 * a constant value set to {@link CKEDITOR#NODE_TEXT}.
+		 *
+		 * @readonly
+		 * @property {Number} [=CKEDITOR.NODE_TEXT]
+		 */
+		type: CKEDITOR.NODE_TEXT,
+
+		filter: function() {},
+
+		/**
+		 * Writes the CDATA with no special manipulations.
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 */
+		writeHtml: function( writer ) {
+			writer.write( this.value );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/comment.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/comment.js
new file mode 100644
index 00000000..7a485f57
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/comment.js
@@ -0,0 +1,80 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+ 'use strict';
+
+/**
+ * A lightweight representation of an HTML comment.
+ *
+ * @class
+ * @extends CKEDITOR.htmlParser.node
+ * @constructor Creates a comment class instance.
+ * @param {String} value The comment text value.
+ */
+CKEDITOR.htmlParser.comment = function( value ) {
+	/**
+	 * The comment text.
+	 *
+	 * @property {String}
+	 */
+	this.value = value;
+
+	/** @private */
+	this._ = {
+		isBlockLike: false
+	};
+};
+
+CKEDITOR.htmlParser.comment.prototype = CKEDITOR.tools.extend( new CKEDITOR.htmlParser.node(), {
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR#NODE_COMMENT}.
+	 *
+	 * @readonly
+	 * @property {Number} [=CKEDITOR.NODE_COMMENT]
+	 */
+	type: CKEDITOR.NODE_COMMENT,
+
+	/**
+	 * Filter this comment with given filter.
+	 *
+	 * @since 4.1
+	 * @param {CKEDITOR.htmlParser.filter} filter
+	 * @returns {Boolean} Method returns `false` when this comment has
+	 * been removed or replaced with other node. This is an information for
+	 * {@link CKEDITOR.htmlParser.element#filterChildren} that it has
+	 * to repeat filter on current position in parent's children array.
+	 */
+	filter: function( filter, context ) {
+		var comment = this.value;
+
+		if ( !( comment = filter.onComment( context, comment, this ) ) ) {
+			this.remove();
+			return false;
+		}
+
+		if ( typeof comment != 'string' ) {
+			this.replaceWith( comment );
+			return false;
+		}
+
+		this.value = comment;
+
+		return true;
+	},
+
+	/**
+	 * Writes the HTML representation of this comment to a CKEDITOR.htmlWriter.
+	 *
+	 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+	 * @param {CKEDITOR.htmlParser.filter} [filter] The filter to be applied to this node.
+	 * **Note:** it's unsafe to filter offline (not appended) node.
+	 */
+	writeHtml: function( writer, filter ) {
+		if ( filter )
+			this.filter( filter );
+
+		writer.comment( this.value );
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/element.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/element.js
new file mode 100644
index 00000000..2b8ce51d
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/element.js
@@ -0,0 +1,519 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+'use strict';
+
+/**
+ * A lightweight representation of an HTML element.
+ *
+ * @class
+ * @extends CKEDITOR.htmlParser.node
+ * @constructor Creates an element class instance.
+ * @param {String} name The element name.
+ * @param {Object} attributes And object holding all attributes defined for
+ * this element.
+ */
+CKEDITOR.htmlParser.element = function( name, attributes ) {
+	/**
+	 * The element name.
+	 *
+	 * @property {String}
+	 */
+	this.name = name;
+
+	/**
+	 * Holds the attributes defined for this element.
+	 *
+	 * @property {Object}
+	 */
+	this.attributes = attributes || {};
+
+	/**
+	 * The nodes that are direct children of this element.
+	 */
+	this.children = [];
+
+	// Reveal the real semantic of our internal custom tag name (#6639),
+	// when resolving whether it's block like.
+	var realName = name || '',
+		prefixed = realName.match( /^cke:(.*)/ );
+	prefixed && ( realName = prefixed[ 1 ] );
+
+	var isBlockLike = !!( CKEDITOR.dtd.$nonBodyContent[ realName ] || CKEDITOR.dtd.$block[ realName ] || CKEDITOR.dtd.$listItem[ realName ] || CKEDITOR.dtd.$tableContent[ realName ] || CKEDITOR.dtd.$nonEditable[ realName ] || realName == 'br' );
+
+	this.isEmpty = !!CKEDITOR.dtd.$empty[ name ];
+	this.isUnknown = !CKEDITOR.dtd[ name ];
+
+	/** @private */
+	this._ = {
+		isBlockLike: isBlockLike,
+		hasInlineStarted: this.isEmpty || !isBlockLike
+	};
+};
+
+/**
+ * Object presentation of CSS style declaration text.
+ *
+ * @class
+ * @constructor Creates a cssStyle class instance.
+ * @param {CKEDITOR.htmlParser.element/String} elementOrStyleText
+ * A html parser element or the inline style text.
+ */
+CKEDITOR.htmlParser.cssStyle = function() {
+	var styleText,
+		arg = arguments[ 0 ],
+		rules = {};
+
+	styleText = arg instanceof CKEDITOR.htmlParser.element ? arg.attributes.style : arg;
+
+	// html-encoded quote might be introduced by 'font-family'
+	// from MS-Word which confused the following regexp. e.g.
+	//'font-family: &quot;Lucida, Console&quot;'
+	// TODO reuse CSS methods from tools.
+	( styleText || '' ).replace( /&quot;/g, '"' ).replace( /\s*([^ :;]+)\s*:\s*([^;]+)\s*(?=;|$)/g, function( match, name, value ) {
+		name == 'font-family' && ( value = value.replace( /["']/g, '' ) );
+		rules[ name.toLowerCase() ] = value;
+	} );
+
+	return {
+
+		rules: rules,
+
+		/**
+		 * Apply the styles onto the specified element or object.
+		 *
+		 * @param {CKEDITOR.htmlParser.element/CKEDITOR.dom.element/Object} obj
+		 */
+		populate: function( obj ) {
+			var style = this.toString();
+			if ( style )
+				obj instanceof CKEDITOR.dom.element ? obj.setAttribute( 'style', style ) : obj instanceof CKEDITOR.htmlParser.element ? obj.attributes.style = style : obj.style = style;
+
+		},
+
+		/**
+		 * Serialize CSS style declaration to string.
+		 *
+		 * @returns {String}
+		 */
+		toString: function() {
+			var output = [];
+			for ( var i in rules )
+				rules[ i ] && output.push( i, ':', rules[ i ], ';' );
+			return output.join( '' );
+		}
+	};
+};
+
+/** @class CKEDITOR.htmlParser.element */
+( function() {
+	// Used to sort attribute entries in an array, where the first element of
+	// each object is the attribute name.
+	var sortAttribs = function( a, b ) {
+			a = a[ 0 ];
+			b = b[ 0 ];
+			return a < b ? -1 : a > b ? 1 : 0;
+		},
+		fragProto = CKEDITOR.htmlParser.fragment.prototype;
+
+	CKEDITOR.htmlParser.element.prototype = CKEDITOR.tools.extend( new CKEDITOR.htmlParser.node(), {
+		/**
+		 * The node type. This is a constant value set to {@link CKEDITOR#NODE_ELEMENT}.
+		 *
+		 * @readonly
+		 * @property {Number} [=CKEDITOR.NODE_ELEMENT]
+		 */
+		type: CKEDITOR.NODE_ELEMENT,
+
+		/**
+		 * Adds a node to the element children list.
+		 *
+		 * @method
+		 * @param {CKEDITOR.htmlParser.node} node The node to be added.
+		 * @param {Number} [index] From where the insertion happens.
+		 */
+		add: fragProto.add,
+
+		/**
+		 * Clone this element.
+		 *
+		 * @returns {CKEDITOR.htmlParser.element} The element clone.
+		 */
+		clone: function() {
+			return new CKEDITOR.htmlParser.element( this.name, this.attributes );
+		},
+
+		/**
+		 * Filter this element and its children with given filter.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.filter} filter
+		 * @returns {Boolean} Method returns `false` when this element has
+		 * been removed or replaced with other. This is an information for
+		 * {@link #filterChildren} that it has to repeat filter on current
+		 * position in parent's children array.
+		 */
+		filter: function( filter, context ) {
+			var element = this,
+				originalName, name;
+
+			context = element.getFilterContext( context );
+
+			// Do not process elements with data-cke-processor attribute set to off.
+			if ( context.off )
+				return true;
+
+			// Filtering if it's the root node.
+			if ( !element.parent )
+				filter.onRoot( context, element );
+
+			while ( true ) {
+				originalName = element.name;
+
+				if ( !( name = filter.onElementName( context, originalName ) ) ) {
+					this.remove();
+					return false;
+				}
+
+				element.name = name;
+
+				if ( !( element = filter.onElement( context, element ) ) ) {
+					this.remove();
+					return false;
+				}
+
+				// New element has been returned - replace current one
+				// and process it (stop processing this and return false, what
+				// means that element has been removed).
+				if ( element !== this ) {
+					this.replaceWith( element );
+					return false;
+				}
+
+				// If name has been changed - continue loop, so in next iteration
+				// filters for new name will be applied to this element.
+				// If name hasn't been changed - stop.
+				if ( element.name == originalName )
+					break;
+
+				// If element has been replaced with something of a
+				// different type, then make the replacement filter itself.
+				if ( element.type != CKEDITOR.NODE_ELEMENT ) {
+					this.replaceWith( element );
+					return false;
+				}
+
+				// This indicate that the element has been dropped by
+				// filter but not the children.
+				if ( !element.name ) {
+					this.replaceWithChildren();
+					return false;
+				}
+			}
+
+			var attributes = element.attributes,
+				a, value, newAttrName;
+
+			for ( a in attributes ) {
+				newAttrName = a;
+				value = attributes[ a ];
+
+				// Loop until name isn't modified.
+				// A little bit senseless, but IE would do that anyway
+				// because it iterates with for-in loop even over properties
+				// created during its run.
+				while ( true ) {
+					if ( !( newAttrName = filter.onAttributeName( context, a ) ) ) {
+						delete attributes[ a ];
+						break;
+					} else if ( newAttrName != a ) {
+						delete attributes[ a ];
+						a = newAttrName;
+						continue;
+					} else
+						break;
+				}
+
+				if ( newAttrName ) {
+					if ( ( value = filter.onAttribute( context, element, newAttrName, value ) ) === false )
+						delete attributes[ newAttrName ];
+					else
+						attributes[ newAttrName ] = value;
+				}
+			}
+
+			if ( !element.isEmpty )
+				this.filterChildren( filter, false, context );
+
+			return true;
+		},
+
+		/**
+		 * Filter this element's children with given filter.
+		 *
+		 * Element's children may only be filtered once by one
+		 * instance of filter.
+		 *
+		 * @method filterChildren
+		 * @param {CKEDITOR.htmlParser.filter} filter
+		 */
+		filterChildren: fragProto.filterChildren,
+
+		/**
+		 * Writes the element HTML to a CKEDITOR.htmlWriter.
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 * @param {CKEDITOR.htmlParser.filter} [filter] The filter to be applied to this node.
+		 * **Note:** it's unsafe to filter offline (not appended) node.
+		 */
+		writeHtml: function( writer, filter ) {
+			if ( filter )
+				this.filter( filter );
+
+			var name = this.name,
+				attribsArray = [],
+				attributes = this.attributes,
+				attrName,
+				attr, i, l;
+
+			// Open element tag.
+			writer.openTag( name, attributes );
+
+			// Copy all attributes to an array.
+			for ( attrName in attributes )
+				attribsArray.push( [ attrName, attributes[ attrName ] ] );
+
+			// Sort the attributes by name.
+			if ( writer.sortAttributes )
+				attribsArray.sort( sortAttribs );
+
+			// Send the attributes.
+			for ( i = 0, l = attribsArray.length; i < l; i++ ) {
+				attr = attribsArray[ i ];
+				writer.attribute( attr[ 0 ], attr[ 1 ] );
+			}
+
+			// Close the tag.
+			writer.openTagClose( name, this.isEmpty );
+
+			this.writeChildrenHtml( writer );
+
+			// Close the element.
+			if ( !this.isEmpty )
+				writer.closeTag( name );
+		},
+
+		/**
+		 * Send children of this element to the writer.
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 * @param {CKEDITOR.htmlParser.filter} [filter]
+		 */
+		writeChildrenHtml: fragProto.writeChildrenHtml,
+
+		/**
+		 * Replace this element with its children.
+		 *
+		 * @since 4.1
+		 */
+		replaceWithChildren: function() {
+			var children = this.children;
+
+			for ( var i = children.length; i; )
+				children[ --i ].insertAfter( this );
+
+			this.remove();
+		},
+
+		/**
+		 * Execute callback on each node (of given type) in this element.
+		 *
+		 *		// Create <p> element with foo<b>bar</b>bom as its content.
+		 *		var elP = CKEDITOR.htmlParser.fragment.fromHtml( 'foo<b>bar</b>bom', 'p' );
+		 *		elP.forEach( function( node ) {
+		 *			console.log( node );
+		 *		} );
+		 *		// Will log:
+		 *		// 1. document fragment,
+		 *		// 2. <p> element,
+		 *		// 3. "foo" text node,
+		 *		// 4. <b> element,
+		 *		// 5. "bar" text node,
+		 *		// 6. "bom" text node.
+		 *
+		 * @since 4.1
+		 * @param {Function} callback Function to be executed on every node.
+		 * **Since 4.3** if `callback` returned `false` descendants of current node will be ignored.
+		 * @param {CKEDITOR.htmlParser.node} callback.node Node passed as argument.
+		 * @param {Number} [type] If specified `callback` will be executed only on nodes of this type.
+		 * @param {Boolean} [skipRoot] Don't execute `callback` on this element.
+		 */
+		forEach: fragProto.forEach,
+
+		/**
+		 * Gets this element's first child. If `condition` is given returns
+		 * first child which satisfies that condition.
+		 *
+		 * @since 4.3
+		 * @param {String/Object/Function} condition Name of a child, hash of names or validator function.
+		 * @returns {CKEDITOR.htmlParser.node}
+		 */
+		getFirst: function( condition ) {
+			if ( !condition )
+				return this.children.length ? this.children[ 0 ] : null;
+
+			if ( typeof condition != 'function' )
+				condition = nameCondition( condition );
+
+			for ( var i = 0, l = this.children.length; i < l; ++i ) {
+				if ( condition( this.children[ i ] ) )
+					return this.children[ i ];
+			}
+			return null;
+		},
+
+		/**
+		 * Gets this element's inner HTML.
+		 *
+		 * @since 4.3
+		 * @returns {String}
+		 */
+		getHtml: function() {
+			var writer = new CKEDITOR.htmlParser.basicWriter();
+			this.writeChildrenHtml( writer );
+			return writer.getHtml();
+		},
+
+		/**
+		 * Sets this element's inner HTML.
+		 *
+		 * @since 4.3
+		 * @param {String} html
+		 */
+		setHtml: function( html ) {
+			var children = this.children = CKEDITOR.htmlParser.fragment.fromHtml( html ).children;
+
+			for ( var i = 0, l = children.length; i < l; ++i )
+				children[ i ].parent = this;
+		},
+
+		/**
+		 * Gets this element's outer HTML.
+		 *
+		 * @since 4.3
+		 * @returns {String}
+		 */
+		getOuterHtml: function() {
+			var writer = new CKEDITOR.htmlParser.basicWriter();
+			this.writeHtml( writer );
+			return writer.getHtml();
+		},
+
+		/**
+		 * Splits this element at given index.
+		 *
+		 * @since 4.3
+		 * @param {Number} index Index at which element will be split &ndash; `0` means beginning,
+		 * `1` after first child node, etc.
+		 * @returns {CKEDITOR.htmlParser.element} New element, following this one.
+		 */
+		split: function( index ) {
+			var cloneChildren = this.children.splice( index, this.children.length - index ),
+				clone = this.clone();
+
+			for ( var i = 0; i < cloneChildren.length; ++i )
+				cloneChildren[ i ].parent = clone;
+
+			clone.children = cloneChildren;
+
+			if ( cloneChildren[ 0 ] )
+				cloneChildren[ 0 ].previous = null;
+
+			if ( index > 0 )
+				this.children[ index - 1 ].next = null;
+
+			this.parent.add( clone, this.getIndex() + 1 );
+
+			return clone;
+		},
+
+		/**
+		 * Removes class name from classes list.
+		 *
+		 * @since 4.3
+		 * @param {String} className The class name to be removed.
+		 */
+		removeClass: function( className ) {
+			var classes = this.attributes[ 'class' ],
+				index;
+
+			if ( !classes )
+				return;
+
+			// We can safely assume that className won't break regexp.
+			// http://stackoverflow.com/questions/448981/what-characters-are-valid-in-css-class-names
+			classes = CKEDITOR.tools.trim( classes.replace( new RegExp( '(?:\\s+|^)' + className + '(?:\\s+|$)' ), ' ' ) );
+
+			if ( classes )
+				this.attributes[ 'class' ] = classes;
+			else
+				delete this.attributes[ 'class' ];
+		},
+
+		/**
+		 * Checkes whether this element has a class name.
+		 *
+		 * @since 4.3
+		 * @param {String} className The class name to be checked.
+		 * @returns {Boolean} Whether this element has a `className`.
+		 */
+		hasClass: function( className ) {
+			var classes = this.attributes[ 'class' ];
+
+			if ( !classes )
+				return false;
+
+			return ( new RegExp( '(?:^|\\s)' + className + '(?=\\s|$)' ) ).test( classes );
+		},
+
+		getFilterContext: function( ctx ) {
+			var changes = [];
+
+			if ( !ctx ) {
+				ctx = {
+					off: false,
+					nonEditable: false,
+					nestedEditable: false
+				};
+			}
+
+			if ( !ctx.off && this.attributes[ 'data-cke-processor' ] == 'off' )
+				changes.push( 'off', true );
+
+			if ( !ctx.nonEditable && this.attributes.contenteditable == 'false' )
+				changes.push( 'nonEditable', true );
+			// A context to be given nestedEditable must be nonEditable first (by inheritance) (#11372).
+			// Never set "nestedEditable" context for a body. If body is processed then it indicates
+			// a fullPage editor and there's no slightest change of nesting such editable (#11504).
+			else if ( this.name != 'body' && !ctx.nestedEditable && this.attributes.contenteditable == 'true' )
+				changes.push( 'nestedEditable', true );
+
+			if ( changes.length ) {
+				ctx = CKEDITOR.tools.copy( ctx );
+				for ( var i = 0; i < changes.length; i += 2 )
+					ctx[ changes[ i ] ] = changes[ i + 1 ];
+			}
+
+			return ctx;
+		}
+	}, true );
+
+	function nameCondition( condition ) {
+		return function( el ) {
+			return el.type == CKEDITOR.NODE_ELEMENT &&
+				( typeof condition == 'string' ? el.name == condition : el.name in condition );
+		};
+	}
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/filter.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/filter.js
new file mode 100644
index 00000000..d44122a5
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/filter.js
@@ -0,0 +1,407 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+'use strict';
+
+( function() {
+	/**
+	 * Filter is a configurable tool for transforming and filtering {@link CKEDITOR.htmlParser.node nodes}.
+	 * It is mainly used during data processing phase which is done not on real DOM nodes,
+	 * but on their simplified form represented by {@link CKEDITOR.htmlParser.node} class and its subclasses.
+	 *
+	 *		var filter = new CKEDITOR.htmlParser.filter( {
+	 *			text: function( value ) {
+	 *				return '@' + value + '@';
+	 *			},
+	 *			elements: {
+	 *				p: function( element ) {
+	 *					element.attributes.foo = '1';
+	 *				}
+	 *			}
+	 *		} );
+	 *
+	 *		var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<p>Foo<b>bar!</b></p>' ),
+	 *			writer = new CKEDITOR.htmlParser.basicWriter();
+	 *		filter.applyTo( fragment );
+	 *		fragment.writeHtml( writer );
+	 *		writer.getHtml(); // '<p foo="1">@Foo@<b>@bar!@</b></p>'
+	 *
+	 * @class
+	 */
+	CKEDITOR.htmlParser.filter = CKEDITOR.tools.createClass( {
+		/**
+		 * @constructor Creates a filter class instance.
+		 * @param {CKEDITOR.htmlParser.filterRulesDefinition} [rules]
+		 */
+		$: function( rules ) {
+			/**
+			 * ID of filter instance, which is used to mark elements
+			 * to which this filter has been already applied.
+			 *
+			 * @property {Number} id
+			 * @readonly
+			 */
+			this.id = CKEDITOR.tools.getNextNumber();
+
+			/**
+			 * Rules for element names.
+			 *
+			 * @property {CKEDITOR.htmlParser.filterRulesGroup}
+			 * @readonly
+			 */
+			this.elementNameRules = new filterRulesGroup();
+
+			/**
+			 * Rules for attribute names.
+			 *
+			 * @property {CKEDITOR.htmlParser.filterRulesGroup}
+			 * @readonly
+			 */
+			this.attributeNameRules = new filterRulesGroup();
+
+			/**
+			 * Hash of elementName => {@link CKEDITOR.htmlParser.filterRulesGroup rules for elements}.
+			 *
+			 * @readonly
+			 */
+			this.elementsRules = {};
+
+			/**
+			 * Hash of attributeName => {@link CKEDITOR.htmlParser.filterRulesGroup rules for attributes}.
+			 *
+			 * @readonly
+			 */
+			this.attributesRules = {};
+
+			/**
+			 * Rules for text nodes.
+			 *
+			 * @property {CKEDITOR.htmlParser.filterRulesGroup}
+			 * @readonly
+			 */
+			this.textRules = new filterRulesGroup();
+
+			/**
+			 * Rules for comment nodes.
+			 *
+			 * @property {CKEDITOR.htmlParser.filterRulesGroup}
+			 * @readonly
+			 */
+			this.commentRules = new filterRulesGroup();
+
+			/**
+			 * Rules for a root node.
+			 *
+			 * @property {CKEDITOR.htmlParser.filterRulesGroup}
+			 * @readonly
+			 */
+			this.rootRules = new filterRulesGroup();
+
+			if ( rules )
+				this.addRules( rules, 10 );
+		},
+
+		proto: {
+			/**
+			 * Add rules to this filter.
+			 *
+			 * @param {CKEDITOR.htmlParser.filterRulesDefinition} rules Object containing filter rules.
+			 * @param {Object/Number} [options] Object containing rules' options or a priority
+			 * (for a backward compatibility with CKEditor versions up to 4.2.x).
+			 * @param {Number} [options.priority=10] The priority of a rule.
+			 * @param {Boolean} [options.applyToAll=false] Whether to apply rule to non-editable
+			 * elements and their descendants too.
+			 */
+			addRules: function( rules, options ) {
+				var priority;
+
+				// Backward compatibility.
+				if ( typeof options == 'number' )
+					priority = options;
+				// New version - try reading from options.
+				else if ( options && ( 'priority' in options ) )
+					priority = options.priority;
+
+				// Defaults.
+				if ( typeof priority != 'number' )
+					priority = 10;
+				if ( typeof options != 'object' )
+					options = {};
+
+				// Add the elementNames.
+				if ( rules.elementNames )
+					this.elementNameRules.addMany( rules.elementNames, priority, options );
+
+				// Add the attributeNames.
+				if ( rules.attributeNames )
+					this.attributeNameRules.addMany( rules.attributeNames, priority, options );
+
+				// Add the elements.
+				if ( rules.elements )
+					addNamedRules( this.elementsRules, rules.elements, priority, options );
+
+				// Add the attributes.
+				if ( rules.attributes )
+					addNamedRules( this.attributesRules, rules.attributes, priority, options );
+
+				// Add the text.
+				if ( rules.text )
+					this.textRules.add( rules.text, priority, options );
+
+				// Add the comment.
+				if ( rules.comment )
+					this.commentRules.add( rules.comment, priority, options );
+
+				// Add root node rules.
+				if ( rules.root )
+					this.rootRules.add( rules.root, priority, options );
+			},
+
+			/**
+			 * Apply this filter to given node.
+			 *
+			 * @param {CKEDITOR.htmlParser.node} node The node to be filtered.
+			 */
+			applyTo: function( node ) {
+				node.filter( this );
+			},
+
+			onElementName: function( context, name ) {
+				return this.elementNameRules.execOnName( context, name );
+			},
+
+			onAttributeName: function( context, name ) {
+				return this.attributeNameRules.execOnName( context, name );
+			},
+
+			onText: function( context, text, node ) {
+				return this.textRules.exec( context, text, node );
+			},
+
+			onComment: function( context, commentText, comment ) {
+				return this.commentRules.exec( context, commentText, comment );
+			},
+
+			onRoot: function( context, element ) {
+				return this.rootRules.exec( context, element );
+			},
+
+			onElement: function( context, element ) {
+				// We must apply filters set to the specific element name as
+				// well as those set to the generic ^/$ name. So, add both to an
+				// array and process them in a small loop.
+				var rulesGroups = [ this.elementsRules[ '^' ], this.elementsRules[ element.name ], this.elementsRules.$ ],
+					rulesGroup, ret;
+
+				for ( var i = 0; i < 3; i++ ) {
+					rulesGroup = rulesGroups[ i ];
+					if ( rulesGroup ) {
+						ret = rulesGroup.exec( context, element, this );
+
+						if ( ret === false )
+							return null;
+
+						if ( ret && ret != element )
+							return this.onNode( context, ret );
+
+						// The non-root element has been dismissed by one of the filters.
+						if ( element.parent && !element.name )
+							break;
+					}
+				}
+
+				return element;
+			},
+
+			onNode: function( context, node ) {
+				var type = node.type;
+
+				return type == CKEDITOR.NODE_ELEMENT ? this.onElement( context, node ) :
+					type == CKEDITOR.NODE_TEXT ? new CKEDITOR.htmlParser.text( this.onText( context, node.value ) ) :
+					type == CKEDITOR.NODE_COMMENT ? new CKEDITOR.htmlParser.comment( this.onComment( context, node.value ) ) : null;
+			},
+
+			onAttribute: function( context, element, name, value ) {
+				var rulesGroup = this.attributesRules[ name ];
+
+				if ( rulesGroup )
+					return rulesGroup.exec( context, value, element, this );
+				return value;
+			}
+		}
+	} );
+
+	/**
+	 * Class grouping filter rules for one subject (like element or attribute names).
+	 *
+	 * @class CKEDITOR.htmlParser.filterRulesGroup
+	 */
+	function filterRulesGroup() {
+		/**
+		 * Array of objects containing rule, priority and options.
+		 *
+		 * @property {Object[]}
+		 * @readonly
+		 */
+		this.rules = [];
+	}
+
+	CKEDITOR.htmlParser.filterRulesGroup = filterRulesGroup;
+
+	filterRulesGroup.prototype = {
+		/**
+		 * Adds specified rule to this group.
+		 *
+		 * @param {Function/Array} rule Function for function based rule or [ pattern, replacement ] array for
+		 * rule applicable to names.
+		 * @param {Number} priority
+		 * @param options
+		 */
+		add: function( rule, priority, options ) {
+			this.rules.splice( this.findIndex( priority ), 0, {
+				value: rule,
+				priority: priority,
+				options: options
+			} );
+		},
+
+		/**
+		 * Adds specified rules to this group.
+		 *
+		 * @param {Array} rules Array of rules - see {@link #add}.
+		 * @param {Number} priority
+		 * @param options
+		 */
+		addMany: function( rules, priority, options ) {
+			var args = [ this.findIndex( priority ), 0 ];
+
+			for ( var i = 0, len = rules.length; i < len; i++ ) {
+				args.push( {
+					value: rules[ i ],
+					priority: priority,
+					options: options
+				} );
+			}
+
+			this.rules.splice.apply( this.rules, args );
+		},
+
+		/**
+		 * Finds an index at which rule with given priority should be inserted.
+		 *
+		 * @param {Number} priority
+		 * @returns {Number} Index.
+		 */
+		findIndex: function( priority ) {
+			var rules = this.rules,
+				len = rules.length,
+				i = len - 1;
+
+			// Search from the end, because usually rules will be added with default priority, so
+			// we will be able to stop loop quickly.
+			while ( i >= 0 && priority < rules[ i ].priority )
+				i--;
+
+			return i + 1;
+		},
+
+		/**
+		 * Executes this rules group on given value. Applicable only if function based rules were added.
+		 *
+		 * All arguments passed to this function will be forwarded to rules' functions.
+		 *
+		 * @param {CKEDITOR.htmlParser.node/CKEDITOR.htmlParser.fragment/String} currentValue The value to be filtered.
+		 * @returns {CKEDITOR.htmlParser.node/CKEDITOR.htmlParser.fragment/String} Filtered value.
+		 */
+		exec: function( context, currentValue ) {
+			var isNode = currentValue instanceof CKEDITOR.htmlParser.node || currentValue instanceof CKEDITOR.htmlParser.fragment,
+				// Splice '1' to remove context, which we don't want to pass to filter rules.
+				args = Array.prototype.slice.call( arguments, 1 ),
+				rules = this.rules,
+				len = rules.length,
+				orgType, orgName, ret, i, rule;
+
+			for ( i = 0; i < len; i++ ) {
+				// Backup the node info before filtering.
+				if ( isNode ) {
+					orgType = currentValue.type;
+					orgName = currentValue.name;
+				}
+
+				rule = rules[ i ];
+				if ( isRuleApplicable( context, rule ) ) {
+					ret = rule.value.apply( null, args );
+
+					if ( ret === false )
+						return ret;
+
+					// We're filtering node (element/fragment).
+					// No further filtering if it's not anymore fitable for the subsequent filters.
+					if ( isNode && ret && ( ret.name != orgName || ret.type != orgType ) )
+						return ret;
+
+					// Update currentValue and corresponding argument in args array.
+					// Updated values will be used in next for-loop step.
+					if ( ret != undefined )
+						args[ 0 ] = currentValue = ret;
+
+					// ret == undefined will continue loop as nothing has happened.
+				}
+			}
+
+			return currentValue;
+		},
+
+		/**
+		 * Executes this rules group on name. Applicable only if filter rules for names were added.
+		 *
+		 * @param {String} currentName The name to be filtered.
+		 * @returns {String} Filtered name.
+		 */
+		execOnName: function( context, currentName ) {
+			var i = 0,
+				rules = this.rules,
+				len = rules.length,
+				rule;
+
+			for ( ; currentName && i < len; i++ ) {
+				rule = rules[ i ];
+				if ( isRuleApplicable( context, rule ) )
+					currentName = currentName.replace( rule.value[ 0 ], rule.value[ 1 ] );
+			}
+
+			return currentName;
+		}
+	};
+
+	function addNamedRules( rulesGroups, newRules, priority, options ) {
+		var ruleName, rulesGroup;
+
+		for ( ruleName in newRules ) {
+			rulesGroup = rulesGroups[ ruleName ];
+
+			if ( !rulesGroup )
+				rulesGroup = rulesGroups[ ruleName ] = new filterRulesGroup();
+
+			rulesGroup.add( newRules[ ruleName ], priority, options );
+		}
+	}
+
+	function isRuleApplicable( context, rule ) {
+		if ( context.nonEditable && !rule.options.applyToAll )
+			return false;
+
+		if ( context.nestedEditable && rule.options.excludeNestedEditable )
+			return false;
+
+		return true;
+	}
+
+} )();
+
+/**
+ * @class CKEDITOR.htmlParser.filterRulesDefinition
+ * @abstract
+ */
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/fragment.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/fragment.js
new file mode 100644
index 00000000..ba9fd99d
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/fragment.js
@@ -0,0 +1,643 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+'use strict';
+
+/**
+ * A lightweight representation of an HTML DOM structure.
+ *
+ * @class
+ * @constructor Creates a fragment class instance.
+ */
+CKEDITOR.htmlParser.fragment = function() {
+	/**
+	 * The nodes contained in the root of this fragment.
+	 *
+	 *		var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
+	 *		alert( fragment.children.length ); // 2
+	 */
+	this.children = [];
+
+	/**
+	 * Get the fragment parent. Should always be null.
+	 *
+	 * @property {Object} [=null]
+	 */
+	this.parent = null;
+
+	/** @private */
+	this._ = {
+		isBlockLike: true,
+		hasInlineStarted: false
+	};
+};
+
+( function() {
+	// Block-level elements whose internal structure should be respected during
+	// parser fixing.
+	var nonBreakingBlocks = CKEDITOR.tools.extend( { table: 1, ul: 1, ol: 1, dl: 1 }, CKEDITOR.dtd.table, CKEDITOR.dtd.ul, CKEDITOR.dtd.ol, CKEDITOR.dtd.dl );
+
+	var listBlocks = { ol: 1, ul: 1 };
+
+	// Dtd of the fragment element, basically it accept anything except for intermediate structure, e.g. orphan <li>.
+	var rootDtd = CKEDITOR.tools.extend( {}, { html: 1 }, CKEDITOR.dtd.html, CKEDITOR.dtd.body, CKEDITOR.dtd.head, { style: 1, script: 1 } );
+
+	// Which element to create when encountered not allowed content.
+	var structureFixes = {
+		ul: 'li',
+		ol: 'li',
+		dl: 'dd',
+		table: 'tbody',
+		tbody: 'tr',
+		thead: 'tr',
+		tfoot: 'tr',
+		tr: 'td'
+	};
+
+	function isRemoveEmpty( node ) {
+		// Keep marked element event if it is empty.
+		if ( node.attributes[ 'data-cke-survive' ] )
+			return false;
+
+		// Empty link is to be removed when empty but not anchor. (#7894)
+		return node.name == 'a' && node.attributes.href || CKEDITOR.dtd.$removeEmpty[ node.name ];
+	}
+
+	/**
+	 * Creates a {@link CKEDITOR.htmlParser.fragment} from an HTML string.
+	 *
+	 *		var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
+	 *		alert( fragment.children[ 0 ].name );		// 'b'
+	 *		alert( fragment.children[ 1 ].value );	// ' Text'
+	 *
+	 * @static
+	 * @param {String} fragmentHtml The HTML to be parsed, filling the fragment.
+	 * @param {CKEDITOR.htmlParser.element/String} [parent] Optional contextual
+	 * element which makes the content been parsed as the content of this element and fix
+	 * to match it.
+	 * If not provided, then {@link CKEDITOR.htmlParser.fragment} will be used
+	 * as the parent and it will be returned.
+	 * @param {String/Boolean} [fixingBlock] When `parent` is a block limit element,
+	 * and the param is a string value other than `false`, it is to
+	 * avoid having block-less content as the direct children of parent by wrapping
+	 * the content with a block element of the specified tag, e.g.
+	 * when `fixingBlock` specified as `p`, the content `<body><i>foo</i></body>`
+	 * will be fixed into `<body><p><i>foo</i></p></body>`.
+	 * @returns {CKEDITOR.htmlParser.fragment/CKEDITOR.htmlParser.element} The created fragment or passed `parent`.
+	 */
+	CKEDITOR.htmlParser.fragment.fromHtml = function( fragmentHtml, parent, fixingBlock ) {
+		var parser = new CKEDITOR.htmlParser();
+
+		var root = parent instanceof CKEDITOR.htmlParser.element ? parent : typeof parent == 'string' ? new CKEDITOR.htmlParser.element( parent ) : new CKEDITOR.htmlParser.fragment();
+
+		var pendingInline = [],
+			pendingBRs = [],
+			currentNode = root,
+			// Indicate we're inside a <textarea> element, spaces should be touched differently.
+			inTextarea = root.name == 'textarea',
+			// Indicate we're inside a <pre> element, spaces should be touched differently.
+			inPre = root.name == 'pre';
+
+		function checkPending( newTagName ) {
+			var pendingBRsSent;
+
+			if ( pendingInline.length > 0 ) {
+				for ( var i = 0; i < pendingInline.length; i++ ) {
+					var pendingElement = pendingInline[ i ],
+						pendingName = pendingElement.name,
+						pendingDtd = CKEDITOR.dtd[ pendingName ],
+						currentDtd = currentNode.name && CKEDITOR.dtd[ currentNode.name ];
+
+					if ( ( !currentDtd || currentDtd[ pendingName ] ) && ( !newTagName || !pendingDtd || pendingDtd[ newTagName ] || !CKEDITOR.dtd[ newTagName ] ) ) {
+						if ( !pendingBRsSent ) {
+							sendPendingBRs();
+							pendingBRsSent = 1;
+						}
+
+						// Get a clone for the pending element.
+						pendingElement = pendingElement.clone();
+
+						// Add it to the current node and make it the current,
+						// so the new element will be added inside of it.
+						pendingElement.parent = currentNode;
+						currentNode = pendingElement;
+
+						// Remove the pending element (back the index by one
+						// to properly process the next entry).
+						pendingInline.splice( i, 1 );
+						i--;
+					} else {
+						// Some element of the same type cannot be nested, flat them,
+						// e.g. <a href="#">foo<a href="#">bar</a></a>. (#7894)
+						if ( pendingName == currentNode.name )
+							addElement( currentNode, currentNode.parent, 1 ), i--;
+					}
+				}
+			}
+		}
+
+		function sendPendingBRs() {
+			while ( pendingBRs.length )
+				addElement( pendingBRs.shift(), currentNode );
+		}
+
+		// Rtrim empty spaces on block end boundary. (#3585)
+		function removeTailWhitespace( element ) {
+			if ( element._.isBlockLike && element.name != 'pre' && element.name != 'textarea' ) {
+
+				var length = element.children.length,
+					lastChild = element.children[ length - 1 ],
+					text;
+				if ( lastChild && lastChild.type == CKEDITOR.NODE_TEXT ) {
+					if ( !( text = CKEDITOR.tools.rtrim( lastChild.value ) ) )
+						element.children.length = length - 1;
+					else
+						lastChild.value = text;
+				}
+			}
+		}
+
+		// Beside of simply append specified element to target, this function also takes
+		// care of other dirty lifts like forcing block in body, trimming spaces at
+		// the block boundaries etc.
+		//
+		// @param {Element} element  The element to be added as the last child of {@link target}.
+		// @param {Element} target The parent element to relieve the new node.
+		// @param {Boolean} [moveCurrent=false] Don't change the "currentNode" global unless
+		// there's a return point node specified on the element, otherwise move current onto {@link target} node.
+		//
+		function addElement( element, target, moveCurrent ) {
+			target = target || currentNode || root;
+
+			// Current element might be mangled by fix body below,
+			// save it for restore later.
+			var savedCurrent = currentNode;
+
+			// Ignore any element that has already been added.
+			if ( element.previous === undefined ) {
+				if ( checkAutoParagraphing( target, element ) ) {
+					// Create a <p> in the fragment.
+					currentNode = target;
+					parser.onTagOpen( fixingBlock, {} );
+
+					// The new target now is the <p>.
+					element.returnPoint = target = currentNode;
+				}
+
+				removeTailWhitespace( element );
+
+				// Avoid adding empty inline.
+				if ( !( isRemoveEmpty( element ) && !element.children.length ) )
+					target.add( element );
+
+				if ( element.name == 'pre' )
+					inPre = false;
+
+				if ( element.name == 'textarea' )
+					inTextarea = false;
+			}
+
+			if ( element.returnPoint ) {
+				currentNode = element.returnPoint;
+				delete element.returnPoint;
+			} else
+				currentNode = moveCurrent ? target : savedCurrent;
+		}
+
+		// Auto paragraphing should happen when inline content enters the root element.
+		function checkAutoParagraphing( parent, node ) {
+
+			// Check for parent that can contain block.
+			if ( ( parent == root || parent.name == 'body' ) && fixingBlock &&
+					 ( !parent.name || CKEDITOR.dtd[ parent.name ][ fixingBlock ] ) )
+			{
+				var name, realName;
+				if ( node.attributes && ( realName = node.attributes[ 'data-cke-real-element-type' ] ) )
+					name = realName;
+				else
+					name = node.name;
+
+				// Text node, inline elements are subjected, except for <script>/<style>.
+				return name && name in CKEDITOR.dtd.$inline &&
+				       !( name in CKEDITOR.dtd.head ) &&
+				       !node.isOrphan ||
+				       node.type == CKEDITOR.NODE_TEXT;
+			}
+		}
+
+		// Judge whether two element tag names are likely the siblings from the same
+		// structural element.
+		function possiblySibling( tag1, tag2 ) {
+
+			if ( tag1 in CKEDITOR.dtd.$listItem || tag1 in CKEDITOR.dtd.$tableContent )
+				return tag1 == tag2 || tag1 == 'dt' && tag2 == 'dd' || tag1 == 'dd' && tag2 == 'dt';
+
+			return false;
+		}
+
+		parser.onTagOpen = function( tagName, attributes, selfClosing, optionalClose ) {
+			var element = new CKEDITOR.htmlParser.element( tagName, attributes );
+
+			// "isEmpty" will be always "false" for unknown elements, so we
+			// must force it if the parser has identified it as a selfClosing tag.
+			if ( element.isUnknown && selfClosing )
+				element.isEmpty = true;
+
+			// Check for optional closed elements, including browser quirks and manually opened blocks.
+			element.isOptionalClose = optionalClose;
+
+			// This is a tag to be removed if empty, so do not add it immediately.
+			if ( isRemoveEmpty( element ) ) {
+				pendingInline.push( element );
+				return;
+			} else if ( tagName == 'pre' )
+				inPre = true;
+			else if ( tagName == 'br' && inPre ) {
+				currentNode.add( new CKEDITOR.htmlParser.text( '\n' ) );
+				return;
+			} else if ( tagName == 'textarea' )
+				inTextarea = true;
+
+			if ( tagName == 'br' ) {
+				pendingBRs.push( element );
+				return;
+			}
+
+			while ( 1 ) {
+				var currentName = currentNode.name;
+
+				var currentDtd = currentName ? ( CKEDITOR.dtd[ currentName ] || ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) ) : rootDtd;
+
+				// If the element cannot be child of the current element.
+				if ( !element.isUnknown && !currentNode.isUnknown && !currentDtd[ tagName ] ) {
+					// Current node doesn't have a close tag, time for a close
+					// as this element isn't fit in. (#7497)
+					if ( currentNode.isOptionalClose )
+						parser.onTagClose( currentName );
+					// Fixing malformed nested lists by moving it into a previous list item. (#3828)
+					else if ( tagName in listBlocks && currentName in listBlocks ) {
+						var children = currentNode.children,
+							lastChild = children[ children.length - 1 ];
+
+						// Establish the list item if it's not existed.
+						if ( !( lastChild && lastChild.name == 'li' ) )
+							addElement( ( lastChild = new CKEDITOR.htmlParser.element( 'li' ) ), currentNode );
+
+						!element.returnPoint && ( element.returnPoint = currentNode );
+						currentNode = lastChild;
+					}
+					// Establish new list root for orphan list items, but NOT to create
+					// new list for the following ones, fix them instead. (#6975)
+					// <dl><dt>foo<dd>bar</dl>
+					// <ul><li>foo<li>bar</ul>
+					else if ( tagName in CKEDITOR.dtd.$listItem &&
+							!possiblySibling( tagName, currentName ) ) {
+						parser.onTagOpen( tagName == 'li' ? 'ul' : 'dl', {}, 0, 1 );
+					}
+					// We're inside a structural block like table and list, AND the incoming element
+					// is not of the same type (e.g. <td>td1<td>td2</td>), we simply add this new one before it,
+					// and most importantly, return back to here once this element is added,
+					// e.g. <table><tr><td>td1</td><p>p1</p><td>td2</td></tr></table>
+					else if ( currentName in nonBreakingBlocks &&
+							!possiblySibling( tagName, currentName ) ) {
+						!element.returnPoint && ( element.returnPoint = currentNode );
+						currentNode = currentNode.parent;
+					} else {
+						// The current element is an inline element, which
+						// need to be continued even after the close, so put
+						// it in the pending list.
+						if ( currentName in CKEDITOR.dtd.$inline )
+							pendingInline.unshift( currentNode );
+
+						// The most common case where we just need to close the
+						// current one and append the new one to the parent.
+						if ( currentNode.parent )
+							addElement( currentNode, currentNode.parent, 1 );
+						// We've tried our best to fix the embarrassment here, while
+						// this element still doesn't find it's parent, mark it as
+						// orphan and show our tolerance to it.
+						else {
+							element.isOrphan = 1;
+							break;
+						}
+					}
+				} else
+					break;
+			}
+
+			checkPending( tagName );
+			sendPendingBRs();
+
+			element.parent = currentNode;
+
+			if ( element.isEmpty )
+				addElement( element );
+			else
+				currentNode = element;
+		};
+
+		parser.onTagClose = function( tagName ) {
+			// Check if there is any pending tag to be closed.
+			for ( var i = pendingInline.length - 1; i >= 0; i-- ) {
+				// If found, just remove it from the list.
+				if ( tagName == pendingInline[ i ].name ) {
+					pendingInline.splice( i, 1 );
+					return;
+				}
+			}
+
+			var pendingAdd = [],
+				newPendingInline = [],
+				candidate = currentNode;
+
+			while ( candidate != root && candidate.name != tagName ) {
+				// If this is an inline element, add it to the pending list, if we're
+				// really closing one of the parents element later, they will continue
+				// after it.
+				if ( !candidate._.isBlockLike )
+					newPendingInline.unshift( candidate );
+
+				// This node should be added to it's parent at this point. But,
+				// it should happen only if the closing tag is really closing
+				// one of the nodes. So, for now, we just cache it.
+				pendingAdd.push( candidate );
+
+				// Make sure return point is properly restored.
+				candidate = candidate.returnPoint || candidate.parent;
+			}
+
+			if ( candidate != root ) {
+				// Add all elements that have been found in the above loop.
+				for ( i = 0; i < pendingAdd.length; i++ ) {
+					var node = pendingAdd[ i ];
+					addElement( node, node.parent );
+				}
+
+				currentNode = candidate;
+
+				if ( candidate._.isBlockLike )
+					sendPendingBRs();
+
+				addElement( candidate, candidate.parent );
+
+				// The parent should start receiving new nodes now, except if
+				// addElement changed the currentNode.
+				if ( candidate == currentNode )
+					currentNode = currentNode.parent;
+
+				pendingInline = pendingInline.concat( newPendingInline );
+			}
+
+			if ( tagName == 'body' )
+				fixingBlock = false;
+		};
+
+		parser.onText = function( text ) {
+			// Trim empty spaces at beginning of text contents except <pre> and <textarea>.
+			if ( ( !currentNode._.hasInlineStarted || pendingBRs.length ) && !inPre && !inTextarea ) {
+				text = CKEDITOR.tools.ltrim( text );
+
+				if ( text.length === 0 )
+					return;
+			}
+
+			var currentName = currentNode.name,
+				currentDtd = currentName ? ( CKEDITOR.dtd[ currentName ] || ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) ) : rootDtd;
+
+			// Fix orphan text in list/table. (#8540) (#8870)
+			if ( !inTextarea && !currentDtd[ '#' ] && currentName in nonBreakingBlocks ) {
+				parser.onTagOpen( structureFixes[ currentName ] || '' );
+				parser.onText( text );
+				return;
+			}
+
+			sendPendingBRs();
+			checkPending();
+
+			// Shrinking consequential spaces into one single for all elements
+			// text contents.
+			if ( !inPre && !inTextarea )
+				text = text.replace( /[\t\r\n ]{2,}|[\t\r\n]/g, ' ' );
+
+			text = new CKEDITOR.htmlParser.text( text );
+
+
+			if ( checkAutoParagraphing( currentNode, text ) )
+				this.onTagOpen( fixingBlock, {}, 0, 1 );
+
+			currentNode.add( text );
+		};
+
+		parser.onCDATA = function( cdata ) {
+			currentNode.add( new CKEDITOR.htmlParser.cdata( cdata ) );
+		};
+
+		parser.onComment = function( comment ) {
+			sendPendingBRs();
+			checkPending();
+			currentNode.add( new CKEDITOR.htmlParser.comment( comment ) );
+		};
+
+		// Parse it.
+		parser.parse( fragmentHtml );
+
+		sendPendingBRs();
+
+		// Close all pending nodes, make sure return point is properly restored.
+		while ( currentNode != root )
+			addElement( currentNode, currentNode.parent, 1 );
+
+		removeTailWhitespace( root );
+
+		return root;
+	};
+
+	CKEDITOR.htmlParser.fragment.prototype = {
+
+		/**
+		 * The node type. This is a constant value set to {@link CKEDITOR#NODE_DOCUMENT_FRAGMENT}.
+		 *
+		 * @readonly
+		 * @property {Number} [=CKEDITOR.NODE_DOCUMENT_FRAGMENT]
+		 */
+		type: CKEDITOR.NODE_DOCUMENT_FRAGMENT,
+
+		/**
+		 * Adds a node to this fragment.
+		 *
+		 * @param {CKEDITOR.htmlParser.node} node The node to be added.
+		 * @param {Number} [index] From where the insertion happens.
+		 */
+		add: function( node, index ) {
+			isNaN( index ) && ( index = this.children.length );
+
+			var previous = index > 0 ? this.children[ index - 1 ] : null;
+			if ( previous ) {
+				// If the block to be appended is following text, trim spaces at
+				// the right of it.
+				if ( node._.isBlockLike && previous.type == CKEDITOR.NODE_TEXT ) {
+					previous.value = CKEDITOR.tools.rtrim( previous.value );
+
+					// If we have completely cleared the previous node.
+					if ( previous.value.length === 0 ) {
+						// Remove it from the list and add the node again.
+						this.children.pop();
+						this.add( node );
+						return;
+					}
+				}
+
+				previous.next = node;
+			}
+
+			node.previous = previous;
+			node.parent = this;
+
+			this.children.splice( index, 0, node );
+
+			if ( !this._.hasInlineStarted )
+				this._.hasInlineStarted = node.type == CKEDITOR.NODE_TEXT || ( node.type == CKEDITOR.NODE_ELEMENT && !node._.isBlockLike );
+		},
+
+		/**
+		 * Filter this fragment's content with given filter.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.filter} filter
+		 */
+		filter: function( filter, context ) {
+			context = this.getFilterContext( context );
+
+			// Apply the root filter.
+			filter.onRoot( context, this );
+
+			this.filterChildren( filter, false, context );
+		},
+
+		/**
+		 * Filter this fragment's children with given filter.
+		 *
+		 * Element's children may only be filtered once by one
+		 * instance of filter.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.filter} filter
+		 * @param {Boolean} [filterRoot] Whether to apply the "root" filter rule specified in the `filter`.
+		 */
+		filterChildren: function( filter, filterRoot, context ) {
+			// If this element's children were already filtered
+			// by current filter, don't filter them 2nd time.
+			// This situation may occur when filtering bottom-up
+			// (filterChildren() called manually in element's filter),
+			// or in unpredictable edge cases when filter
+			// is manipulating DOM structure.
+			if ( this.childrenFilteredBy == filter.id )
+				return;
+
+			context = this.getFilterContext( context );
+
+			// Filtering root if enforced.
+			if ( filterRoot && !this.parent )
+				filter.onRoot( context, this );
+
+			this.childrenFilteredBy = filter.id;
+
+			// Don't cache anything, children array may be modified by filter rule.
+			for ( var i = 0; i < this.children.length; i++ ) {
+				// Stay in place if filter returned false, what means
+				// that node has been removed.
+				if ( this.children[ i ].filter( filter, context ) === false )
+					i--;
+			}
+		},
+
+		/**
+		 * Writes the fragment HTML to a {@link CKEDITOR.htmlParser.basicWriter}.
+		 *
+		 *		var writer = new CKEDITOR.htmlWriter();
+		 *		var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<P><B>Example' );
+		 *		fragment.writeHtml( writer );
+		 *		alert( writer.getHtml() ); // '<p><b>Example</b></p>'
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 * @param {CKEDITOR.htmlParser.filter} [filter] The filter to use when writing the HTML.
+		 */
+		writeHtml: function( writer, filter ) {
+			if ( filter )
+				this.filter( filter );
+
+			this.writeChildrenHtml( writer );
+		},
+
+		/**
+		 * Write and filtering the child nodes of this fragment.
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 * @param {CKEDITOR.htmlParser.filter} [filter] The filter to use when writing the HTML.
+		 * @param {Boolean} [filterRoot] Whether to apply the "root" filter rule specified in the `filter`.
+		 */
+		writeChildrenHtml: function( writer, filter, filterRoot ) {
+			var context = this.getFilterContext();
+
+			// Filtering root if enforced.
+			if ( filterRoot && !this.parent && filter )
+				filter.onRoot( context, this );
+
+			if ( filter )
+				this.filterChildren( filter, false, context );
+
+			for ( var i = 0, children = this.children, l = children.length; i < l; i++ )
+				children[ i ].writeHtml( writer );
+		},
+
+		/**
+		 * Execute callback on each node (of given type) in this document fragment.
+		 *
+		 *		var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<p>foo<b>bar</b>bom</p>' );
+		 *		fragment.forEach( function( node ) {
+		 *			console.log( node );
+		 *		} );
+		 *		// Will log:
+		 *		// 1. document fragment,
+		 *		// 2. <p> element,
+		 *		// 3. "foo" text node,
+		 *		// 4. <b> element,
+		 *		// 5. "bar" text node,
+		 *		// 6. "bom" text node.
+		 *
+		 * @since 4.1
+		 * @param {Function} callback Function to be executed on every node.
+		 * **Since 4.3** if `callback` returned `false` descendants of current node will be ignored.
+		 * @param {CKEDITOR.htmlParser.node} callback.node Node passed as argument.
+		 * @param {Number} [type] If specified `callback` will be executed only on nodes of this type.
+		 * @param {Boolean} [skipRoot] Don't execute `callback` on this fragment.
+		 */
+		forEach: function( callback, type, skipRoot ) {
+			if ( !skipRoot && ( !type || this.type == type ) )
+				var ret = callback( this );
+
+			// Do not filter children if callback returned false.
+			if ( ret === false )
+				return;
+
+			var children = this.children,
+				node,
+				i = 0;
+
+			// We do not cache the size, because the list of nodes may be changed by the callback.
+			for ( ; i < children.length; i++ ) {
+				node = children[ i ];
+				if ( node.type == CKEDITOR.NODE_ELEMENT )
+					node.forEach( callback, type );
+				else if ( !type || node.type == type )
+					callback( node );
+			}
+		},
+
+		getFilterContext: function( context ) {
+			return context || {};
+		}
+	};
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/node.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/node.js
new file mode 100644
index 00000000..cdb5dfbd
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/node.js
@@ -0,0 +1,150 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+'use strict';
+
+( function() {
+	/**
+	 * A lightweight representation of HTML node.
+	 *
+	 * @since 4.1
+	 * @class
+	 * @constructor Creates a node class instance.
+	 */
+	CKEDITOR.htmlParser.node = function() {};
+
+	CKEDITOR.htmlParser.node.prototype = {
+		/**
+		 * Remove this node from a tree.
+		 *
+		 * @since 4.1
+		 */
+		remove: function() {
+			var children = this.parent.children,
+				index = CKEDITOR.tools.indexOf( children, this ),
+				previous = this.previous,
+				next = this.next;
+
+			previous && ( previous.next = next );
+			next && ( next.previous = previous );
+			children.splice( index, 1 );
+			this.parent = null;
+		},
+
+		/**
+		 * Replace this node with given one.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.node} node The node that will replace this one.
+		 */
+		replaceWith: function( node ) {
+			var children = this.parent.children,
+				index = CKEDITOR.tools.indexOf( children, this ),
+				previous = node.previous = this.previous,
+				next = node.next = this.next;
+
+			previous && ( previous.next = node );
+			next && ( next.previous = node );
+
+			children[ index ] = node;
+
+			node.parent = this.parent;
+			this.parent = null;
+		},
+
+		/**
+		 * Insert this node after given one.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.node} node The node that will precede this element.
+		 */
+		insertAfter: function( node ) {
+			var children = node.parent.children,
+				index = CKEDITOR.tools.indexOf( children, node ),
+				next = node.next;
+
+			children.splice( index + 1, 0, this );
+
+			this.next = node.next;
+			this.previous = node;
+			node.next = this;
+			next && ( next.previous = this );
+
+			this.parent = node.parent;
+		},
+
+		/**
+		 * Insert this node before given one.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.node} node The node that will follow this element.
+		 */
+		insertBefore: function( node ) {
+			var children = node.parent.children,
+				index = CKEDITOR.tools.indexOf( children, node );
+
+			children.splice( index, 0, this );
+
+			this.next = node;
+			this.previous = node.previous;
+			node.previous && ( node.previous.next = this );
+			node.previous = this;
+
+			this.parent = node.parent;
+		},
+
+		/**
+		 * Gets the closest ancestor element of this element which satisfies given condition
+		 *
+		 * @since 4.3
+		 * @param {String/Object/Function} condition Name of an ancestor, hash of names or validator function.
+		 * @returns {CKEDITOR.htmlParser.element} The closest ancestor which satisfies given condition or `null`.
+		 */
+		getAscendant: function( condition ) {
+			var checkFn =
+				typeof condition == 'function' ?	condition :
+				typeof condition == 'string' ?		function( el ) { return el.name == condition; } :
+													function( el ) { return el.name in condition; };
+
+			var parent = this.parent;
+
+			// Parent has to be an element - don't check doc fragment.
+			while ( parent && parent.type == CKEDITOR.NODE_ELEMENT ) {
+				if ( checkFn( parent ) )
+					return parent;
+				parent = parent.parent;
+			}
+
+			return null;
+		},
+
+		/**
+		 * Wraps this element with given `wrapper`.
+		 *
+		 * @since 4.3
+		 * @param {CKEDITOR.htmlParser.element} wrapper The element which will be this element's new parent.
+		 * @returns {CKEDITOR.htmlParser.element} Wrapper.
+		 */
+		wrapWith: function( wrapper ) {
+			this.replaceWith( wrapper );
+			wrapper.add( this );
+			return wrapper;
+		},
+
+		/**
+		 * Gets this node's index in its parent's children array.
+		 *
+		 * @since 4.3
+		 * @returns {Number}
+		 */
+		getIndex: function() {
+			return CKEDITOR.tools.indexOf( this.parent.children, this );
+		},
+
+		getFilterContext: function( context ) {
+			return context || {};
+		}
+	};
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/core/htmlparser/text.js b/lam/templates/lib/extra/ckeditor/core/htmlparser/text.js
new file mode 100644
index 00000000..cf817285
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/core/htmlparser/text.js
@@ -0,0 +1,70 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+ 'use strict';
+
+( function() {
+	/**
+	 * A lightweight representation of HTML text.
+	 *
+	 * @class
+	 * @extends CKEDITOR.htmlParser.node
+	 * @constructor Creates a text class instance.
+	 * @param {String} value The text node value.
+	 */
+	CKEDITOR.htmlParser.text = function( value ) {
+		/**
+		 * The text value.
+		 *
+		 * @property {String}
+		 */
+		this.value = value;
+
+		/** @private */
+		this._ = {
+			isBlockLike: false
+		};
+	};
+
+	CKEDITOR.htmlParser.text.prototype = CKEDITOR.tools.extend( new CKEDITOR.htmlParser.node(), {
+		/**
+		 * The node type. This is a constant value set to {@link CKEDITOR#NODE_TEXT}.
+		 *
+		 * @readonly
+		 * @property {Number} [=CKEDITOR.NODE_TEXT]
+		 */
+		type: CKEDITOR.NODE_TEXT,
+
+		/**
+		 * Filter this text node with given filter.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.htmlParser.filter} filter
+		 * @returns {Boolean} Method returns `false` when this text node has
+		 * been removed. This is an information for {@link CKEDITOR.htmlParser.element#filterChildren}
+		 * that it has to repeat filter on current position in parent's children array.
+		 */
+		filter: function( filter, context ) {
+			if ( !( this.value = filter.onText( context, this.value, this ) ) ) {
+				this.remove();
+				return false;
+			}
+		},
+
+		/**
+		 * Writes the HTML representation of this text to a {CKEDITOR.htmlParser.basicWriter}.
+		 *
+		 * @param {CKEDITOR.htmlParser.basicWriter} writer The writer to which write the HTML.
+		 * @param {CKEDITOR.htmlParser.filter} [filter] The filter to be applied to this node.
+		 * **Note:** it's unsafe to filter offline (not appended) node.
+		 */
+		writeHtml: function( writer, filter ) {
+			if ( filter )
+				this.filter( filter );
+
+			writer.text( this.value );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/basicstyles/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/basicstyles/plugin.js
new file mode 100644
index 00000000..a275c087
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/basicstyles/plugin.js
@@ -0,0 +1,189 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'basicstyles', {
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	icons: 'bold,italic,underline,strike,subscript,superscript', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		var order = 0;
+		// All buttons use the same code to register. So, to avoid
+		// duplications, let's use this tool function.
+		var addButtonCommand = function( buttonName, buttonLabel, commandName, styleDefiniton ) {
+				// Disable the command if no definition is configured.
+				if ( !styleDefiniton )
+					return;
+
+				var style = new CKEDITOR.style( styleDefiniton ),
+					forms = contentForms[ commandName ];
+
+				// Put the style as the most important form.
+				forms.unshift( style );
+
+				// Listen to contextual style activation.
+				editor.attachStyleStateChange( style, function( state ) {
+					!editor.readOnly && editor.getCommand( commandName ).setState( state );
+				} );
+
+				// Create the command that can be used to apply the style.
+				editor.addCommand( commandName, new CKEDITOR.styleCommand( style, {
+					contentForms: forms
+				} ) );
+
+				// Register the button, if the button plugin is loaded.
+				if ( editor.ui.addButton ) {
+					editor.ui.addButton( buttonName, {
+						label: buttonLabel,
+						command: commandName,
+						toolbar: 'basicstyles,' + ( order += 10 )
+					} );
+				}
+			};
+
+		var contentForms = {
+				bold: [
+					'strong',
+					'b',
+					[ 'span', function( el ) {
+						var fw = el.styles[ 'font-weight' ];
+						return fw == 'bold' || +fw >= 700;
+					} ]
+				],
+
+				italic: [
+					'em',
+					'i',
+					[ 'span', function( el ) {
+						return el.styles[ 'font-style' ] == 'italic';
+					} ]
+				],
+
+				underline: [
+					'u',
+					[ 'span', function( el ) {
+						return el.styles[ 'text-decoration' ] == 'underline';
+					} ]
+				],
+
+				strike: [
+					's',
+					'strike',
+					[ 'span', function( el ) {
+						return el.styles[ 'text-decoration' ] == 'line-through';
+					} ]
+				],
+
+				subscript: [
+					'sub'
+				],
+
+				superscript: [
+					'sup'
+				]
+			},
+			config = editor.config,
+			lang = editor.lang.basicstyles;
+
+		addButtonCommand( 'Bold', lang.bold, 'bold', config.coreStyles_bold );
+		addButtonCommand( 'Italic', lang.italic, 'italic', config.coreStyles_italic );
+		addButtonCommand( 'Underline', lang.underline, 'underline', config.coreStyles_underline );
+		addButtonCommand( 'Strike', lang.strike, 'strike', config.coreStyles_strike );
+		addButtonCommand( 'Subscript', lang.subscript, 'subscript', config.coreStyles_subscript );
+		addButtonCommand( 'Superscript', lang.superscript, 'superscript', config.coreStyles_superscript );
+
+		editor.setKeystroke( [
+			[ CKEDITOR.CTRL + 66 /*B*/, 'bold' ],
+			[ CKEDITOR.CTRL + 73 /*I*/, 'italic' ],
+			[ CKEDITOR.CTRL + 85 /*U*/, 'underline' ]
+			] );
+	}
+} );
+
+// Basic Inline Styles.
+
+/**
+ * The style definition that applies the **bold** style to the text.
+ *
+ *		config.coreStyles_bold = { element: 'b', overrides: 'strong' };
+ *
+ *		config.coreStyles_bold = {
+ *			element: 'span',
+ *			attributes: { 'class': 'Bold' }
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_bold = { element: 'strong', overrides: 'b' };
+
+/**
+ * The style definition that applies the *italics* style to the text.
+ *
+ *		config.coreStyles_italic = { element: 'i', overrides: 'em' };
+ *
+ *		CKEDITOR.config.coreStyles_italic = {
+ *			element: 'span',
+ *			attributes: { 'class': 'Italic' }
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_italic = { element: 'em', overrides: 'i' };
+
+/**
+ * The style definition that applies the <u>underline</u> style to the text.
+ *
+ *		CKEDITOR.config.coreStyles_underline = {
+ *			element: 'span',
+ *			attributes: { 'class': 'Underline' }
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_underline = { element: 'u' };
+
+/**
+ * The style definition that applies the <strike>strike-through</strike> style to the text.
+ *
+ *		CKEDITOR.config.coreStyles_strike = {
+ *			element: 'span',
+ *			attributes: { 'class': 'StrikeThrough' },
+ *			overrides: 'strike'
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_strike = { element: 's', overrides: 'strike' };
+
+/**
+ * The style definition that applies the subscript style to the text.
+ *
+ *		CKEDITOR.config.coreStyles_subscript = {
+ *			element: 'span',
+ *			attributes: { 'class': 'Subscript' },
+ *			overrides: 'sub'
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_subscript = { element: 'sub' };
+
+/**
+ * The style definition that applies the superscript style to the text.
+ *
+ *		CKEDITOR.config.coreStyles_superscript = {
+ *			element: 'span',
+ *			attributes: { 'class': 'Superscript' },
+ *			overrides: 'sup'
+ *		};
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.coreStyles_superscript = { element: 'sup' };
diff --git a/lam/templates/lib/extra/ckeditor/plugins/blockquote/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/blockquote/plugin.js
new file mode 100644
index 00000000..83b2873d
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/blockquote/plugin.js
@@ -0,0 +1,248 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	function noBlockLeft( bqBlock ) {
+		for ( var i = 0, length = bqBlock.getChildCount(), child; i < length && ( child = bqBlock.getChild( i ) ); i++ ) {
+			if ( child.type == CKEDITOR.NODE_ELEMENT && child.isBlockBoundary() )
+				return false;
+		}
+		return true;
+	}
+
+	var commandObject = {
+		exec: function( editor ) {
+			var state = editor.getCommand( 'blockquote' ).state,
+				selection = editor.getSelection(),
+				range = selection && selection.getRanges()[ 0 ];
+
+			if ( !range )
+				return;
+
+			var bookmarks = selection.createBookmarks();
+
+			// Kludge for #1592: if the bookmark nodes are in the beginning of
+			// blockquote, then move them to the nearest block element in the
+			// blockquote.
+			if ( CKEDITOR.env.ie ) {
+				var bookmarkStart = bookmarks[ 0 ].startNode,
+					bookmarkEnd = bookmarks[ 0 ].endNode,
+					cursor;
+
+				if ( bookmarkStart && bookmarkStart.getParent().getName() == 'blockquote' ) {
+					cursor = bookmarkStart;
+					while ( ( cursor = cursor.getNext() ) ) {
+						if ( cursor.type == CKEDITOR.NODE_ELEMENT && cursor.isBlockBoundary() ) {
+							bookmarkStart.move( cursor, true );
+							break;
+						}
+					}
+				}
+
+				if ( bookmarkEnd && bookmarkEnd.getParent().getName() == 'blockquote' ) {
+					cursor = bookmarkEnd;
+					while ( ( cursor = cursor.getPrevious() ) ) {
+						if ( cursor.type == CKEDITOR.NODE_ELEMENT && cursor.isBlockBoundary() ) {
+							bookmarkEnd.move( cursor );
+							break;
+						}
+					}
+				}
+			}
+
+			var iterator = range.createIterator(),
+				block;
+			iterator.enlargeBr = editor.config.enterMode != CKEDITOR.ENTER_BR;
+
+			if ( state == CKEDITOR.TRISTATE_OFF ) {
+				var paragraphs = [];
+				while ( ( block = iterator.getNextParagraph() ) )
+					paragraphs.push( block );
+
+				// If no paragraphs, create one from the current selection position.
+				if ( paragraphs.length < 1 ) {
+					var para = editor.document.createElement( editor.config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ),
+						firstBookmark = bookmarks.shift();
+					range.insertNode( para );
+					para.append( new CKEDITOR.dom.text( '\ufeff', editor.document ) );
+					range.moveToBookmark( firstBookmark );
+					range.selectNodeContents( para );
+					range.collapse( true );
+					firstBookmark = range.createBookmark();
+					paragraphs.push( para );
+					bookmarks.unshift( firstBookmark );
+				}
+
+				// Make sure all paragraphs have the same parent.
+				var commonParent = paragraphs[ 0 ].getParent(),
+					tmp = [];
+				for ( var i = 0; i < paragraphs.length; i++ ) {
+					block = paragraphs[ i ];
+					commonParent = commonParent.getCommonAncestor( block.getParent() );
+				}
+
+				// The common parent must not be the following tags: table, tbody, tr, ol, ul.
+				var denyTags = { table: 1, tbody: 1, tr: 1, ol: 1, ul: 1 };
+				while ( denyTags[ commonParent.getName() ] )
+					commonParent = commonParent.getParent();
+
+				// Reconstruct the block list to be processed such that all resulting blocks
+				// satisfy parentNode.equals( commonParent ).
+				var lastBlock = null;
+				while ( paragraphs.length > 0 ) {
+					block = paragraphs.shift();
+					while ( !block.getParent().equals( commonParent ) )
+						block = block.getParent();
+					if ( !block.equals( lastBlock ) )
+						tmp.push( block );
+					lastBlock = block;
+				}
+
+				// If any of the selected blocks is a blockquote, remove it to prevent
+				// nested blockquotes.
+				while ( tmp.length > 0 ) {
+					block = tmp.shift();
+					if ( block.getName() == 'blockquote' ) {
+						var docFrag = new CKEDITOR.dom.documentFragment( editor.document );
+						while ( block.getFirst() ) {
+							docFrag.append( block.getFirst().remove() );
+							paragraphs.push( docFrag.getLast() );
+						}
+
+						docFrag.replace( block );
+					} else
+						paragraphs.push( block );
+				}
+
+				// Now we have all the blocks to be included in a new blockquote node.
+				var bqBlock = editor.document.createElement( 'blockquote' );
+				bqBlock.insertBefore( paragraphs[ 0 ] );
+				while ( paragraphs.length > 0 ) {
+					block = paragraphs.shift();
+					bqBlock.append( block );
+				}
+			} else if ( state == CKEDITOR.TRISTATE_ON ) {
+				var moveOutNodes = [],
+					database = {};
+
+				while ( ( block = iterator.getNextParagraph() ) ) {
+					var bqParent = null,
+						bqChild = null;
+					while ( block.getParent() ) {
+						if ( block.getParent().getName() == 'blockquote' ) {
+							bqParent = block.getParent();
+							bqChild = block;
+							break;
+						}
+						block = block.getParent();
+					}
+
+					// Remember the blocks that were recorded down in the moveOutNodes array
+					// to prevent duplicates.
+					if ( bqParent && bqChild && !bqChild.getCustomData( 'blockquote_moveout' ) ) {
+						moveOutNodes.push( bqChild );
+						CKEDITOR.dom.element.setMarker( database, bqChild, 'blockquote_moveout', true );
+					}
+				}
+
+				CKEDITOR.dom.element.clearAllMarkers( database );
+
+				var movedNodes = [],
+					processedBlockquoteBlocks = [];
+
+				database = {};
+				while ( moveOutNodes.length > 0 ) {
+					var node = moveOutNodes.shift();
+					bqBlock = node.getParent();
+
+					// If the node is located at the beginning or the end, just take it out
+					// without splitting. Otherwise, split the blockquote node and move the
+					// paragraph in between the two blockquote nodes.
+					if ( !node.getPrevious() )
+						node.remove().insertBefore( bqBlock );
+					else if ( !node.getNext() )
+						node.remove().insertAfter( bqBlock );
+					else {
+						node.breakParent( node.getParent() );
+						processedBlockquoteBlocks.push( node.getNext() );
+					}
+
+					// Remember the blockquote node so we can clear it later (if it becomes empty).
+					if ( !bqBlock.getCustomData( 'blockquote_processed' ) ) {
+						processedBlockquoteBlocks.push( bqBlock );
+						CKEDITOR.dom.element.setMarker( database, bqBlock, 'blockquote_processed', true );
+					}
+
+					movedNodes.push( node );
+				}
+
+				CKEDITOR.dom.element.clearAllMarkers( database );
+
+				// Clear blockquote nodes that have become empty.
+				for ( i = processedBlockquoteBlocks.length - 1; i >= 0; i-- ) {
+					bqBlock = processedBlockquoteBlocks[ i ];
+					if ( noBlockLeft( bqBlock ) )
+						bqBlock.remove();
+				}
+
+				if ( editor.config.enterMode == CKEDITOR.ENTER_BR ) {
+					var firstTime = true;
+					while ( movedNodes.length ) {
+						node = movedNodes.shift();
+
+						if ( node.getName() == 'div' ) {
+							docFrag = new CKEDITOR.dom.documentFragment( editor.document );
+							var needBeginBr = firstTime && node.getPrevious() && !( node.getPrevious().type == CKEDITOR.NODE_ELEMENT && node.getPrevious().isBlockBoundary() );
+							if ( needBeginBr )
+								docFrag.append( editor.document.createElement( 'br' ) );
+
+							var needEndBr = node.getNext() && !( node.getNext().type == CKEDITOR.NODE_ELEMENT && node.getNext().isBlockBoundary() );
+							while ( node.getFirst() )
+								node.getFirst().remove().appendTo( docFrag );
+
+							if ( needEndBr )
+								docFrag.append( editor.document.createElement( 'br' ) );
+
+							docFrag.replace( node );
+							firstTime = false;
+						}
+					}
+				}
+			}
+
+			selection.selectBookmarks( bookmarks );
+			editor.focus();
+		},
+
+		refresh: function( editor, path ) {
+			// Check if inside of blockquote.
+			var firstBlock = path.block || path.blockLimit;
+			this.setState( editor.elementPath( firstBlock ).contains( 'blockquote', 1 ) ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+		},
+
+		context: 'blockquote',
+
+		allowedContent: 'blockquote',
+		requiredContent: 'blockquote'
+	};
+
+	CKEDITOR.plugins.add( 'blockquote', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'blockquote', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			if ( editor.blockless )
+				return;
+
+			editor.addCommand( 'blockquote', commandObject );
+
+			editor.ui.addButton && editor.ui.addButton( 'Blockquote', {
+				label: editor.lang.blockquote.toolbar,
+				command: 'blockquote',
+				toolbar: 'blocks,10'
+			} );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/button/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/button/plugin.js
new file mode 100644
index 00000000..5a9c67f6
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/button/plugin.js
@@ -0,0 +1,379 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	var template = '<a id="{id}"' +
+		' class="cke_button cke_button__{name} cke_button_{state} {cls}"' +
+		( CKEDITOR.env.gecko && CKEDITOR.env.version >= 10900 && !CKEDITOR.env.hc ? '' : ' href="javascript:void(\'{titleJs}\')"' ) +
+		' title="{title}"' +
+		' tabindex="-1"' +
+		' hidefocus="true"' +
+		' role="button"' +
+		' aria-labelledby="{id}_label"' +
+		' aria-haspopup="{hasArrow}"' +
+		' aria-disabled="{ariaDisabled}"';
+
+	// Some browsers don't cancel key events in the keydown but in the
+	// keypress.
+	// TODO: Check if really needed for Gecko+Mac.
+	if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+		template += ' onkeypress="return false;"';
+
+	// With Firefox, we need to force the button to redraw, otherwise it
+	// will remain in the focus state.
+	if ( CKEDITOR.env.gecko )
+		template += ' onblur="this.style.cssText = this.style.cssText;"';
+
+	template += ' onkeydown="return CKEDITOR.tools.callFunction({keydownFn},event);"' +
+		' onfocus="return CKEDITOR.tools.callFunction({focusFn},event);" ' +
+		' onmousedown="return CKEDITOR.tools.callFunction({mousedownFn},event);" ' +
+		( CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick' ) + // #188
+			'="CKEDITOR.tools.callFunction({clickFn},this);return false;">' +
+		'<span class="cke_button_icon cke_button__{iconName}_icon" style="{style}"';
+
+
+	template += '>&nbsp;</span>' +
+		'<span id="{id}_label" class="cke_button_label cke_button__{name}_label" aria-hidden="false">{label}</span>' +
+		'{arrowHtml}' +
+		'</a>';
+
+	var templateArrow = '<span class="cke_button_arrow">' +
+		// BLACK DOWN-POINTING TRIANGLE
+	( CKEDITOR.env.hc ? '&#9660;' : '' ) +
+		'</span>';
+
+	var btnArrowTpl = CKEDITOR.addTemplate( 'buttonArrow', templateArrow ),
+		btnTpl = CKEDITOR.addTemplate( 'button', template );
+
+	CKEDITOR.plugins.add( 'button', {
+		lang: 'ca,cs,el,en,en-gb,fa,fr,gl,hu,ja,km,nl,pl,pt,pt-br,ru,sl,sv,uk,zh-cn', // %REMOVE_LINE_CORE%
+		beforeInit: function( editor ) {
+			editor.ui.addHandler( CKEDITOR.UI_BUTTON, CKEDITOR.ui.button.handler );
+		}
+	} );
+
+	/**
+	 * Button UI element.
+	 *
+	 * @readonly
+	 * @property {String} [='button']
+	 * @member CKEDITOR
+	 */
+	CKEDITOR.UI_BUTTON = 'button';
+
+	/**
+	 * Represents a button UI element. This class should not be called directly. To
+	 * create new buttons use {@link CKEDITOR.ui#addButton} instead.
+	 *
+	 * @class
+	 * @constructor Creates a button class instance.
+	 * @param {Object} definition The button definition.
+	 */
+	CKEDITOR.ui.button = function( definition ) {
+		CKEDITOR.tools.extend( this, definition,
+		// Set defaults.
+		{
+			title: definition.label,
+			click: definition.click ||
+			function( editor ) {
+				editor.execCommand( definition.command );
+			}
+		} );
+
+		this._ = {};
+	};
+
+	/**
+	 * Represents button handler object.
+	 *
+	 * @class
+	 * @singleton
+	 * @extends CKEDITOR.ui.handlerDefinition
+	 */
+	CKEDITOR.ui.button.handler = {
+		/**
+		 * Transforms a button definition in a {@link CKEDITOR.ui.button} instance.
+		 *
+		 * @member CKEDITOR.ui.button.handler
+		 * @param {Object} definition
+		 * @returns {CKEDITOR.ui.button}
+		 */
+		create: function( definition ) {
+			return new CKEDITOR.ui.button( definition );
+		}
+	};
+
+	/** @class CKEDITOR.ui.button */
+	CKEDITOR.ui.button.prototype = {
+		/**
+		 * Renders the button.
+		 *
+		 * @param {CKEDITOR.editor} editor The editor instance which this button is
+		 * to be used by.
+		 * @param {Array} output The output array to which append the HTML relative
+		 * to this button.
+		 */
+		render: function( editor, output ) {
+			var env = CKEDITOR.env,
+				id = this._.id = CKEDITOR.tools.getNextId(),
+				stateName = '',
+				command = this.command,
+				// Get the command name.
+				clickFn;
+
+			this._.editor = editor;
+
+			var instance = {
+				id: id,
+				button: this,
+				editor: editor,
+				focus: function() {
+					var element = CKEDITOR.document.getById( id );
+					element.focus();
+				},
+				execute: function() {
+					this.button.click( editor );
+				},
+				attach: function( editor ) {
+					this.button.attach( editor );
+				}
+			};
+
+			var keydownFn = CKEDITOR.tools.addFunction( function( ev ) {
+				if ( instance.onkey ) {
+					ev = new CKEDITOR.dom.event( ev );
+					return ( instance.onkey( instance, ev.getKeystroke() ) !== false );
+				}
+			} );
+
+			var focusFn = CKEDITOR.tools.addFunction( function( ev ) {
+				var retVal;
+
+				if ( instance.onfocus )
+					retVal = ( instance.onfocus( instance, new CKEDITOR.dom.event( ev ) ) !== false );
+
+				// FF2: prevent focus event been bubbled up to editor container, which caused unexpected editor focus.
+				if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
+					ev.preventBubble();
+				return retVal;
+			} );
+
+			var selLocked = 0;
+
+			var mousedownFn = CKEDITOR.tools.addFunction( function() {
+				// Opera: lock to prevent loosing editable text selection when clicking on button.
+				if ( CKEDITOR.env.opera ) {
+					var edt = editor.editable();
+					if ( edt.isInline() && edt.hasFocus ) {
+						editor.lockSelection();
+						selLocked = 1;
+					}
+				}
+			} );
+
+			instance.clickFn = clickFn = CKEDITOR.tools.addFunction( function() {
+
+				// Restore locked selection in Opera.
+				if ( selLocked ) {
+					editor.unlockSelection( 1 );
+					selLocked = 0;
+				}
+
+				instance.execute();
+			} );
+
+
+			// Indicate a mode sensitive button.
+			if ( this.modes ) {
+				var modeStates = {};
+
+				function updateState() {
+					// "this" is a CKEDITOR.ui.button instance.
+
+					var mode = editor.mode;
+
+					if ( mode ) {
+						// Restore saved button state.
+						var state = this.modes[ mode ] ? modeStates[ mode ] != undefined ? modeStates[ mode ] : CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
+
+						state = editor.readOnly && !this.readOnly ? CKEDITOR.TRISTATE_DISABLED : state;
+
+						this.setState( state );
+
+						// Let plugin to disable button.
+						if ( this.refresh )
+							this.refresh();
+					}
+				}
+
+				editor.on( 'beforeModeUnload', function() {
+					if ( editor.mode && this._.state != CKEDITOR.TRISTATE_DISABLED )
+						modeStates[ editor.mode ] = this._.state;
+				}, this );
+
+				// Update status when activeFilter, mode or readOnly changes.
+				editor.on( 'activeFilterChange', updateState, this );
+				editor.on( 'mode', updateState, this );
+				// If this button is sensitive to readOnly state, update it accordingly.
+				!this.readOnly && editor.on( 'readOnly', updateState, this );
+
+			} else if ( command ) {
+				// Get the command instance.
+				command = editor.getCommand( command );
+
+				if ( command ) {
+					command.on( 'state', function() {
+						this.setState( command.state );
+					}, this );
+
+					stateName += ( command.state == CKEDITOR.TRISTATE_ON ? 'on' : command.state == CKEDITOR.TRISTATE_DISABLED ? 'disabled' : 'off' );
+				}
+			}
+
+			// For button that has text-direction awareness on selection path.
+			if ( this.directional ) {
+				editor.on( 'contentDirChanged', function( evt ) {
+					var el = CKEDITOR.document.getById( this._.id ),
+						icon = el.getFirst();
+
+					var pathDir = evt.data;
+
+					// Make a minor direction change to become style-able for the skin icon.
+					if ( pathDir !=  editor.lang.dir )
+						el.addClass( 'cke_' + pathDir );
+					else
+						el.removeClass( 'cke_ltr' ).removeClass( 'cke_rtl' );
+
+					// Inline style update for the plugin icon.
+					icon.setAttribute( 'style', CKEDITOR.skin.getIconStyle( iconName, pathDir == 'rtl', this.icon, this.iconOffset ) );
+				}, this );
+			}
+
+			if ( !command )
+				stateName += 'off';
+
+			var name = this.name || this.command,
+				iconName = name;
+
+			// Check if we're pointing to an icon defined by another command. (#9555)
+			if ( this.icon && !( /\./ ).test( this.icon ) ) {
+				iconName = this.icon;
+				this.icon = null;
+			}
+
+			var params = {
+				id: id,
+				name: name,
+				iconName: iconName,
+				label: this.label,
+				cls: this.className || '',
+				state: stateName,
+				ariaDisabled: stateName == 'disabled' ? 'true' : 'false',
+				title: this.title,
+				titleJs: env.gecko && env.version >= 10900 && !env.hc ? '' : ( this.title || '' ).replace( "'", '' ),
+				hasArrow: this.hasArrow ? 'true' : 'false',
+				keydownFn: keydownFn,
+				mousedownFn: mousedownFn,
+				focusFn: focusFn,
+				clickFn: clickFn,
+				style: CKEDITOR.skin.getIconStyle( iconName, ( editor.lang.dir == 'rtl' ), this.icon, this.iconOffset ),
+				arrowHtml: this.hasArrow ? btnArrowTpl.output() : ''
+			};
+
+			btnTpl.output( params, output );
+
+			if ( this.onRender )
+				this.onRender();
+
+			return instance;
+		},
+
+		/**
+		 * @todo
+		 */
+		setState: function( state ) {
+			if ( this._.state == state )
+				return false;
+
+			this._.state = state;
+
+			var element = CKEDITOR.document.getById( this._.id );
+
+			if ( element ) {
+				element.setState( state, 'cke_button' );
+
+				state == CKEDITOR.TRISTATE_DISABLED ?
+					element.setAttribute( 'aria-disabled', true ) :
+					element.removeAttribute( 'aria-disabled' );
+
+				if ( !this.hasArrow ) {
+					// Note: aria-pressed attribute should not be added to menuButton instances. (#11331)
+					state == CKEDITOR.TRISTATE_ON ?
+						element.setAttribute( 'aria-pressed', true ) :
+						element.removeAttribute( 'aria-pressed' );
+				} else {
+					var newLabel = state == CKEDITOR.TRISTATE_ON ?
+						this._.editor.lang.button.selectedLabel.replace( /%1/g, this.label ) : this.label;
+					CKEDITOR.document.getById( this._.id + '_label' ).setText( newLabel );
+				}
+
+				return true;
+			} else
+				return false;
+		},
+
+		/**
+		 * @todo
+		 */
+		getState: function( state ) {
+			return this._.state;
+		},
+
+		/**
+		 * Returns this button's {@link CKEDITOR.feature} instance.
+		 *
+		 * It may be this button instance if it has at least one of
+		 * `allowedContent` and `requiredContent` properties. Otherwise,
+		 * if command is bound to this button by `command` property, then
+		 * that command will be returned.
+		 *
+		 * This method implements {@link CKEDITOR.feature#toFeature} interface method.
+		 *
+		 * @since 4.1
+		 * @param {CKEDITOR.editor} Editor instance.
+		 * @returns {CKEDITOR.feature} The feature.
+		 */
+		toFeature: function( editor ) {
+			if ( this._.feature )
+				return this._.feature;
+
+			var feature = this;
+
+			// If button isn't a feature, return command if is bound.
+			if ( !this.allowedContent && !this.requiredContent && this.command )
+				feature = editor.getCommand( this.command ) || feature;
+
+			return this._.feature = feature;
+		}
+	};
+
+	/**
+	 * Adds a button definition to the UI elements list.
+	 *
+	 *		editorInstance.ui.addButton( 'MyBold', {
+	 *			label: 'My Bold',
+	 *			command: 'bold',
+	 *			toolbar: 'basicstyles,1'
+	 *		} );
+	 *
+	 * @member CKEDITOR.ui
+	 * @param {String} name The button name.
+	 * @param {Object} definition The button definition.
+	 */
+	CKEDITOR.ui.prototype.addButton = function( name, definition ) {
+		this.add( name, CKEDITOR.UI_BUTTON, definition );
+	};
+
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/clipboard/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/clipboard/plugin.js
new file mode 100644
index 00000000..3118e3ac
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/clipboard/plugin.js
@@ -0,0 +1,1229 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @ignore
+ * File overview: Clipboard support.
+ */
+
+//
+// EXECUTION FLOWS:
+// -- CTRL+C
+//		* browser's default behaviour
+// -- CTRL+V
+//		* listen onKey (onkeydown)
+//		* simulate 'beforepaste' for non-IEs on editable
+//		* simulate 'paste' for Fx2/Opera on editable
+//		* listen 'onpaste' on editable ('onbeforepaste' for IE)
+//		* fire 'beforePaste' on editor
+//		* !canceled && getClipboardDataByPastebin
+//		* fire 'paste' on editor
+//		* !canceled && fire 'afterPaste' on editor
+// -- CTRL+X
+//		* listen onKey (onkeydown)
+//		* fire 'saveSnapshot' on editor
+//		* browser's default behaviour
+//		* deferred second 'saveSnapshot' event
+// -- Copy command
+//		* tryToCutCopy
+//			* execCommand
+//		* !success && alert
+// -- Cut command
+//		* fixCut
+//		* tryToCutCopy
+//			* execCommand
+//		* !success && alert
+// -- Paste command
+//		* fire 'paste' on editable ('beforepaste' for IE)
+//		* !canceled && execCommand 'paste'
+//		* !success && fire 'pasteDialog' on editor
+// -- Paste from native context menu & menubar
+//		(Fx & Webkits are handled in 'paste' default listner.
+//		Opera cannot be handled at all because it doesn't fire any events
+//		Special treatment is needed for IE, for which is this part of doc)
+//		* listen 'onpaste'
+//		* cancel native event
+//		* fire 'beforePaste' on editor
+//		* !canceled && getClipboardDataByPastebin
+//		* execIECommand( 'paste' ) -> this fires another 'paste' event, so cancel it
+//		* fire 'paste' on editor
+//		* !canceled && fire 'afterPaste' on editor
+//
+//
+// PASTE EVENT - PREPROCESSING:
+// -- Possible dataValue types: auto, text, html.
+// -- Possible dataValue contents:
+//		* text (possible \n\r)
+//		* htmlified text (text + br,div,p - no presentional markup & attrs - depends on browser)
+//		* html
+// -- Possible flags:
+//		* htmlified - if true then content is a HTML even if no markup inside. This flag is set
+//			for content from editable pastebins, because they 'htmlify' pasted content.
+//
+// -- Type: auto:
+//		* content: htmlified text ->	filter, unify text markup (brs, ps, divs), set type: text
+//		* content: html ->				filter, set type: html
+// -- Type: text:
+//		* content: htmlified text ->	filter, unify text markup
+//		* content: html ->				filter, strip presentional markup, unify text markup
+// -- Type: html:
+//		* content: htmlified text ->	filter, unify text markup
+//		* content: html ->				filter
+//
+// -- Phases:
+//		* filtering (priorities 3-5) - e.g. pastefromword filters
+//		* content type sniffing (priority 6)
+//		* markup transformations for text (priority 6)
+//
+
+'use strict';
+
+( function() {
+	// Register the plugin.
+	CKEDITOR.plugins.add( 'clipboard', {
+		requires: 'dialog',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'copy,copy-rtl,cut,cut-rtl,paste,paste-rtl', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			var textificationFilter;
+
+			initClipboard( editor );
+
+			CKEDITOR.dialog.add( 'paste', CKEDITOR.getUrl( this.path + 'dialogs/paste.js' ) );
+
+			editor.on( 'paste', function( evt ) {
+				var data = evt.data.dataValue,
+					blockElements = CKEDITOR.dtd.$block;
+
+				// Filter webkit garbage.
+				if ( data.indexOf( 'Apple-' ) > -1 ) {
+					// Replace special webkit's &nbsp; with simple space, because webkit
+					// produces them even for normal spaces.
+					data = data.replace( /<span class="Apple-converted-space">&nbsp;<\/span>/gi, ' ' );
+
+					// Strip <span> around white-spaces when not in forced 'html' content type.
+					// This spans are created only when pasting plain text into Webkit,
+					// but for safety reasons remove them always.
+					if ( evt.data.type != 'html' )
+						data = data.replace( /<span class="Apple-tab-span"[^>]*>([^<]*)<\/span>/gi, function( all, spaces ) {
+						// Replace tabs with 4 spaces like Fx does.
+						return spaces.replace( /\t/g, '&nbsp;&nbsp; &nbsp;' );
+					} );
+
+					// This br is produced only when copying & pasting HTML content.
+					if ( data.indexOf( '<br class="Apple-interchange-newline">' ) > -1 ) {
+						evt.data.startsWithEOL = 1;
+						evt.data.preSniffing = 'html'; // Mark as not text.
+						data = data.replace( /<br class="Apple-interchange-newline">/, '' );
+					}
+
+					// Remove all other classes.
+					data = data.replace( /(<[^>]+) class="Apple-[^"]*"/gi, '$1' );
+				}
+
+				// Strip editable that was copied from inside. (#9534)
+				if ( data.match( /^<[^<]+cke_(editable|contents)/i ) ) {
+					var tmp,
+						editable_wrapper,
+						wrapper = new CKEDITOR.dom.element( 'div' );
+
+					wrapper.setHtml( data );
+					// Verify for sure and check for nested editor UI parts. (#9675)
+					while ( wrapper.getChildCount() == 1 &&
+							( tmp = wrapper.getFirst() ) &&
+							tmp.type == CKEDITOR.NODE_ELEMENT &&	// Make sure first-child is element.
+							( tmp.hasClass( 'cke_editable' ) || tmp.hasClass( 'cke_contents' ) ) ) {
+						wrapper = editable_wrapper = tmp;
+					}
+
+					// If editable wrapper was found strip it and bogus <br> (added on FF).
+					if ( editable_wrapper )
+						data = editable_wrapper.getHtml().replace( /<br>$/i, '' );
+				}
+
+				if ( CKEDITOR.env.ie ) {
+					// &nbsp; <p> -> <p> (br.cke-pasted-remove will be removed later)
+					data = data.replace( /^&nbsp;(?: |\r\n)?<(\w+)/g, function( match, elementName ) {
+						if ( elementName.toLowerCase() in blockElements ) {
+							evt.data.preSniffing = 'html'; // Mark as not a text.
+							return '<' + elementName;
+						}
+						return match;
+					} );
+				} else if ( CKEDITOR.env.webkit ) {
+					// </p><div><br></div> -> </p><br>
+					// We don't mark br, because this situation can happen for htmlified text too.
+					data = data.replace( /<\/(\w+)><div><br><\/div>$/, function( match, elementName ) {
+						if ( elementName in blockElements ) {
+							evt.data.endsWithEOL = 1;
+							return '</' + elementName + '>';
+						}
+						return match;
+					} );
+				} else if ( CKEDITOR.env.gecko ) {
+					// Firefox adds bogus <br> when user pasted text followed by space(s).
+					data = data.replace( /(\s)<br>$/, '$1' );
+				}
+
+				evt.data.dataValue = data;
+			}, null, null, 3 );
+
+			editor.on( 'paste', function( evt ) {
+				var dataObj = evt.data,
+					type = dataObj.type,
+					data = dataObj.dataValue,
+					trueType,
+					// Default is 'html'.
+					defaultType = editor.config.clipboard_defaultContentType || 'html';
+
+				// If forced type is 'html' we don't need to know true data type.
+				if ( type == 'html' || dataObj.preSniffing == 'html' )
+					trueType = 'html';
+				else
+					trueType = recogniseContentType( data );
+
+				// Unify text markup.
+				if ( trueType == 'htmlifiedtext' )
+					data = htmlifiedTextHtmlification( editor.config, data );
+				// Strip presentional markup & unify text markup.
+				else if ( type == 'text' && trueType == 'html' ) {
+					// Init filter only if needed and cache it.
+					data = htmlTextification( editor.config, data, textificationFilter || ( textificationFilter = getTextificationFilter( editor ) ) );
+				}
+
+				if ( dataObj.startsWithEOL )
+					data = '<br data-cke-eol="1">' + data;
+				if ( dataObj.endsWithEOL )
+					data += '<br data-cke-eol="1">';
+
+				if ( type == 'auto' )
+					type = ( trueType == 'html' || defaultType == 'html' ) ? 'html' : 'text';
+
+				dataObj.type = type;
+				dataObj.dataValue = data;
+				delete dataObj.preSniffing;
+				delete dataObj.startsWithEOL;
+				delete dataObj.endsWithEOL;
+			}, null, null, 6 );
+
+			// Inserts processed data into the editor at the end of the
+			// events chain.
+			editor.on( 'paste', function( evt ) {
+				var data = evt.data;
+
+				editor.insertHtml( data.dataValue, data.type );
+
+				// Deferr 'afterPaste' so all other listeners for 'paste' will be fired first.
+				setTimeout( function() {
+					editor.fire( 'afterPaste' );
+				}, 0 );
+			}, null, null, 1000 );
+
+			editor.on( 'pasteDialog', function( evt ) {
+				// TODO it's possible that this setTimeout is not needed any more,
+				// because of changes introduced in the same commit as this comment.
+				// Editor.getClipboardData adds listner to the dialog's events which are
+				// fired after a while (not like 'showDialog').
+				setTimeout( function() {
+					// Open default paste dialog.
+					editor.openDialog( 'paste', evt.data );
+				}, 0 );
+			} );
+		}
+	} );
+
+	function initClipboard( editor ) {
+		var preventBeforePasteEvent = 0,
+			preventPasteEvent = 0,
+			inReadOnly = 0,
+			// Safari doesn't like 'beforepaste' event - it sometimes doesn't
+			// properly handles ctrl+c. Probably some race-condition between events.
+			// Chrome and Firefox works well with both events, so better to use 'paste'
+			// which will handle pasting from e.g. browsers' menu bars.
+			// IE7/8 doesn't like 'paste' event for which it's throwing random errors.
+			mainPasteEvent = CKEDITOR.env.ie ? 'beforepaste' : 'paste';
+
+		addListeners();
+		addButtonsCommands();
+
+		/**
+		 * Gets clipboard data by directly accessing the clipboard (IE only) or opening paste dialog.
+		 *
+		 *		editor.getClipboardData( { title: 'Get my data' }, function( data ) {
+		 *			if ( data )
+		 *				alert( data.type + ' ' + data.dataValue );
+		 *		} );
+		 *
+		 * @member CKEDITOR.editor
+		 * @param {Object} options
+		 * @param {String} [options.title] Title of paste dialog.
+		 * @param {Function} callback Function that will be executed with `data.type` and `data.dataValue`
+		 * or `null` if none of the capturing method succeeded.
+		 */
+		editor.getClipboardData = function( options, callback ) {
+			var beforePasteNotCanceled = false,
+				dataType = 'auto',
+				dialogCommited = false;
+
+			// Options are optional - args shift.
+			if ( !callback ) {
+				callback = options;
+				options = null;
+			}
+
+			// Listen with maximum priority to handle content before everyone else.
+			// This callback will handle paste event that will be fired if direct
+			// access to the clipboard succeed in IE.
+			editor.on( 'paste', onPaste, null, null, 0 );
+
+			// Listen at the end of listeners chain to see if event wasn't canceled
+			// and to retrieve modified data.type.
+			editor.on( 'beforePaste', onBeforePaste, null, null, 1000 );
+
+			// getClipboardDataDirectly() will fire 'beforePaste' synchronously, so we can
+			// check if it was canceled and if any listener modified data.type.
+
+			// If command didn't succeed (only IE allows to access clipboard and only if
+			// user agrees) open and handle paste dialog.
+			if ( getClipboardDataDirectly() === false ) {
+				// Direct access to the clipboard wasn't successful so remove listener.
+				editor.removeListener( 'paste', onPaste );
+
+				// If beforePaste was canceled do not open dialog.
+				// Add listeners only if dialog really opened. 'pasteDialog' can be canceled.
+				if ( beforePasteNotCanceled && editor.fire( 'pasteDialog', onDialogOpen ) ) {
+					editor.on( 'pasteDialogCommit', onDialogCommit );
+
+					// 'dialogHide' will be fired after 'pasteDialogCommit'.
+					editor.on( 'dialogHide', function( evt ) {
+						evt.removeListener();
+						evt.data.removeListener( 'pasteDialogCommit', onDialogCommit );
+
+						// Because Opera has to wait a while in pasteDialog we have to wait here.
+						setTimeout( function() {
+							// Notify even if user canceled dialog (clicked 'cancel', ESC, etc).
+							if ( !dialogCommited )
+								callback( null );
+						}, 10 );
+					} );
+				} else
+					callback( null );
+			}
+
+			function onPaste( evt ) {
+				evt.removeListener();
+				evt.cancel();
+				callback( evt.data );
+			}
+
+			function onBeforePaste( evt ) {
+				evt.removeListener();
+				beforePasteNotCanceled = true;
+				dataType = evt.data.type;
+			}
+
+			function onDialogCommit( evt ) {
+				evt.removeListener();
+				// Cancel pasteDialogCommit so paste dialog won't automatically fire
+				// 'paste' evt by itself.
+				evt.cancel();
+				dialogCommited = true;
+				callback( { type: dataType, dataValue: evt.data } );
+			}
+
+			function onDialogOpen() {
+				this.customTitle = ( options && options.title );
+			}
+		};
+
+		function addButtonsCommands() {
+			addButtonCommand( 'Cut', 'cut', createCutCopyCmd( 'cut' ), 10, 1 );
+			addButtonCommand( 'Copy', 'copy', createCutCopyCmd( 'copy' ), 20, 4 );
+			addButtonCommand( 'Paste', 'paste', createPasteCmd(), 30, 8 );
+
+			function addButtonCommand( buttonName, commandName, command, toolbarOrder, ctxMenuOrder ) {
+				var lang = editor.lang.clipboard[ commandName ];
+
+				editor.addCommand( commandName, command );
+				editor.ui.addButton && editor.ui.addButton( buttonName, {
+					label: lang,
+					command: commandName,
+					toolbar: 'clipboard,' + toolbarOrder
+				} );
+
+				// If the "menu" plugin is loaded, register the menu item.
+				if ( editor.addMenuItems ) {
+					editor.addMenuItem( commandName, {
+						label: lang,
+						command: commandName,
+						group: 'clipboard',
+						order: ctxMenuOrder
+					} );
+				}
+			}
+		}
+
+		function addListeners() {
+			editor.on( 'key', onKey );
+			editor.on( 'contentDom', addListenersToEditable );
+
+			// For improved performance, we're checking the readOnly state on selectionChange instead of hooking a key event for that.
+			editor.on( 'selectionChange', function( evt ) {
+				inReadOnly = evt.data.selection.getRanges()[ 0 ].checkReadOnly();
+				setToolbarStates();
+			} );
+
+			// If the "contextmenu" plugin is loaded, register the listeners.
+			if ( editor.contextMenu ) {
+				editor.contextMenu.addListener( function( element, selection ) {
+					inReadOnly = selection.getRanges()[ 0 ].checkReadOnly();
+					return {
+						cut: stateFromNamedCommand( 'cut' ),
+						copy: stateFromNamedCommand( 'copy' ),
+						paste: stateFromNamedCommand( 'paste' )
+					};
+				} );
+			}
+		}
+
+		// Add events listeners to editable.
+		function addListenersToEditable() {
+			var editable = editor.editable();
+
+			// We'll be catching all pasted content in one line, regardless of whether
+			// it's introduced by a document command execution (e.g. toolbar buttons) or
+			// user paste behaviors (e.g. CTRL+V).
+			editable.on( mainPasteEvent, function( evt ) {
+				if ( CKEDITOR.env.ie && preventBeforePasteEvent )
+					return;
+
+				// If you've just asked yourself why preventPasteEventNow() is not here, but
+				// in listener for CTRL+V and exec method of 'paste' command
+				// you've asked the same question we did.
+				//
+				// THE ANSWER:
+				//
+				// First thing to notice - this answer makes sense only for IE,
+				// because other browsers don't listen for 'paste' event.
+				//
+				// What would happen if we move preventPasteEventNow() here?
+				// For:
+				// * CTRL+V - IE fires 'beforepaste', so we prevent 'paste' and pasteDataFromClipboard(). OK.
+				// * editor.execCommand( 'paste' ) - we fire 'beforepaste', so we prevent
+				//		'paste' and pasteDataFromClipboard() and doc.execCommand( 'Paste' ). OK.
+				// * native context menu - IE fires 'beforepaste', so we prevent 'paste', but unfortunately
+				//		on IE we fail with pasteDataFromClipboard() here, because of... we don't know why, but
+				//		we just fail, so... we paste nothing. FAIL.
+				// * native menu bar - the same as for native context menu.
+				//
+				// But don't you know any way to distinguish first two cases from last two?
+				// Only one - special flag set in CTRL+V handler and exec method of 'paste'
+				// command. And that's what we did using preventPasteEventNow().
+
+				pasteDataFromClipboard( evt );
+			} );
+
+			// It's not possible to clearly handle all four paste methods (ctrl+v, native menu bar
+			// native context menu, editor's command) in one 'paste/beforepaste' event in IE.
+			//
+			// For ctrl+v & editor's command it's easy to handle pasting in 'beforepaste' listener,
+			// so we do this. For another two methods it's better to use 'paste' event.
+			//
+			// 'paste' is always being fired after 'beforepaste' (except of weird one on opening native
+			// context menu), so for two methods handled in 'beforepaste' we're canceling 'paste'
+			// using preventPasteEvent state.
+			//
+			// 'paste' event in IE is being fired before getClipboardDataByPastebin executes its callback.
+			//
+			// QUESTION: Why didn't you handle all 4 paste methods in handler for 'paste'?
+			//		Wouldn't this just be simpler?
+			// ANSWER: Then we would have to evt.data.preventDefault() only for native
+			//		context menu and menu bar pastes. The same with execIECommand().
+			//		That would force us to mark CTRL+V and editor's paste command with
+			//		special flag, other than preventPasteEvent. But we still would have to
+			//		have preventPasteEvent for the second event fired by execIECommand.
+			//		Code would be longer and not cleaner.
+			CKEDITOR.env.ie && editable.on( 'paste', function( evt ) {
+				if ( preventPasteEvent )
+					return;
+				// Cancel next 'paste' event fired by execIECommand( 'paste' )
+				// at the end of this callback.
+				preventPasteEventNow();
+
+				// Prevent native paste.
+				evt.data.preventDefault();
+
+				pasteDataFromClipboard( evt );
+
+				// Force IE to paste content into pastebin so pasteDataFromClipboard will work.
+				if ( !execIECommand( 'paste' ) )
+					editor.openDialog( 'paste' );
+			} );
+
+			// [IE] Dismiss the (wrong) 'beforepaste' event fired on context/toolbar menu open. (#7953)
+			if ( CKEDITOR.env.ie ) {
+				editable.on( 'contextmenu', preventBeforePasteEventNow, null, null, 0 );
+
+				editable.on( 'beforepaste', function( evt ) {
+					if ( evt.data && !evt.data.$.ctrlKey )
+						preventBeforePasteEventNow();
+				}, null, null, 0 );
+
+			}
+
+			editable.on( 'beforecut', function() {
+				!preventBeforePasteEvent && fixCut( editor );
+			} );
+
+			var mouseupTimeout;
+
+			// Use editor.document instead of editable in non-IEs for observing mouseup
+			// since editable won't fire the event if selection process started within
+			// iframe and ended out of the editor (#9851).
+			editable.attachListener( CKEDITOR.env.ie ? editable : editor.document.getDocumentElement(), 'mouseup', function() {
+				mouseupTimeout = setTimeout( function() {
+					setToolbarStates();
+				}, 0 );
+			} );
+
+			// Make sure that deferred mouseup callback isn't executed after editor instance
+			// had been destroyed. This may happen when editor.destroy() is called in parallel
+			// with mouseup event (i.e. a button with onclick callback) (#10219).
+			editor.on( 'destroy', function() {
+				clearTimeout( mouseupTimeout );
+			} );
+
+			editable.on( 'keyup', setToolbarStates );
+		}
+
+		// Create object representing Cut or Copy commands.
+		function createCutCopyCmd( type ) {
+			return {
+				type: type,
+				canUndo: type == 'cut', // We can't undo copy to clipboard.
+				startDisabled: true,
+				exec: function( data ) {
+					// Attempts to execute the Cut and Copy operations.
+					function tryToCutCopy( type ) {
+						if ( CKEDITOR.env.ie )
+							return execIECommand( type );
+
+						// non-IEs part
+						try {
+							// Other browsers throw an error if the command is disabled.
+							return editor.document.$.execCommand( type, false, null );
+						} catch ( e ) {
+							return false;
+						}
+					}
+
+					this.type == 'cut' && fixCut();
+
+					var success = tryToCutCopy( this.type );
+
+					if ( !success )
+						alert( editor.lang.clipboard[ this.type + 'Error' ] ); // Show cutError or copyError.
+
+					return success;
+				}
+			};
+		}
+
+		function createPasteCmd() {
+			return {
+				// Snapshots are done manually by editable.insertXXX methods.
+				canUndo: false,
+				async: true,
+
+				exec: function( editor, data ) {
+					var fire = function( data, withBeforePaste ) {
+							data && firePasteEvents( data.type, data.dataValue, !!withBeforePaste );
+
+							editor.fire( 'afterCommandExec', {
+								name: 'paste',
+								command: cmd,
+								returnValue: !!data
+							} );
+						},
+						cmd = this;
+
+					// Check data precisely - don't open dialog on empty string.
+					if ( typeof data == 'string' )
+						fire( { type: 'auto', dataValue: data }, 1 );
+					else
+						editor.getClipboardData( fire );
+				}
+			};
+		}
+
+		function preventPasteEventNow() {
+			preventPasteEvent = 1;
+			// For safety reason we should wait longer than 0/1ms.
+			// We don't know how long execution of quite complex getClipboardData will take
+			// and in for example 'paste' listner execCommand() (which fires 'paste') is called
+			// after getClipboardData finishes.
+			// Luckily, it's impossible to immediately fire another 'paste' event we want to handle,
+			// because we only handle there native context menu and menu bar.
+			setTimeout( function() {
+				preventPasteEvent = 0;
+			}, 100 );
+		}
+
+		function preventBeforePasteEventNow() {
+			preventBeforePasteEvent = 1;
+			setTimeout( function() {
+				preventBeforePasteEvent = 0;
+			}, 10 );
+		}
+
+		// Tries to execute any of the paste, cut or copy commands in IE. Returns a
+		// boolean indicating that the operation succeeded.
+		// @param {String} command *LOWER CASED* name of command ('paste', 'cut', 'copy').
+		function execIECommand( command ) {
+			var doc = editor.document,
+				body = doc.getBody(),
+				enabled = false,
+				onExec = function() {
+					enabled = true;
+				};
+
+			// The following seems to be the only reliable way to detect that
+			// clipboard commands are enabled in IE. It will fire the
+			// onpaste/oncut/oncopy events only if the security settings allowed
+			// the command to execute.
+			body.on( command, onExec );
+
+			// IE6/7: document.execCommand has problem to paste into positioned element.
+			( CKEDITOR.env.version > 7 ? doc.$ : doc.$.selection.createRange() )[ 'execCommand' ]( command );
+
+			body.removeListener( command, onExec );
+
+			return enabled;
+		}
+
+		function firePasteEvents( type, data, withBeforePaste ) {
+			var eventData = { type: type };
+
+			if ( withBeforePaste ) {
+				// Fire 'beforePaste' event so clipboard flavor get customized
+				// by other plugins.
+				if ( editor.fire( 'beforePaste', eventData ) === false )
+					return false; // Event canceled
+			}
+
+			// The very last guard to make sure the paste has successfully happened.
+			// This check should be done after firing 'beforePaste' because for native paste
+			// 'beforePaste' is by default fired even for empty clipboard.
+			if ( !data )
+				return false;
+
+			// Reuse eventData.type because the default one could be changed by beforePaste listeners.
+			eventData.dataValue = data;
+
+			return editor.fire( 'paste', eventData );
+		}
+
+		// Cutting off control type element in IE standards breaks the selection entirely. (#4881)
+		function fixCut() {
+			if ( !CKEDITOR.env.ie || CKEDITOR.env.quirks )
+				return;
+
+			var sel = editor.getSelection(),
+				control, range, dummy;
+
+			if ( ( sel.getType() == CKEDITOR.SELECTION_ELEMENT ) && ( control = sel.getSelectedElement() ) ) {
+				range = sel.getRanges()[ 0 ];
+				dummy = editor.document.createText( '' );
+				dummy.insertBefore( control );
+				range.setStartBefore( dummy );
+				range.setEndAfter( control );
+				sel.selectRanges( [ range ] );
+
+				// Clear up the fix if the paste wasn't succeeded.
+				setTimeout( function() {
+					// Element still online?
+					if ( control.getParent() ) {
+						dummy.remove();
+						sel.selectElement( control );
+					}
+				}, 0 );
+			}
+		}
+
+		// Allow to peek clipboard content by redirecting the
+		// pasting content into a temporary bin and grab the content of it.
+		function getClipboardDataByPastebin( evt, callback ) {
+			var doc = editor.document,
+				editable = editor.editable(),
+				cancel = function( evt ) {
+					evt.cancel();
+				},
+				ff3x = CKEDITOR.env.gecko && CKEDITOR.env.version <= 10902,
+				blurListener;
+
+			// Avoid recursions on 'paste' event or consequent paste too fast. (#5730)
+			if ( doc.getById( 'cke_pastebin' ) )
+				return;
+
+			var sel = editor.getSelection();
+			var bms = sel.createBookmarks();
+
+			// Create container to paste into.
+			// For rich content we prefer to use "body" since it holds
+			// the least possibility to be splitted by pasted content, while this may
+			// breaks the text selection on a frame-less editable, "div" would be
+			// the best one in that case.
+			// In another case on old IEs moving the selection into a "body" paste bin causes error panic.
+			// Body can't be also used for Opera which fills it with <br>
+			// what is indistinguishable from pasted <br> (copying <br> in Opera isn't possible,
+			// but it can be copied from other browser).
+			var pastebin = new CKEDITOR.dom.element(
+				( CKEDITOR.env.webkit || editable.is( 'body' ) ) && !( CKEDITOR.env.ie || CKEDITOR.env.opera ) ? 'body' : 'div', doc );
+
+			pastebin.setAttributes( {
+				id: 'cke_pastebin',
+				'data-cke-temp': '1'
+			} );
+
+			// Append bogus to prevent Opera from doing this. (#9522)
+			if ( CKEDITOR.env.opera )
+				pastebin.appendBogus();
+
+			var containerOffset = 0,
+				offsetParent,
+				win = doc.getWindow();
+
+			// Seems to be the only way to avoid page scroll in Fx 3.x.
+			if ( ff3x ) {
+				pastebin.insertAfter( bms[ 0 ].startNode );
+				pastebin.setStyle( 'display', 'inline' );
+			} else {
+				if ( CKEDITOR.env.webkit ) {
+					// It's better to paste close to the real paste destination, so inherited styles
+					// (which Webkits will try to compensate by styling span) differs less from the destination's one.
+					editable.append( pastebin );
+					// Style pastebin like .cke_editable, to minimize differences between origin and destination. (#9754)
+					pastebin.addClass( 'cke_editable' );
+
+					// Compensate position of offsetParent.
+					if ( !editable.is( 'body' ) ) {
+						// We're not able to get offsetParent from pastebin (body element), so check whether
+						// its parent (editable) is positioned.
+						if ( editable.getComputedStyle( 'position' ) != 'static' )
+							offsetParent = editable;
+						// And if not - safely get offsetParent from editable.
+						else
+							offsetParent = CKEDITOR.dom.element.get( editable.$.offsetParent );
+
+						containerOffset = offsetParent.getDocumentPosition().y;
+					}
+				} else {
+					// Opera and IE doesn't allow to append to html element.
+					editable.getAscendant( CKEDITOR.env.ie || CKEDITOR.env.opera ? 'body' : 'html', 1 ).append( pastebin );
+				}
+
+				pastebin.setStyles( {
+					position: 'absolute',
+					// Position the bin at the top (+10 for safety) of viewport to avoid any subsequent document scroll.
+					top: ( win.getScrollPosition().y - containerOffset + 10 ) + 'px',
+					width: '1px',
+					// Caret has to fit in that height, otherwise browsers like Chrome & Opera will scroll window to show it.
+					// Set height equal to viewport's height - 20px (safety gaps), minimum 1px.
+					height: Math.max( 1, win.getViewPaneSize().height - 20 ) + 'px',
+					overflow: 'hidden',
+					// Reset styles that can mess up pastebin position.
+					margin: 0,
+					padding: 0
+				} );
+			}
+
+			// Check if the paste bin now establishes new editing host.
+			var isEditingHost = pastebin.getParent().isReadOnly();
+
+			if ( isEditingHost ) {
+				// Hide the paste bin.
+				pastebin.setOpacity( 0 );
+				// And make it editable.
+				pastebin.setAttribute( 'contenteditable', true );
+			}
+			// Transparency is not enough since positioned non-editing host always shows
+			// resize handler, pull it off the screen instead.
+			else
+				pastebin.setStyle( editor.config.contentsLangDirection == 'ltr' ? 'left' : 'right', '-1000px' );
+
+			editor.on( 'selectionChange', cancel, null, null, 0 );
+
+			// Webkit fill fire blur on editable when moving selection to
+			// pastebin (if body is used). Cancel it because it causes incorrect
+			// selection lock in case of inline editor (#10644).
+			// The same seems to apply to Firefox (#10787).
+			if ( CKEDITOR.env.webkit || CKEDITOR.env.gecko )
+				blurListener = editable.once( 'blur', cancel, null, null, -100 );
+
+			// Temporarily move selection to the pastebin.
+			isEditingHost && pastebin.focus();
+			var range = new CKEDITOR.dom.range( pastebin );
+			range.selectNodeContents( pastebin );
+			var selPastebin = range.select();
+
+			// If non-native paste is executed, IE will open security alert and blur editable.
+			// Editable will then lock selection inside itself and after accepting security alert
+			// this selection will be restored. We overwrite stored selection, so it's restored
+			// in pastebin. (#9552)
+			if ( CKEDITOR.env.ie ) {
+				blurListener = editable.once( 'blur', function( evt ) {
+					editor.lockSelection( selPastebin );
+				} );
+			}
+
+			var scrollTop = CKEDITOR.document.getWindow().getScrollPosition().y;
+
+			// Wait a while and grab the pasted contents.
+			setTimeout( function() {
+				// Restore main window's scroll position which could have been changed
+				// by browser in cases described in #9771.
+				if ( CKEDITOR.env.webkit || CKEDITOR.env.opera )
+					CKEDITOR.document[ CKEDITOR.env.webkit ? 'getBody' : 'getDocumentElement' ]().$.scrollTop = scrollTop;
+
+				// Blur will be fired only on non-native paste. In other case manually remove listener.
+				blurListener && blurListener.removeListener();
+
+				// Restore properly the document focus. (#8849)
+				if ( CKEDITOR.env.ie )
+					editable.focus();
+
+				// IE7: selection must go before removing pastebin. (#8691)
+				sel.selectBookmarks( bms );
+				pastebin.remove();
+
+				// Grab the HTML contents.
+				// We need to look for a apple style wrapper on webkit it also adds
+				// a div wrapper if you copy/paste the body of the editor.
+				// Remove hidden div and restore selection.
+				var bogusSpan;
+				if ( CKEDITOR.env.webkit && ( bogusSpan = pastebin.getFirst() ) && ( bogusSpan.is && bogusSpan.hasClass( 'Apple-style-span' ) ) )
+					pastebin = bogusSpan;
+
+				editor.removeListener( 'selectionChange', cancel );
+				callback( pastebin.getHtml() );
+			}, 0 );
+		}
+
+		// Try to get content directly from clipboard, without native event
+		// being fired before. In other words - synthetically get clipboard data
+		// if it's possible.
+		// mainPasteEvent will be fired, so if forced native paste:
+		// * worked, getClipboardDataByPastebin will grab it,
+		// * didn't work, pastebin will be empty and editor#paste won't be fired.
+		function getClipboardDataDirectly() {
+			if ( CKEDITOR.env.ie ) {
+				// Prevent IE from pasting at the begining of the document.
+				editor.focus();
+
+				// Command will be handled by 'beforepaste', but as
+				// execIECommand( 'paste' ) will fire also 'paste' event
+				// we're canceling it.
+				preventPasteEventNow();
+
+				// #9247: Lock focus to prevent IE from hiding toolbar for inline editor.
+				var focusManager = editor.focusManager;
+				focusManager.lock();
+
+				if ( editor.editable().fire( mainPasteEvent ) && !execIECommand( 'paste' ) ) {
+					focusManager.unlock();
+					return false;
+				}
+				focusManager.unlock();
+			} else {
+				try {
+					if ( editor.editable().fire( mainPasteEvent ) && !editor.document.$.execCommand( 'Paste', false, null ) )
+						throw 0;
+
+				} catch ( e ) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		// Listens for some clipboard related keystrokes, so they get customized.
+		// Needs to be bind to keydown event.
+		function onKey( event ) {
+			if ( editor.mode != 'wysiwyg' )
+				return;
+
+			switch ( event.data.keyCode ) {
+				// Paste
+				case CKEDITOR.CTRL + 86: // CTRL+V
+				case CKEDITOR.SHIFT + 45: // SHIFT+INS
+					var editable = editor.editable();
+
+					// Cancel 'paste' event because ctrl+v is for IE handled
+					// by 'beforepaste'.
+					preventPasteEventNow();
+
+					// Simulate 'beforepaste' event for all none-IEs.
+					!CKEDITOR.env.ie && editable.fire( 'beforepaste' );
+
+					// Simulate 'paste' event for Opera/Firefox2.
+					if ( CKEDITOR.env.opera || CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
+						editable.fire( 'paste' );
+					return;
+
+					// Cut
+				case CKEDITOR.CTRL + 88: // CTRL+X
+				case CKEDITOR.SHIFT + 46: // SHIFT+DEL
+					// Save Undo snapshot.
+					editor.fire( 'saveSnapshot' ); // Save before cut
+					setTimeout( function() {
+						editor.fire( 'saveSnapshot' ); // Save after cut
+					}, 50 ); // OSX is slow (#11416).
+			}
+		}
+
+		function pasteDataFromClipboard( evt ) {
+			// Default type is 'auto', but can be changed by beforePaste listeners.
+			var eventData = { type: 'auto' };
+			// Fire 'beforePaste' event so clipboard flavor get customized by other plugins.
+			// If 'beforePaste' is canceled continue executing getClipboardDataByPastebin and then do nothing
+			// (do not fire 'paste', 'afterPaste' events). This way we can grab all - synthetically
+			// and natively pasted content and prevent its insertion into editor
+			// after canceling 'beforePaste' event.
+			var beforePasteNotCanceled = editor.fire( 'beforePaste', eventData );
+
+			getClipboardDataByPastebin( evt, function( data ) {
+				// Clean up.
+				data = data.replace( /<span[^>]+data-cke-bookmark[^<]*?<\/span>/ig, '' );
+
+				// Fire remaining events (without beforePaste)
+				beforePasteNotCanceled && firePasteEvents( eventData.type, data, 0, 1 );
+			} );
+		}
+
+		function setToolbarStates() {
+			if ( editor.mode != 'wysiwyg' )
+				return;
+
+			var pasteState = stateFromNamedCommand( 'paste' );
+
+			editor.getCommand( 'cut' ).setState( stateFromNamedCommand( 'cut' ) );
+			editor.getCommand( 'copy' ).setState( stateFromNamedCommand( 'copy' ) );
+			editor.getCommand( 'paste' ).setState( pasteState );
+			editor.fire( 'pasteState', pasteState );
+		}
+
+		function stateFromNamedCommand( command ) {
+			if ( inReadOnly && command in { paste: 1, cut: 1 } )
+				return CKEDITOR.TRISTATE_DISABLED;
+
+			if ( command == 'paste' )
+				return CKEDITOR.TRISTATE_OFF;
+
+			// Cut, copy - check if the selection is not empty.
+			var sel = editor.getSelection(),
+				ranges = sel.getRanges(),
+				selectionIsEmpty = sel.getType() == CKEDITOR.SELECTION_NONE || ( ranges.length == 1 && ranges[ 0 ].collapsed );
+
+			return selectionIsEmpty ? CKEDITOR.TRISTATE_DISABLED : CKEDITOR.TRISTATE_OFF;
+		}
+	}
+
+	// Returns:
+	// * 'htmlifiedtext' if content looks like transformed by browser from plain text.
+	//		See clipboard/paste.html TCs for more info.
+	// * 'html' if it is not 'htmlifiedtext'.
+	function recogniseContentType( data ) {
+		if ( CKEDITOR.env.webkit ) {
+			// Plain text or ( <div><br></div> and text inside <div> ).
+			if ( !data.match( /^[^<]*$/g ) && !data.match( /^(<div><br( ?\/)?><\/div>|<div>[^<]*<\/div>)*$/gi ) )
+				return 'html';
+		} else if ( CKEDITOR.env.ie ) {
+			// Text and <br> or ( text and <br> in <p> - paragraphs can be separated by new \r\n ).
+			if ( !data.match( /^([^<]|<br( ?\/)?>)*$/gi ) && !data.match( /^(<p>([^<]|<br( ?\/)?>)*<\/p>|(\r\n))*$/gi ) )
+				return 'html';
+		} else if ( CKEDITOR.env.gecko || CKEDITOR.env.opera ) {
+			// Text or <br>.
+			if ( !data.match( /^([^<]|<br( ?\/)?>)*$/gi ) )
+				return 'html';
+		} else
+			return 'html';
+
+		return 'htmlifiedtext';
+	}
+
+	// This function transforms what browsers produce when
+	// pasting plain text into editable element (see clipboard/paste.html TCs
+	// for more info) into correct HTML (similar to that produced by text2Html).
+	function htmlifiedTextHtmlification( config, data ) {
+		function repeatParagraphs( repeats ) {
+			// Repeat blocks floor((n+1)/2) times.
+			// Even number of repeats - add <br> at the beginning of last <p>.
+			return CKEDITOR.tools.repeat( '</p><p>', ~~ ( repeats / 2 ) ) + ( repeats % 2 == 1 ? '<br>' : '' );
+		}
+
+			// Replace adjacent white-spaces (EOLs too - Fx sometimes keeps them) with one space.
+		data = data.replace( /\s+/g, ' ' )
+			// Remove spaces from between tags.
+			.replace( /> +</g, '><' )
+			// Normalize XHTML syntax and upper cased <br> tags.
+			.replace( /<br ?\/>/gi, '<br>' );
+
+		// IE - lower cased tags.
+		data = data.replace( /<\/?[A-Z]+>/g, function( match ) {
+			return match.toLowerCase();
+		} );
+
+		// Don't touch single lines (no <br|p|div>) - nothing to do here.
+		if ( data.match( /^[^<]$/ ) )
+			return data;
+
+		// Webkit.
+		if ( CKEDITOR.env.webkit && data.indexOf( '<div>' ) > -1 ) {
+				// One line break at the beginning - insert <br>
+			data = data.replace( /^(<div>(<br>|)<\/div>)(?!$|(<div>(<br>|)<\/div>))/g, '<br>' )
+				// Two or more - reduce number of new lines by one.
+				.replace( /^(<div>(<br>|)<\/div>){2}(?!$)/g, '<div></div>' );
+
+			// Two line breaks create one paragraph in Webkit.
+			if ( data.match( /<div>(<br>|)<\/div>/ ) ) {
+				data = '<p>' + data.replace( /(<div>(<br>|)<\/div>)+/g, function( match ) {
+					return repeatParagraphs( match.split( '</div><div>' ).length + 1 );
+				} ) + '</p>';
+			}
+
+			// One line break create br.
+			data = data.replace( /<\/div><div>/g, '<br>' );
+
+			// Remove remaining divs.
+			data = data.replace( /<\/?div>/g, '' );
+		}
+
+		// Opera and Firefox and enterMode != BR.
+		if ( ( CKEDITOR.env.gecko || CKEDITOR.env.opera ) && config.enterMode != CKEDITOR.ENTER_BR ) {
+			// Remove bogus <br> - Fx generates two <brs> for one line break.
+			// For two line breaks it still produces two <brs>, but it's better to ignore this case than the first one.
+			if ( CKEDITOR.env.gecko )
+				data = data.replace( /^<br><br>$/, '<br>' );
+
+			// This line satisfy edge case when for Opera we have two line breaks
+			//data = data.replace( /)
+
+			if ( data.indexOf( '<br><br>' ) > -1 ) {
+				// Two line breaks create one paragraph, three - 2, four - 3, etc.
+				data = '<p>' + data.replace( /(<br>){2,}/g, function( match ) {
+					return repeatParagraphs( match.length / 4 );
+				} ) + '</p>';
+			}
+		}
+
+		return switchEnterMode( config, data );
+	}
+
+	// Filter can be editor dependent.
+	function getTextificationFilter( editor ) {
+		var filter = new CKEDITOR.htmlParser.filter();
+
+		// Elements which creates vertical breaks (have vert margins) - took from HTML5 spec.
+		// http://dev.w3.org/html5/markup/Overview.html#toc
+		var replaceWithParaIf = { blockquote: 1, dl: 1, fieldset: 1, h1: 1, h2: 1, h3: 1, h4: 1, h5: 1, h6: 1, ol: 1, p: 1, table: 1, ul: 1 },
+
+			// All names except of <br>.
+			stripInlineIf = CKEDITOR.tools.extend( { br: 0 }, CKEDITOR.dtd.$inline ),
+
+			// What's finally allowed (cke:br will be removed later).
+			allowedIf = { p: 1, br: 1, 'cke:br': 1 },
+
+			knownIf = CKEDITOR.dtd,
+
+			// All names that will be removed (with content).
+			removeIf = CKEDITOR.tools.extend( { area: 1, basefont: 1, embed: 1, iframe: 1, map: 1, object: 1, param: 1 }, CKEDITOR.dtd.$nonBodyContent, CKEDITOR.dtd.$cdata );
+
+		var flattenTableCell = function( element ) {
+				delete element.name;
+				element.add( new CKEDITOR.htmlParser.text( ' ' ) );
+			},
+			// Squash adjacent headers into one. <h1>A</h1><h2>B</h2> -> <h1>A<br>B</h1><h2></h2>
+			// Empty ones will be removed later.
+			squashHeader = function( element ) {
+				var next = element,
+					br, el;
+
+				while ( ( next = next.next ) && next.name && next.name.match( /^h\d$/ ) ) {
+					// TODO shitty code - waitin' for htmlParse.element fix.
+					br = new CKEDITOR.htmlParser.element( 'cke:br' );
+					br.isEmpty = true;
+					element.add( br );
+					while ( ( el = next.children.shift() ) )
+						element.add( el );
+				}
+			};
+
+		filter.addRules( {
+			elements: {
+				h1: squashHeader,
+				h2: squashHeader,
+				h3: squashHeader,
+				h4: squashHeader,
+				h5: squashHeader,
+				h6: squashHeader,
+
+				img: function( element ) {
+					var alt = CKEDITOR.tools.trim( element.attributes.alt || '' ),
+						txt = ' ';
+
+					// Replace image with its alt if it doesn't look like an url or is empty.
+					if ( alt && !alt.match( /(^http|\.(jpe?g|gif|png))/i ) )
+						txt = ' [' + alt + '] ';
+
+					return new CKEDITOR.htmlParser.text( txt );
+				},
+
+				td: flattenTableCell,
+				th: flattenTableCell,
+
+				$: function( element ) {
+					var initialName = element.name,
+						br;
+
+					// Remove entirely.
+					if ( removeIf[ initialName ] )
+						return false;
+
+					// Remove all attributes.
+					element.attributes = {};
+
+					// Pass brs.
+					if ( initialName == 'br' )
+						return element;
+
+					// Elements that we want to replace with paragraphs.
+					if ( replaceWithParaIf[ initialName ] )
+						element.name = 'p';
+
+					// Elements that we want to strip (tags only, without the content).
+					else if ( stripInlineIf[ initialName ] )
+						delete element.name;
+
+					// Surround other known element with <brs> and strip tags.
+					else if ( knownIf[ initialName ] ) {
+						// TODO shitty code - waitin' for htmlParse.element fix.
+						br = new CKEDITOR.htmlParser.element( 'cke:br' );
+						br.isEmpty = true;
+
+						// Replace hrs (maybe sth else too?) with only one br.
+						if ( CKEDITOR.dtd.$empty[ initialName ] )
+							return br;
+
+						element.add( br, 0 );
+						br = br.clone();
+						br.isEmpty = true;
+						element.add( br );
+						delete element.name;
+					}
+
+					// Final cleanup - if we can still find some not allowed elements then strip their names.
+					if ( !allowedIf[ element.name ] )
+						delete element.name;
+
+					return element;
+				}
+			}
+		}, {
+			// Apply this filter to every element.
+			applyToAll: true
+		} );
+
+		return filter;
+	}
+
+	function htmlTextification( config, data, filter ) {
+		var fragment = new CKEDITOR.htmlParser.fragment.fromHtml( data ),
+			writer = new CKEDITOR.htmlParser.basicWriter();
+
+		fragment.writeHtml( writer, filter );
+		data = writer.getHtml();
+
+		// Cleanup cke:brs.
+		data = data.replace( /\s*(<\/?[a-z:]+ ?\/?>)\s*/g, '$1' )	// Remove spaces around tags.
+			.replace( /(<cke:br \/>){2,}/g, '<cke:br />' )			// Join multiple adjacent cke:brs
+			.replace( /(<cke:br \/>)(<\/?p>|<br \/>)/g, '$2' )		// Strip cke:brs adjacent to original brs or ps.
+			.replace( /(<\/?p>|<br \/>)(<cke:br \/>)/g, '$1' )
+			.replace( /<(cke:)?br( \/)?>/g, '<br>' )				// Finally - rename cke:brs to brs and fix <br /> to <br>.
+			.replace( /<p><\/p>/g, '' );							// Remove empty paragraphs.
+
+		// Fix nested ps. E.g.:
+		// <p>A<p>B<p>C</p>D<p>E</p>F</p>G
+		// <p>A</p><p>B</p><p>C</p><p>D</p><p>E</p><p>F</p>G
+		var nested = 0;
+		data = data.replace( /<\/?p>/g, function( match ) {
+			if ( match == '<p>' ) {
+				if ( ++nested > 1 )
+					return '</p><p>';
+			} else {
+				if ( --nested > 0 )
+					return '</p><p>';
+			}
+
+			return match;
+		} ).replace( /<p><\/p>/g, '' ); // Step before: </p></p> -> </p><p></p><p>. Fix this here.
+
+		return switchEnterMode( config, data );
+	}
+
+	function switchEnterMode( config, data ) {
+		if ( config.enterMode == CKEDITOR.ENTER_BR ) {
+			data = data.replace( /(<\/p><p>)+/g, function( match ) {
+				return CKEDITOR.tools.repeat( '<br>', match.length / 7 * 2 );
+			} ).replace( /<\/?p>/g, '' );
+		} else if ( config.enterMode == CKEDITOR.ENTER_DIV )
+			data = data.replace( /<(\/)?p>/g, '<$1div>' );
+
+		return data;
+	}
+} )();
+
+/**
+ * The default content type is used when pasted data cannot be clearly recognized as HTML or text.
+ *
+ * For example: `'foo'` may come from a plain text editor or a website. It isn't possible to recognize content
+ * type in this case, so default will be used. However, it's clear that `'<b>example</b> text'` is an HTML
+ * and its origin is webpage, email or other rich text editor.
+ *
+ * **Note:** If content type is text, then styles of context of paste are preserved.
+ *
+ *		CKEDITOR.config.clipboard_defaultContentType = 'text';
+ *
+ * @since 4.0
+ * @cfg {'html'/'text'} [clipboard_defaultContentType='html']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Fired when a clipboard operation is about to be taken into the editor.
+ * Listeners can manipulate the data to be pasted before having it effectively
+ * inserted into the document.
+ *
+ * @since 3.1
+ * @event paste
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param data
+ * @param {String} data.type Type of data in `data.dataValue`. Usually `html` or `text`, but for listeners
+ * with priority less than 6 it may be also `auto`, what means that content type hasn't been recognised yet
+ * (this will be done by content type sniffer that listens with priority 6).
+ * @param {String} data.dataValue HTML to be pasted.
+ */
+
+/**
+ * Internal event to open the Paste dialog.
+ *
+ * @private
+ * @event pasteDialog
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {Function} [data] Callback that will be passed to {@link CKEDITOR.editor#openDialog}.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/colorbutton/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/colorbutton/plugin.js
new file mode 100644
index 00000000..b11f7660
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/colorbutton/plugin.js
@@ -0,0 +1,286 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "colorbutton" plugin that makes it possible to assign
+ *               text and background colors to editor contents.
+ *
+ */
+CKEDITOR.plugins.add( 'colorbutton', {
+	requires: 'panelbutton,floatpanel',
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	icons: 'bgcolor,textcolor', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		var config = editor.config,
+			lang = editor.lang.colorbutton;
+
+		var clickFn;
+
+		if ( !CKEDITOR.env.hc ) {
+			addButton( 'TextColor', 'fore', lang.textColorTitle, 10 );
+			addButton( 'BGColor', 'back', lang.bgColorTitle, 20 );
+		}
+
+		function addButton( name, type, title, order ) {
+			var style = new CKEDITOR.style( config[ 'colorButton_' + type + 'Style' ] ),
+				colorBoxId = CKEDITOR.tools.getNextId() + '_colorBox';
+
+			editor.ui.add( name, CKEDITOR.UI_PANELBUTTON, {
+				label: title,
+				title: title,
+				modes: { wysiwyg: 1 },
+				editorFocus: 0,
+				toolbar: 'colors,' + order,
+				allowedContent: style,
+				requiredContent: style,
+
+				panel: {
+					css: CKEDITOR.skin.getPath( 'editor' ),
+					attributes: { role: 'listbox', 'aria-label': lang.panelTitle }
+				},
+
+				onBlock: function( panel, block ) {
+					block.autoSize = true;
+					block.element.addClass( 'cke_colorblock' );
+					block.element.setHtml( renderColors( panel, type, colorBoxId ) );
+					// The block should not have scrollbars (#5933, #6056)
+					block.element.getDocument().getBody().setStyle( 'overflow', 'hidden' );
+
+					CKEDITOR.ui.fire( 'ready', this );
+
+					var keys = block.keys;
+					var rtl = editor.lang.dir == 'rtl';
+					keys[ rtl ? 37 : 39 ] = 'next'; // ARROW-RIGHT
+					keys[ 40 ] = 'next'; // ARROW-DOWN
+					keys[ 9 ] = 'next'; // TAB
+					keys[ rtl ? 39 : 37 ] = 'prev'; // ARROW-LEFT
+					keys[ 38 ] = 'prev'; // ARROW-UP
+					keys[ CKEDITOR.SHIFT + 9 ] = 'prev'; // SHIFT + TAB
+					keys[ 32 ] = 'click'; // SPACE
+				},
+
+				refresh: function() {
+					if ( !editor.activeFilter.check( style ) )
+						this.setState( CKEDITOR.TRISTATE_DISABLED );
+				},
+
+				// The automatic colorbox should represent the real color (#6010)
+				onOpen: function() {
+
+					var selection = editor.getSelection(),
+						block = selection && selection.getStartElement(),
+						path = editor.elementPath( block ),
+						color;
+
+					if ( !path )
+						return;
+
+					// Find the closest block element.
+					block = path.block || path.blockLimit || editor.document.getBody();
+
+					// The background color might be transparent. In that case, look up the color in the DOM tree.
+					do {
+						color = block && block.getComputedStyle( type == 'back' ? 'background-color' : 'color' ) || 'transparent';
+					}
+					while ( type == 'back' && color == 'transparent' && block && ( block = block.getParent() ) );
+
+					// The box should never be transparent.
+					if ( !color || color == 'transparent' )
+						color = '#ffffff';
+
+					this._.panel._.iframe.getFrameDocument().getById( colorBoxId ).setStyle( 'background-color', color );
+
+					return color;
+				}
+			} );
+		}
+
+
+		function renderColors( panel, type, colorBoxId ) {
+			var output = [],
+				colors = config.colorButton_colors.split( ',' );
+
+			var clickFn = CKEDITOR.tools.addFunction( function( color, type ) {
+				if ( color == '?' ) {
+					var applyColorStyle = arguments.callee;
+
+					function onColorDialogClose( evt ) {
+						this.removeListener( 'ok', onColorDialogClose );
+						this.removeListener( 'cancel', onColorDialogClose );
+
+						evt.name == 'ok' && applyColorStyle( this.getContentElement( 'picker', 'selectedColor' ).getValue(), type );
+					}
+
+					editor.openDialog( 'colordialog', function() {
+						this.on( 'ok', onColorDialogClose );
+						this.on( 'cancel', onColorDialogClose );
+					} );
+
+					return;
+				}
+
+				editor.focus();
+
+				panel.hide();
+
+				editor.fire( 'saveSnapshot' );
+
+				// Clean up any conflicting style within the range.
+				editor.removeStyle( new CKEDITOR.style( config[ 'colorButton_' + type + 'Style' ], { color: 'inherit' } ) );
+
+				if ( color ) {
+					var colorStyle = config[ 'colorButton_' + type + 'Style' ];
+
+					colorStyle.childRule = type == 'back' ?
+					function( element ) {
+						// It's better to apply background color as the innermost style. (#3599)
+						// Except for "unstylable elements". (#6103)
+						return isUnstylable( element );
+					} : function( element ) {
+						// Fore color style must be applied inside links instead of around it. (#4772,#6908)
+						return !( element.is( 'a' ) || element.getElementsByTag( 'a' ).count() ) || isUnstylable( element );
+					};
+
+					editor.applyStyle( new CKEDITOR.style( colorStyle, { color: color } ) );
+				}
+
+				editor.fire( 'saveSnapshot' );
+			} );
+
+			// Render the "Automatic" button.
+			output.push( '<a class="cke_colorauto" _cke_focus=1 hidefocus=true' +
+				' title="', lang.auto, '"' +
+				' onclick="CKEDITOR.tools.callFunction(', clickFn, ',null,\'', type, '\');return false;"' +
+				' href="javascript:void(\'', lang.auto, '\')"' +
+				' role="option">' +
+				'<table role="presentation" cellspacing=0 cellpadding=0 width="100%">' +
+					'<tr>' +
+						'<td>' +
+							'<span class="cke_colorbox" id="', colorBoxId, '"></span>' +
+						'</td>' +
+						'<td colspan=7 align=center>', lang.auto, '</td>' +
+					'</tr>' +
+				'</table>' +
+				'</a>' +
+				'<table role="presentation" cellspacing=0 cellpadding=0 width="100%">' );
+
+			// Render the color boxes.
+			for ( var i = 0; i < colors.length; i++ ) {
+				if ( ( i % 8 ) === 0 )
+					output.push( '</tr><tr>' );
+
+				var parts = colors[ i ].split( '/' ),
+					colorName = parts[ 0 ],
+					colorCode = parts[ 1 ] || colorName;
+
+				// The data can be only a color code (without #) or colorName + color code
+				// If only a color code is provided, then the colorName is the color with the hash
+				// Convert the color from RGB to RRGGBB for better compatibility with IE and <font>. See #5676
+				if ( !parts[ 1 ] )
+					colorName = '#' + colorName.replace( /^(.)(.)(.)$/, '$1$1$2$2$3$3' );
+
+				var colorLabel = editor.lang.colorbutton.colors[ colorCode ] || colorCode;
+				output.push( '<td>' +
+					'<a class="cke_colorbox" _cke_focus=1 hidefocus=true' +
+						' title="', colorLabel, '"' +
+						' onclick="CKEDITOR.tools.callFunction(', clickFn, ',\'', colorName, '\',\'', type, '\'); return false;"' +
+						' href="javascript:void(\'', colorLabel, '\')"' +
+						' role="option">' +
+						'<span class="cke_colorbox" style="background-color:#', colorCode, '"></span>' +
+					'</a>' +
+					'</td>' );
+			}
+
+			// Render the "More Colors" button.
+			if ( editor.plugins.colordialog && config.colorButton_enableMore === undefined || config.colorButton_enableMore ) {
+				output.push( '</tr>' +
+					'<tr>' +
+						'<td colspan=8 align=center>' +
+							'<a class="cke_colormore" _cke_focus=1 hidefocus=true' +
+								' title="', lang.more, '"' +
+								' onclick="CKEDITOR.tools.callFunction(', clickFn, ',\'?\',\'', type, '\');return false;"' +
+								' href="javascript:void(\'', lang.more, '\')"', ' role="option">', lang.more, '</a>' +
+						'</td>' ); // tr is later in the code.
+			}
+
+			output.push( '</tr></table>' );
+
+			return output.join( '' );
+		}
+
+		function isUnstylable( ele ) {
+			return ( ele.getAttribute( 'contentEditable' ) == 'false' ) || ele.getAttribute( 'data-nostyle' );
+		}
+	}
+} );
+
+/**
+ * Whether to enable the **More Colors*** button in the color selectors.
+ *
+ *		config.colorButton_enableMore = false;
+ *
+ * @cfg {Boolean} [colorButton_enableMore=true]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Defines the colors to be displayed in the color selectors. This is a string
+ * containing hexadecimal notation for HTML colors, without the `'#'` prefix.
+ *
+ * **Since 3.3:** A color name may optionally be defined by prefixing the entries with
+ * a name and the slash character. For example, `'FontColor1/FF9900'` will be
+ * displayed as the color `#FF9900` in the selector, but will be output as `'FontColor1'`.
+ *
+ *		// Brazil colors only.
+ *		config.colorButton_colors = '00923E,F8C100,28166F';
+ *
+ *		config.colorButton_colors = 'FontColor1/FF9900,FontColor2/0066CC,FontColor3/F00';
+ *
+ * @cfg {String} [colorButton_colors=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.colorButton_colors = '000,800000,8B4513,2F4F4F,008080,000080,4B0082,696969,' +
+	'B22222,A52A2A,DAA520,006400,40E0D0,0000CD,800080,808080,' +
+	'F00,FF8C00,FFD700,008000,0FF,00F,EE82EE,A9A9A9,' +
+	'FFA07A,FFA500,FFFF00,00FF00,AFEEEE,ADD8E6,DDA0DD,D3D3D3,' +
+	'FFF0F5,FAEBD7,FFFFE0,F0FFF0,F0FFFF,F0F8FF,E6E6FA,FFF';
+
+/**
+ * Stores the style definition that applies the text foreground color.
+ *
+ *		// This is actually the default value.
+ *		config.colorButton_foreStyle = {
+ *			element: 'span',
+ *			styles: { color: '#(color)' }
+ *		};
+ *
+ * @cfg [colorButton_foreStyle=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.colorButton_foreStyle = {
+	element: 'span',
+	styles: { 'color': '#(color)' },
+	overrides: [ {
+		element: 'font', attributes: { 'color': null }
+	} ]
+};
+
+/**
+ * Stores the style definition that applies the text background color.
+ *
+ *		// This is actually the default value.
+ *		config.colorButton_backStyle = {
+ *			element: 'span',
+ *			styles: { 'background-color': '#(color)' }
+ *		};
+ *
+ * @cfg [colorButton_backStyle=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.colorButton_backStyle = {
+	element: 'span',
+	styles: { 'background-color': '#(color)' }
+};
diff --git a/lam/templates/lib/extra/ckeditor/plugins/contextmenu/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/contextmenu/plugin.js
new file mode 100644
index 00000000..06cb74b2
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/contextmenu/plugin.js
@@ -0,0 +1,143 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'contextmenu', {
+	requires: 'menu',
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+
+	// Make sure the base class (CKEDITOR.menu) is loaded before it (#3318).
+	onLoad: function() {
+		/**
+		 * Class replacing the non-configurable native context menu with configurable CKEditor's equivalent.
+		 *
+		 * @class
+		 * @extends CKEDITOR.menu
+		 */
+		CKEDITOR.plugins.contextMenu = CKEDITOR.tools.createClass( {
+			base: CKEDITOR.menu,
+
+			/**
+			 * Creates the CKEDITOR.plugins.contextMenu class instance.
+			 *
+			 * @constructor
+			 * @param {CKEDITOR.editor} editor
+			 */
+			$: function( editor ) {
+				this.base.call( this, editor, {
+					panel: {
+						className: 'cke_menu_panel',
+						attributes: {
+							'aria-label': editor.lang.contextmenu.options
+						}
+					}
+				} );
+			},
+
+			proto: {
+				/**
+				 * Starts watching on native context menu triggers (option key, right click) on given element.
+				 *
+				 * @param {CKEDITOR.dom.element} element
+				 * @param {Boolean} [nativeContextMenuOnCtrl] Whether to open native context menu if
+				 * *Ctrl* key is hold on opening the context menu. See {@link CKEDITOR.config#browserContextMenuOnCtrl}.
+				 */
+				addTarget: function( element, nativeContextMenuOnCtrl ) {
+					element.on( 'contextmenu', function( event ) {
+						var domEvent = event.data,
+							isCtrlKeyDown =
+								// Safari on Windows always show 'ctrlKey' as true in 'contextmenu' event,
+								// which make this property unreliable. (#4826)
+								( CKEDITOR.env.webkit ? holdCtrlKey : ( CKEDITOR.env.mac ? domEvent.$.metaKey : domEvent.$.ctrlKey ) );
+
+						if ( nativeContextMenuOnCtrl && isCtrlKeyDown )
+							return;
+
+						// Cancel the browser context menu.
+						domEvent.preventDefault();
+
+						var doc = domEvent.getTarget().getDocument(),
+							offsetParent = domEvent.getTarget().getDocument().getDocumentElement(),
+							fromFrame = !doc.equals( CKEDITOR.document ),
+							scroll = doc.getWindow().getScrollPosition(),
+							offsetX = fromFrame ? domEvent.$.clientX : domEvent.$.pageX || scroll.x + domEvent.$.clientX,
+							offsetY = fromFrame ? domEvent.$.clientY : domEvent.$.pageY || scroll.y + domEvent.$.clientY;
+
+						CKEDITOR.tools.setTimeout( function() {
+							this.open( offsetParent, null, offsetX, offsetY );
+
+							// IE needs a short while to allow selection change before opening menu. (#7908)
+						}, CKEDITOR.env.ie ? 200 : 0, this );
+					}, this );
+
+					if ( CKEDITOR.env.webkit ) {
+						var holdCtrlKey,
+							onKeyDown = function( event ) {
+								holdCtrlKey = CKEDITOR.env.mac ? event.data.$.metaKey : event.data.$.ctrlKey;
+							},
+							resetOnKeyUp = function() {
+								holdCtrlKey = 0;
+							};
+
+						element.on( 'keydown', onKeyDown );
+						element.on( 'keyup', resetOnKeyUp );
+						element.on( 'contextmenu', resetOnKeyUp );
+					}
+				},
+
+				/**
+				 * Opens context menu in given location. See the {@link CKEDITOR.menu#show} method.
+				 *
+				 * @param {CKEDITOR.dom.element} offsetParent
+				 * @param {Number} [corner]
+				 * @param {Number} [offsetX]
+				 * @param {Number} [offsetY]
+				 */
+				open: function( offsetParent, corner, offsetX, offsetY ) {
+					this.editor.focus();
+					offsetParent = offsetParent || CKEDITOR.document.getDocumentElement();
+
+					// #9362: Force selection check to update commands' states in the new context.
+					this.editor.selectionChange( 1 );
+
+					this.show( offsetParent, corner, offsetX, offsetY );
+				}
+			}
+		} );
+	},
+
+	beforeInit: function( editor ) {
+		/**
+		 * @readonly
+		 * @property {CKEDITOR.plugins.contextMenu} contextMenu
+		 * @member CKEDITOR.editor
+		 */
+		var contextMenu = editor.contextMenu = new CKEDITOR.plugins.contextMenu( editor );
+
+		editor.on( 'contentDom', function() {
+			contextMenu.addTarget( editor.editable(), editor.config.browserContextMenuOnCtrl !== false );
+		} );
+
+		editor.addCommand( 'contextMenu', {
+			exec: function() {
+				editor.contextMenu.open( editor.document.getBody() );
+			}
+		} );
+
+		editor.setKeystroke( CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' );
+		editor.setKeystroke( CKEDITOR.CTRL + CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' );
+	}
+} );
+
+/**
+ * Whether to show the browser native context menu when the *Ctrl* or
+ * *Meta* (Mac) key is pressed on opening the context menu with the
+ * right mouse button click or the *Menu* key.
+ *
+ *		config.browserContextMenuOnCtrl = false;
+ *
+ * @since 3.0.2
+ * @cfg {Boolean} [browserContextMenuOnCtrl=true]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/dialog/dialogDefinition.js b/lam/templates/lib/extra/ckeditor/plugins/dialog/dialogDefinition.js
new file mode 100644
index 00000000..9d51fcf0
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/dialog/dialogDefinition.js
@@ -0,0 +1,1006 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Defines the "virtual" dialog, dialog content and dialog button
+ * definition classes.
+ */
+
+/**
+ * The definition of a dialog window.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialogs.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		CKEDITOR.dialog.add( 'testOnly', function( editor ) {
+ *			return {
+ *				title:			'Test Dialog',
+ *				resizable:		CKEDITOR.DIALOG_RESIZE_BOTH,
+ *				minWidth:		500,
+ *				minHeight:		400,
+ *				contents: [
+ *					{
+ *						id:			'tab1',
+ *						label:		'First Tab',
+ *						title:		'First Tab Title',
+ *						accessKey:	'Q',
+ *						elements: [
+ *							{
+ *								type:			'text',
+ *								label:			'Test Text 1',
+ *								id:				'testText1',
+ *								'default':		'hello world!'
+ *							}
+ *						]
+ *					}
+ *				]
+ *			};
+ *		} );
+ *
+ * @class CKEDITOR.dialog.definition
+ */
+
+/**
+ * The dialog title, displayed in the dialog's header. Required.
+ *
+ * @property {String} title
+ */
+
+/**
+ * How the dialog can be resized, must be one of the four contents defined below.
+ *
+ * * {@link CKEDITOR#DIALOG_RESIZE_NONE}
+ * * {@link CKEDITOR#DIALOG_RESIZE_WIDTH}
+ * * {@link CKEDITOR#DIALOG_RESIZE_HEIGHT}
+ * * {@link CKEDITOR#DIALOG_RESIZE_BOTH}
+ *
+ * @property {Number} [resizable=CKEDITOR.DIALOG_RESIZE_NONE]
+ */
+
+/**
+ * The minimum width of the dialog, in pixels.
+ *
+ * @property {Number} [minWidth=600]
+ */
+
+/**
+ * The minimum height of the dialog, in pixels.
+ *
+ * @property {Number} [minHeight=400]
+ */
+
+
+/**
+ * The initial width of the dialog, in pixels.
+ *
+ * @since 3.5.3
+ * @property {Number} [width=CKEDITOR.dialog.definition#minWidth]
+ */
+
+/**
+ * The initial height of the dialog, in pixels.
+ *
+ * @since 3.5.3
+ * @property {Number} [height=CKEDITOR.dialog.definition.minHeight]
+ */
+
+/**
+ * The buttons in the dialog, defined as an array of
+ * {@link CKEDITOR.dialog.definition.button} objects.
+ *
+ * @property {Array} [buttons=[ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ]]
+ */
+
+/**
+ * The contents in the dialog, defined as an array of
+ * {@link CKEDITOR.dialog.definition.content} objects. Required.
+ *
+ * @property {Array} contents
+ */
+
+/**
+ * The function to execute when OK is pressed.
+ *
+ * @property {Function} onOk
+ */
+
+/**
+ * The function to execute when Cancel is pressed.
+ *
+ * @property {Function} onCancel
+ */
+
+/**
+ * The function to execute when the dialog is displayed for the first time.
+ *
+ * @property {Function} onLoad
+ */
+
+/**
+ * The function to execute when the dialog is loaded (executed every time the dialog is opened).
+ *
+ * @property {Function} onShow
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog content pages.
+ *
+ * @class CKEDITOR.dialog.definition.content.
+ */
+
+/**
+ * The id of the content page.
+ *
+ * @property {String} id
+ */
+
+/**
+ * The tab label of the content page.
+ *
+ * @property {String} label
+ */
+
+/**
+ * The popup message of the tab label.
+ *
+ * @property {String} title
+ */
+
+/**
+ * The CTRL hotkey for switching to the tab.
+ *
+ *		contentDefinition.accessKey = 'Q'; // Switch to this page when CTRL-Q is pressed.
+ *
+ * @property {String} accessKey
+ */
+
+/**
+ * The UI elements contained in this content page, defined as an array of
+ * {@link CKEDITOR.dialog.definition.uiElement} objects.
+ *
+ * @property {Array} elements
+ */
+
+/**
+ * The definition of user interface element (textarea, radio etc).
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog UI elements.
+ *
+ * @class CKEDITOR.dialog.definition.uiElement
+ * @see CKEDITOR.ui.dialog.uiElement
+ */
+
+/**
+ * The id of the UI element.
+ *
+ * @property {String} id
+ */
+
+/**
+ * The type of the UI element. Required.
+ *
+ * @property {String} type
+ */
+
+/**
+ * The popup label of the UI element.
+ *
+ * @property {String} title
+ */
+
+/**
+ * The content that needs to be allowed to enable this UI element.
+ * All formats accepted by {@link CKEDITOR.filter#check} may be used.
+ *
+ * When all UI elements in a tab are disabled, this tab will be disabled automatically.
+ *
+ * @property {String/Object/CKEDITOR.style} requiredContent
+ */
+
+/**
+ * CSS class names to append to the UI element.
+ *
+ * @property {String} className
+ */
+
+/**
+ * Inline CSS classes to append to the UI element.
+ *
+ * @property {String} style
+ */
+
+/**
+ * Horizontal alignment (in container) of the UI element.
+ *
+ * @property {String} align
+ */
+
+/**
+ * Function to execute the first time the UI element is displayed.
+ *
+ * @property {Function} onLoad
+ */
+
+/**
+ * Function to execute whenever the UI element's parent dialog is displayed.
+ *
+ * @property {Function} onShow
+ */
+
+/**
+ * Function to execute whenever the UI element's parent dialog is closed.
+ *
+ * @property {Function} onHide
+ */
+
+/**
+ * Function to execute whenever the UI element's parent
+ * dialog's {@link CKEDITOR.dialog#setupContent} method is executed.
+ * It usually takes care of the respective UI element as a standalone element.
+ *
+ * @property {Function} setup
+ */
+
+/**
+ * Function to execute whenever the UI element's parent
+ * dialog's {@link CKEDITOR.dialog#commitContent} method is executed.
+ * It usually takes care of the respective UI element as a standalone element.
+ *
+ * @property {Function} commit
+ */
+
+// ----- hbox -----------------------------------------------------------------
+
+/**
+ * Horizontal layout box for dialog UI elements, auto-expends to available width of container.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create horizontal layouts.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.hbox} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'hbox',
+ *			widths: [ '25%', '25%', '50%' ],
+ *			children: [
+ *				{
+ *					type: 'text',
+ *					id: 'id1',
+ *					width: '40px',
+ *				},
+ *				{
+ *					type: 'text',
+ *					id: 'id2',
+ *					width: '40px',
+ *				},
+ *				{
+ *					type: 'text',
+ *					id: 'id3'
+ *				}
+ *			]
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.hbox
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
+ *
+ * @property {Array} children
+ */
+
+/**
+ * (Optional) The widths of child cells.
+ *
+ * @property {Array} widths
+ */
+
+/**
+ * (Optional) The height of the layout.
+ *
+ * @property {Number} height
+ */
+
+/**
+ * The CSS styles to apply to this element.
+ *
+ * @property {String} styles
+ */
+
+/**
+ * (Optional) The padding width inside child cells. Example: 0, 1.
+ *
+ * @property {Number} padding
+ */
+
+/**
+ * (Optional) The alignment of the whole layout. Example: center, top.
+ *
+ * @property {String} align
+ */
+
+// ----- vbox -----------------------------------------------------------------
+
+/**
+ * Vertical layout box for dialog UI elements.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create vertical layouts.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.vbox} object and can
+ * be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'vbox',
+ *			align: 'right',
+ *			width: '200px',
+ *			children: [
+ *				{
+ *					type: 'text',
+ *					id: 'age',
+ *					label: 'Age'
+ *				},
+ *				{
+ *					type: 'text',
+ *					id: 'sex',
+ *					label: 'Sex'
+ *				},
+ *				{
+ *					type: 'text',
+ *					id: 'nationality',
+ *					label: 'Nationality'
+ *				}
+ *			]
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.vbox
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
+ *
+ * @property {Array} children
+ */
+
+/**
+ * (Optional) The width of the layout.
+ *
+ * @property {Array} width
+ */
+
+/**
+ * (Optional) The heights of individual cells.
+ *
+ * @property {Number} heights
+ */
+
+/**
+ * The CSS styles to apply to this element.
+ *
+ * @property {String} styles
+ */
+
+/**
+ * (Optional) The padding width inside child cells. Example: 0, 1.
+ *
+ * @property {Number} padding
+ */
+
+/**
+ * (Optional) The alignment of the whole layout. Example: center, top.
+ *
+ * @property {String} align
+ */
+
+/**
+ * (Optional) Whether the layout should expand vertically to fill its container.
+ *
+ * @property {Boolean} expand
+ */
+
+// ----- labeled element ------------------------------------------------------
+
+/**
+ * The definition of labeled user interface element (textarea, textInput etc).
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog UI elements.
+ *
+ * @class CKEDITOR.dialog.definition.labeledElement
+ * @extends CKEDITOR.dialog.definition.uiElement
+ * @see CKEDITOR.ui.dialog.labeledElement
+ */
+
+/**
+ * The label of the UI element.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label'
+ *		}
+ *
+ * @property {String} label
+ */
+
+/**
+ * (Optional) Specify the layout of the label. Set to `'horizontal'` for horizontal layout.
+ * The default layout is vertical.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label',
+ *			labelLayout: 'horizontal'
+ *		}
+ *
+ * @property {String} labelLayout
+ */
+
+/**
+ * (Optional) Applies only to horizontal layouts: a two elements array of lengths to specify the widths of the
+ * label and the content element. See also {@link CKEDITOR.dialog.definition.labeledElement#labelLayout}.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label',
+ *			labelLayout: 'horizontal',
+ *			widths: [100, 200]
+ *		}
+ *
+ * @property {Array} widths
+ */
+
+/**
+ * Specify the inline style of the uiElement label.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label',
+ *			labelStyle: 'color: red'
+ *		}
+ *
+ * @property {String} labelStyle
+ */
+
+
+/**
+ * Specify the inline style of the input element.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label',
+ *			inputStyle: 'text-align: center'
+ *		}
+ *
+ * @since 3.6.1
+ * @property {String} inputStyle
+ */
+
+/**
+ * Specify the inline style of the input element container.
+ *
+ *		{
+ *			type: 'text',
+ *			label: 'My Label',
+ *			controlStyle: 'width: 3em'
+ *		}
+ *
+ * @since 3.6.1
+ * @property {String} controlStyle
+ */
+
+// ----- button ---------------------------------------------------------------
+
+/**
+ * The definition of a button.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create buttons.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.button} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'button',
+ *			id: 'buttonId',
+ *			label: 'Click me',
+ *			title: 'My title',
+ *			onClick: function() {
+ *				// this = CKEDITOR.ui.dialog.button
+ *				alert( 'Clicked: ' + this.id );
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.button
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * Whether the button is disabled.
+ *
+ * @property {Boolean} disabled
+ */
+
+/**
+ * The label of the UI element.
+ *
+ * @property {String} label
+ */
+
+// ----- checkbox ------
+/**
+ * The definition of a checkbox element.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create groups of checkbox buttons.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.checkbox} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'checkbox',
+ *			id: 'agree',
+ *			label: 'I agree',
+ *			'default': 'checked',
+ *			onClick: function() {
+ *				// this = CKEDITOR.ui.dialog.checkbox
+ *				alert( 'Checked: ' + this.getValue() );
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.checkbox
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * The label of the UI element.
+ *
+ * @property {String} label
+ */
+
+/**
+ * The default state.
+ *
+ * @property {String} [default='' (unchecked)]
+ */
+
+// ----- file -----------------------------------------------------------------
+
+/**
+ * The definition of a file upload input.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create file upload elements.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.file} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'file',
+ *			id: 'upload',
+ *			label: 'Select file from your computer',
+ *			size: 38
+ *		},
+ *		{
+ *			type: 'fileButton',
+ *			id: 'fileId',
+ *			label: 'Upload file',
+ *			'for': [ 'tab1', 'upload' ],
+ *			filebrowser: {
+ *				onSelect: function( fileUrl, data ) {
+ *					alert( 'Successfully uploaded: ' + fileUrl );
+ *				}
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.file
+ * @extends CKEDITOR.dialog.definition.labeledElement
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * (Optional) The action attribute of the form element associated with this file upload input.
+ * If empty, CKEditor will use path to server connector for currently opened folder.
+ *
+ * @property {String} action
+ */
+
+/**
+ * The size of the UI element.
+ *
+ * @property {Number} size
+ */
+
+// ----- fileButton -----------------------------------------------------------
+
+/**
+ * The definition of a button for submitting the file in a file upload input.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create a button for submitting the file in a file upload input.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.fileButton} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ * @class CKEDITOR.dialog.definition.fileButton
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * The label of the UI element.
+ *
+ * @property {String} label
+ */
+
+/**
+ * The instruction for CKEditor how to deal with file upload.
+ * By default, the file and fileButton elements will not work "as expected" if this attribute is not set.
+ *
+ *		// Update field with id 'txtUrl' in the 'tab1' tab when file is uploaded.
+ *		filebrowser: 'tab1:txtUrl'
+ *
+ *		// Call custom onSelect function when file is successfully uploaded.
+ *		filebrowser: {
+ *			onSelect: function( fileUrl, data ) {
+ *				alert( 'Successfully uploaded: ' + fileUrl );
+ *			}
+ *		}
+ *
+ * @property {String} filebrowser/Object
+ */
+
+/**
+ * An array that contains pageId and elementId of the file upload input element for which this button is created.
+ *
+ *		[ pageId, elementId ]
+ *
+ * @property {String} for
+ */
+
+// ----- html -----------------------------------------------------------------
+
+/**
+ * The definition of a raw HTML element.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create elements made from raw HTML code.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.html} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ * To access HTML elements use {@link CKEDITOR.dom.document#getById}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example 1:
+ *		{
+ *			type: 'html',
+ *			html: '<h3>This is some sample HTML content.</h3>'
+ *		}
+ *
+ *		// Example 2:
+ *		// Complete sample with document.getById() call when the "Ok" button is clicked.
+ *		var dialogDefinition = {
+ *			title: 'Sample dialog',
+ *			minWidth: 300,
+ *			minHeight: 200,
+ *			onOk: function() {
+ *				// "this" is now a CKEDITOR.dialog object.
+ *				var document = this.getElement().getDocument();
+ *				// document = CKEDITOR.dom.document
+ *				var element = <b>document.getById( 'myDiv' );</b>
+ *				if ( element )
+ *					alert( element.getHtml() );
+ *			},
+ *			contents: [
+ *				{
+ *					id: 'tab1',
+ *					label: '',
+ *					title: '',
+ *					elements: [
+ *						{
+ *							type: 'html',
+ *							html: '<div id="myDiv">Sample <b>text</b>.</div><div id="otherId">Another div.</div>'
+ *						}
+ *					]
+ *				}
+ *			],
+ *			buttons: [ CKEDITOR.dialog.cancelButton, CKEDITOR.dialog.okButton ]
+ *		};
+ *
+ * @class CKEDITOR.dialog.definition.html
+ * @extends CKEDITOR.dialog.definition.uiElement
+ */
+
+/**
+ * (Required) HTML code of this element.
+ *
+ * @property {String} html
+ */
+
+// ----- radio ----------------------------------------------------------------
+
+/**
+ * The definition of a radio group.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create groups of radio buttons.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.radio} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'radio',
+ *			id: 'country',
+ *			label: 'Which country is bigger',
+ *			items: [ [ 'France', 'FR' ], [ 'Germany', 'DE' ] ],
+ *			style: 'color: green',
+ *			'default': 'DE',
+ *			onClick: function() {
+ *				// this = CKEDITOR.ui.dialog.radio
+ *				alert( 'Current value: ' + this.getValue() );
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.radio
+ * @extends CKEDITOR.dialog.definition.labeledElement
+ */
+
+/**
+ * The default value.
+ *
+ * @property {String} default
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * An array of options. Each option is a 1- or 2-item array of format `[ 'Description', 'Value' ]`.
+ * If `'Value'` is missing, then the value would be assumed to be the same as the description.
+ *
+ * @property {Array} items
+ */
+
+// ----- selectElement --------------------------------------------------------
+
+/**
+ * The definition of a select element.
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create select elements.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.select} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		// Example:
+ *		{
+ *			type: 'select',
+ *			id: 'sport',
+ *			label: 'Select your favourite sport',
+ *			items: [ [ 'Basketball' ], [ 'Baseball' ], [ 'Hockey' ], [ 'Football' ] ],
+ *			'default': 'Football',
+ *			onChange: function( api ) {
+ *				// this = CKEDITOR.ui.dialog.select
+ *				alert( 'Current value: ' + this.getValue() );
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.select
+ * @extends CKEDITOR.dialog.definition.labeledElement
+ */
+
+/**
+ * The default value.
+ *
+ * @property {String} default
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * An array of options. Each option is a 1- or 2-item array of format `[ 'Description', 'Value' ]`.
+ * If `'Value'` is missing, then the value would be assumed to be the same as the description.
+ *
+ * @property {Array} items
+ */
+
+/**
+ * (Optional) Set this to true if you'd like to have a multiple-choice select box.
+ *
+ * @property {Boolean} [multiple=false]
+ */
+
+/**
+ * (Optional) The number of items to display in the select box.
+ *
+ * @property {Number} size
+ */
+
+// ----- textInput ------------------------------------------------------------
+
+/**
+ * The definition of a text field (single line).
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create text fields.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.textInput} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+ *		// There is no constructor for this class, the user just has to define an
+ *		// object with the appropriate properties.
+ *
+ *		{
+ *			type: 'text',
+ *			id: 'name',
+ *			label: 'Your name',
+ *			'default': '',
+ *			validate: function() {
+ *				if ( !this.getValue() ) {
+ *					api.openMsgDialog( '', 'Name cannot be empty.' );
+ *					return false;
+ *				}
+ *			}
+ *		}
+ *
+ * @class CKEDITOR.dialog.definition.textInput
+ * @extends CKEDITOR.dialog.definition.labeledElement
+ */
+
+/**
+ * The default value.
+ *
+ * @property {String} default
+ */
+
+/**
+ * (Optional) The maximum length.
+ *
+ * @property {Number} maxLength
+ */
+
+/**
+ * (Optional) The size of the input field.
+ *
+ * @property {Number} size
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+// ----- textarea -------------------------------------------------------------
+
+/**
+ * The definition of a text field (multiple lines).
+ *
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create textarea.
+ *
+ * Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.textarea} object
+ * and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
+ *
+ * For a complete example of dialog definition, please check {@link CKEDITOR.dialog#add}.
+ *
+* 		// There is no constructor for this class, the user just has to define an
+* 		// object with the appropriate properties.
+*
+* 		// Example:
+* 		{
+* 			type: 'textarea',
+* 			id: 'message',
+* 			label: 'Your comment',
+* 			'default': '',
+* 			validate: function() {
+* 				if ( this.getValue().length < 5 ) {
+* 					api.openMsgDialog( 'The comment is too short.' );
+* 					return false;
+* 				}
+* 			}
+* 		}
+ *
+ * @class CKEDITOR.dialog.definition.textarea
+ * @extends CKEDITOR.dialog.definition.labeledElement
+ */
+
+/**
+ * The number of rows.
+ *
+ * @property {Number} rows
+ */
+
+/**
+ * The number of columns.
+ *
+ * @property {Number} cols
+ */
+
+/**
+ * (Optional) The validation function.
+ *
+ * @property {Function} validate
+ */
+
+/**
+ * The default value.
+ *
+ * @property {String} default
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/dialog/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/dialog/plugin.js
new file mode 100644
index 00000000..c848eb38
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/dialog/plugin.js
@@ -0,0 +1,3267 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The floating dialog plugin.
+ */
+
+/**
+ * No resize for this dialog.
+ *
+ * @readonly
+ * @property {Number} [=0]
+ * @member CKEDITOR
+ */
+CKEDITOR.DIALOG_RESIZE_NONE = 0;
+
+/**
+ * Only allow horizontal resizing for this dialog, disable vertical resizing.
+ *
+ * @readonly
+ * @property {Number} [=1]
+ * @member CKEDITOR
+ */
+CKEDITOR.DIALOG_RESIZE_WIDTH = 1;
+
+/**
+ * Only allow vertical resizing for this dialog, disable horizontal resizing.
+ *
+ * @readonly
+ * @property {Number} [=2]
+ * @member CKEDITOR
+ */
+CKEDITOR.DIALOG_RESIZE_HEIGHT = 2;
+
+/**
+ * Allow the dialog to be resized in both directions.
+ *
+ * @readonly
+ * @property {Number} [=3]
+ * @member CKEDITOR
+ */
+CKEDITOR.DIALOG_RESIZE_BOTH = 3;
+
+( function() {
+	var cssLength = CKEDITOR.tools.cssLength;
+
+	function isTabVisible( tabId ) {
+		return !!this._.tabs[ tabId ][ 0 ].$.offsetHeight;
+	}
+
+	function getPreviousVisibleTab() {
+		var tabId = this._.currentTabId,
+			length = this._.tabIdList.length,
+			tabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, tabId ) + length;
+
+		for ( var i = tabIndex - 1; i > tabIndex - length; i-- ) {
+			if ( isTabVisible.call( this, this._.tabIdList[ i % length ] ) )
+				return this._.tabIdList[ i % length ];
+		}
+
+		return null;
+	}
+
+	function getNextVisibleTab() {
+		var tabId = this._.currentTabId,
+			length = this._.tabIdList.length,
+			tabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, tabId );
+
+		for ( var i = tabIndex + 1; i < tabIndex + length; i++ ) {
+			if ( isTabVisible.call( this, this._.tabIdList[ i % length ] ) )
+				return this._.tabIdList[ i % length ];
+		}
+
+		return null;
+	}
+
+
+	function clearOrRecoverTextInputValue( container, isRecover ) {
+		var inputs = container.$.getElementsByTagName( 'input' );
+		for ( var i = 0, length = inputs.length; i < length; i++ ) {
+			var item = new CKEDITOR.dom.element( inputs[ i ] );
+
+			if ( item.getAttribute( 'type' ).toLowerCase() == 'text' ) {
+				if ( isRecover ) {
+					item.setAttribute( 'value', item.getCustomData( 'fake_value' ) || '' );
+					item.removeCustomData( 'fake_value' );
+				} else {
+					item.setCustomData( 'fake_value', item.getAttribute( 'value' ) );
+					item.setAttribute( 'value', '' );
+				}
+			}
+		}
+	}
+
+	// Handle dialog element validation state UI changes.
+	function handleFieldValidated( isValid, msg ) {
+		var input = this.getInputElement();
+		if ( input )
+			isValid ? input.removeAttribute( 'aria-invalid' ) : input.setAttribute( 'aria-invalid', true );
+
+		if ( !isValid ) {
+			if ( this.select )
+				this.select();
+			else
+				this.focus();
+		}
+
+		msg && alert( msg );
+
+		this.fire( 'validated', { valid: isValid, msg: msg } );
+	}
+
+	function resetField() {
+		var input = this.getInputElement();
+		input && input.removeAttribute( 'aria-invalid' );
+	}
+
+	var templateSource = '<div class="cke_reset_all {editorId} {editorDialogClass} {hidpi}' +
+		'" dir="{langDir}"' +
+		' lang="{langCode}"' +
+		' role="dialog"' +
+		' aria-labelledby="cke_dialog_title_{id}"' +
+		'>' +
+		'<table class="cke_dialog ' + CKEDITOR.env.cssClass + ' cke_{langDir}"' +
+			' style="position:absolute" role="presentation">' +
+			'<tr><td role="presentation">' +
+			'<div class="cke_dialog_body" role="presentation">' +
+				'<div id="cke_dialog_title_{id}" class="cke_dialog_title" role="presentation"></div>' +
+				'<a id="cke_dialog_close_button_{id}" class="cke_dialog_close_button" href="javascript:void(0)" title="{closeTitle}" role="button"><span class="cke_label">X</span></a>' +
+				'<div id="cke_dialog_tabs_{id}" class="cke_dialog_tabs" role="tablist"></div>' +
+				'<table class="cke_dialog_contents" role="presentation">' +
+				'<tr>' +
+					'<td id="cke_dialog_contents_{id}" class="cke_dialog_contents_body" role="presentation"></td>' +
+				'</tr>' +
+				'<tr>' +
+					'<td id="cke_dialog_footer_{id}" class="cke_dialog_footer" role="presentation"></td>' +
+				'</tr>' +
+				'</table>' +
+			'</div>' +
+			'</td></tr>' +
+		'</table>' +
+		'</div>';
+
+	function buildDialog( editor ) {
+		var element = CKEDITOR.dom.element.createFromHtml( CKEDITOR.addTemplate( 'dialog', templateSource ).output( {
+			id: CKEDITOR.tools.getNextNumber(),
+			editorId: editor.id,
+			langDir: editor.lang.dir,
+			langCode: editor.langCode,
+			editorDialogClass: 'cke_editor_' + editor.name.replace( /\./g, '\\.' ) + '_dialog',
+			closeTitle: editor.lang.common.close,
+			hidpi: CKEDITOR.env.hidpi ? 'cke_hidpi' : ''
+		} ) );
+
+		// TODO: Change this to getById(), so it'll support custom templates.
+		var body = element.getChild( [ 0, 0, 0, 0, 0 ] ),
+			title = body.getChild( 0 ),
+			close = body.getChild( 1 );
+
+		// IFrame shim for dialog that masks activeX in IE. (#7619)
+		if ( CKEDITOR.env.ie && !CKEDITOR.env.ie6Compat ) {
+			var src = 'javascript:void(function(){' + encodeURIComponent( 'document.open();(' + CKEDITOR.tools.fixDomain + ')();document.close();' ) + '}())',
+				iframe = CKEDITOR.dom.element.createFromHtml( '<iframe' +
+					' frameBorder="0"' +
+					' class="cke_iframe_shim"' +
+					' src="' + src + '"' +
+					' tabIndex="-1"' +
+					'></iframe>' );
+			iframe.appendTo( body.getParent() );
+		}
+
+		// Make the Title and Close Button unselectable.
+		title.unselectable();
+		close.unselectable();
+
+		return {
+			element: element,
+			parts: {
+				dialog: element.getChild( 0 ),
+				title: title,
+				close: close,
+				tabs: body.getChild( 2 ),
+				contents: body.getChild( [ 3, 0, 0, 0 ] ),
+				footer: body.getChild( [ 3, 0, 1, 0 ] )
+			}
+		};
+	}
+
+	/**
+	 * This is the base class for runtime dialog objects. An instance of this
+	 * class represents a single named dialog for a single editor instance.
+	 *
+	 *		var dialogObj = new CKEDITOR.dialog( editor, 'smiley' );
+	 *
+	 * @class
+	 * @constructor Creates a dialog class instance.
+	 * @param {Object} editor The editor which created the dialog.
+	 * @param {String} dialogName The dialog's registered name.
+	 */
+	CKEDITOR.dialog = function( editor, dialogName ) {
+		// Load the dialog definition.
+		var definition = CKEDITOR.dialog._.dialogDefinitions[ dialogName ],
+			defaultDefinition = CKEDITOR.tools.clone( defaultDialogDefinition ),
+			buttonsOrder = editor.config.dialog_buttonsOrder || 'OS',
+			dir = editor.lang.dir,
+			tabsToRemove = {},
+			i, processed, stopPropagation;
+
+		if ( ( buttonsOrder == 'OS' && CKEDITOR.env.mac ) || // The buttons in MacOS Apps are in reverse order (#4750)
+		( buttonsOrder == 'rtl' && dir == 'ltr' ) || ( buttonsOrder == 'ltr' && dir == 'rtl' ) )
+			defaultDefinition.buttons.reverse();
+
+
+		// Completes the definition with the default values.
+		definition = CKEDITOR.tools.extend( definition( editor ), defaultDefinition );
+
+		// Clone a functionally independent copy for this dialog.
+		definition = CKEDITOR.tools.clone( definition );
+
+		// Create a complex definition object, extending it with the API
+		// functions.
+		definition = new definitionObject( this, definition );
+
+		var doc = CKEDITOR.document;
+
+		var themeBuilt = buildDialog( editor );
+
+		// Initialize some basic parameters.
+		this._ = {
+			editor: editor,
+			element: themeBuilt.element,
+			name: dialogName,
+			contentSize: { width: 0, height: 0 },
+			size: { width: 0, height: 0 },
+			contents: {},
+			buttons: {},
+			accessKeyMap: {},
+
+			// Initialize the tab and page map.
+			tabs: {},
+			tabIdList: [],
+			currentTabId: null,
+			currentTabIndex: null,
+			pageCount: 0,
+			lastTab: null,
+			tabBarMode: false,
+
+			// Initialize the tab order array for input widgets.
+			focusList: [],
+			currentFocusIndex: 0,
+			hasFocus: false
+		};
+
+		this.parts = themeBuilt.parts;
+
+		CKEDITOR.tools.setTimeout( function() {
+			editor.fire( 'ariaWidget', this.parts.contents );
+		}, 0, this );
+
+		// Set the startup styles for the dialog, avoiding it enlarging the
+		// page size on the dialog creation.
+		var startStyles = {
+			position: CKEDITOR.env.ie6Compat ? 'absolute' : 'fixed',
+			top: 0,
+			visibility: 'hidden'
+		};
+
+		startStyles[ dir == 'rtl' ? 'right' : 'left' ] = 0;
+		this.parts.dialog.setStyles( startStyles );
+
+
+		// Call the CKEDITOR.event constructor to initialize this instance.
+		CKEDITOR.event.call( this );
+
+		// Fire the "dialogDefinition" event, making it possible to customize
+		// the dialog definition.
+		this.definition = definition = CKEDITOR.fire( 'dialogDefinition', {
+			name: dialogName,
+			definition: definition
+		}, editor ).definition;
+
+		// Cache tabs that should be removed.
+		if ( !( 'removeDialogTabs' in editor._ ) && editor.config.removeDialogTabs ) {
+			var removeContents = editor.config.removeDialogTabs.split( ';' );
+
+			for ( i = 0; i < removeContents.length; i++ ) {
+				var parts = removeContents[ i ].split( ':' );
+				if ( parts.length == 2 ) {
+					var removeDialogName = parts[ 0 ];
+					if ( !tabsToRemove[ removeDialogName ] )
+						tabsToRemove[ removeDialogName ] = [];
+					tabsToRemove[ removeDialogName ].push( parts[ 1 ] );
+				}
+			}
+			editor._.removeDialogTabs = tabsToRemove;
+		}
+
+		// Remove tabs of this dialog.
+		if ( editor._.removeDialogTabs && ( tabsToRemove = editor._.removeDialogTabs[ dialogName ] ) ) {
+			for ( i = 0; i < tabsToRemove.length; i++ )
+				definition.removeContents( tabsToRemove[ i ] );
+		}
+
+		// Initialize load, show, hide, ok and cancel events.
+		if ( definition.onLoad )
+			this.on( 'load', definition.onLoad );
+
+		if ( definition.onShow )
+			this.on( 'show', definition.onShow );
+
+		if ( definition.onHide )
+			this.on( 'hide', definition.onHide );
+
+		if ( definition.onOk ) {
+			this.on( 'ok', function( evt ) {
+				// Dialog confirm might probably introduce content changes (#5415).
+				editor.fire( 'saveSnapshot' );
+				setTimeout( function() {
+					editor.fire( 'saveSnapshot' );
+				}, 0 );
+				if ( definition.onOk.call( this, evt ) === false )
+					evt.data.hide = false;
+			} );
+		}
+
+		if ( definition.onCancel ) {
+			this.on( 'cancel', function( evt ) {
+				if ( definition.onCancel.call( this, evt ) === false )
+					evt.data.hide = false;
+			} );
+		}
+
+		var me = this;
+
+		// Iterates over all items inside all content in the dialog, calling a
+		// function for each of them.
+		var iterContents = function( func ) {
+				var contents = me._.contents,
+					stop = false;
+
+				for ( var i in contents ) {
+					for ( var j in contents[ i ] ) {
+						stop = func.call( this, contents[ i ][ j ] );
+						if ( stop )
+							return;
+					}
+				}
+			};
+
+		this.on( 'ok', function( evt ) {
+			iterContents( function( item ) {
+				if ( item.validate ) {
+					var retval = item.validate( this ),
+						invalid = typeof( retval ) == 'string' || retval === false;
+
+					if ( invalid ) {
+						evt.data.hide = false;
+						evt.stop();
+					}
+
+					handleFieldValidated.call( item, !invalid, typeof retval == 'string' ? retval : undefined );
+					return invalid;
+				}
+			} );
+		}, this, null, 0 );
+
+		this.on( 'cancel', function( evt ) {
+			iterContents( function( item ) {
+				if ( item.isChanged() ) {
+					if ( !editor.config.dialog_noConfirmCancel && !confirm( editor.lang.common.confirmCancel ) )
+						evt.data.hide = false;
+					return true;
+				}
+			} );
+		}, this, null, 0 );
+
+		this.parts.close.on( 'click', function( evt ) {
+			if ( this.fire( 'cancel', { hide: true } ).hide !== false )
+				this.hide();
+			evt.data.preventDefault();
+		}, this );
+
+		// Sort focus list according to tab order definitions.
+		function setupFocus() {
+			var focusList = me._.focusList;
+			focusList.sort( function( a, b ) {
+				// Mimics browser tab order logics;
+				if ( a.tabIndex != b.tabIndex )
+					return b.tabIndex - a.tabIndex;
+				//  Sort is not stable in some browsers,
+				// fall-back the comparator to 'focusIndex';
+				else
+					return a.focusIndex - b.focusIndex;
+			} );
+
+			var size = focusList.length;
+			for ( var i = 0; i < size; i++ )
+				focusList[ i ].focusIndex = i;
+		}
+
+		function changeFocus( offset ) {
+			var focusList = me._.focusList;
+			offset = offset || 0;
+
+			if ( focusList.length < 1 )
+				return;
+
+			var current = me._.currentFocusIndex;
+
+			// Trigger the 'blur' event of  any input element before anything,
+			// since certain UI updates may depend on it.
+			try {
+				focusList[ current ].getInputElement().$.blur();
+			} catch ( e ) {}
+
+			var startIndex = ( current + offset + focusList.length ) % focusList.length,
+				currentIndex = startIndex;
+			while ( offset && !focusList[ currentIndex ].isFocusable() ) {
+				currentIndex = ( currentIndex + offset + focusList.length ) % focusList.length;
+				if ( currentIndex == startIndex )
+					break;
+			}
+
+			focusList[ currentIndex ].focus();
+
+			// Select whole field content.
+			if ( focusList[ currentIndex ].type == 'text' )
+				focusList[ currentIndex ].select();
+		}
+
+		this.changeFocus = changeFocus;
+
+
+		function keydownHandler( evt ) {
+			// If I'm not the top dialog, ignore.
+			if ( me != CKEDITOR.dialog._.currentTop )
+				return;
+
+			var keystroke = evt.data.getKeystroke(),
+				rtl = editor.lang.dir == 'rtl',
+				button;
+
+			processed = stopPropagation = 0;
+
+			if ( keystroke == 9 || keystroke == CKEDITOR.SHIFT + 9 ) {
+				var shiftPressed = ( keystroke == CKEDITOR.SHIFT + 9 );
+
+				// Handling Tab and Shift-Tab.
+				if ( me._.tabBarMode ) {
+					// Change tabs.
+					var nextId = shiftPressed ? getPreviousVisibleTab.call( me ) : getNextVisibleTab.call( me );
+					me.selectPage( nextId );
+					me._.tabs[ nextId ][ 0 ].focus();
+				} else {
+					// Change the focus of inputs.
+					changeFocus( shiftPressed ? -1 : 1 );
+				}
+
+				processed = 1;
+			} else if ( keystroke == CKEDITOR.ALT + 121 && !me._.tabBarMode && me.getPageCount() > 1 ) {
+				// Alt-F10 puts focus into the current tab item in the tab bar.
+				me._.tabBarMode = true;
+				me._.tabs[ me._.currentTabId ][ 0 ].focus();
+				processed = 1;
+			} else if ( ( keystroke == 37 || keystroke == 39 ) && me._.tabBarMode ) {
+				// Arrow keys - used for changing tabs.
+				nextId = ( keystroke == ( rtl ? 39 : 37 ) ? getPreviousVisibleTab.call( me ) : getNextVisibleTab.call( me ) );
+				me.selectPage( nextId );
+				me._.tabs[ nextId ][ 0 ].focus();
+				processed = 1;
+			} else if ( ( keystroke == 13 || keystroke == 32 ) && me._.tabBarMode ) {
+				this.selectPage( this._.currentTabId );
+				this._.tabBarMode = false;
+				this._.currentFocusIndex = -1;
+				changeFocus( 1 );
+				processed = 1;
+			}
+			// If user presses enter key in a text box, it implies clicking OK for the dialog.
+			else if ( keystroke == 13 /*ENTER*/ ) {
+				// Don't do that for a target that handles ENTER.
+				var target = evt.data.getTarget();
+				if ( !target.is( 'a', 'button', 'select', 'textarea' ) && ( !target.is( 'input' ) || target.$.type != 'button' ) ) {
+					button = this.getButton( 'ok' );
+					button && CKEDITOR.tools.setTimeout( button.click, 0, button );
+					processed = 1;
+				}
+				stopPropagation = 1; // Always block the propagation (#4269)
+			} else if ( keystroke == 27 /*ESC*/ ) {
+				button = this.getButton( 'cancel' );
+
+				// If there's a Cancel button, click it, else just fire the cancel event and hide the dialog.
+				if ( button )
+					CKEDITOR.tools.setTimeout( button.click, 0, button );
+				else {
+					if ( this.fire( 'cancel', { hide: true } ).hide !== false )
+						this.hide();
+				}
+				stopPropagation = 1; // Always block the propagation (#4269)
+			} else
+				return;
+
+			keypressHandler( evt );
+		}
+
+		function keypressHandler( evt ) {
+			if ( processed )
+				evt.data.preventDefault( 1 );
+			else if ( stopPropagation )
+				evt.data.stopPropagation();
+		}
+
+		var dialogElement = this._.element;
+
+		editor.focusManager.add( dialogElement, 1 );
+
+		// Add the dialog keyboard handlers.
+		this.on( 'show', function() {
+			dialogElement.on( 'keydown', keydownHandler, this );
+
+			// Some browsers instead, don't cancel key events in the keydown, but in the
+			// keypress. So we must do a longer trip in those cases. (#4531,#8985)
+			if ( CKEDITOR.env.opera || CKEDITOR.env.gecko )
+				dialogElement.on( 'keypress', keypressHandler, this );
+
+		} );
+		this.on( 'hide', function() {
+			dialogElement.removeListener( 'keydown', keydownHandler );
+			if ( CKEDITOR.env.opera || CKEDITOR.env.gecko )
+				dialogElement.removeListener( 'keypress', keypressHandler );
+
+			// Reset fields state when closing dialog.
+			iterContents( function( item ) {
+				resetField.apply( item );
+			} );
+		} );
+		this.on( 'iframeAdded', function( evt ) {
+			var doc = new CKEDITOR.dom.document( evt.data.iframe.$.contentWindow.document );
+			doc.on( 'keydown', keydownHandler, this, null, 0 );
+		} );
+
+		// Auto-focus logic in dialog.
+		this.on( 'show', function() {
+			// Setup tabIndex on showing the dialog instead of on loading
+			// to allow dynamic tab order happen in dialog definition.
+			setupFocus();
+
+			if ( editor.config.dialog_startupFocusTab && me._.pageCount > 1 ) {
+				me._.tabBarMode = true;
+				me._.tabs[ me._.currentTabId ][ 0 ].focus();
+			} else if ( !this._.hasFocus ) {
+				this._.currentFocusIndex = -1;
+
+				// Decide where to put the initial focus.
+				if ( definition.onFocus ) {
+					var initialFocus = definition.onFocus.call( this );
+					// Focus the field that the user specified.
+					initialFocus && initialFocus.focus();
+				}
+				// Focus the first field in layout order.
+				else
+					changeFocus( 1 );
+			}
+		}, this, null, 0xffffffff );
+
+		// IE6 BUG: Text fields and text areas are only half-rendered the first time the dialog appears in IE6 (#2661).
+		// This is still needed after [2708] and [2709] because text fields in hidden TR tags are still broken.
+		if ( CKEDITOR.env.ie6Compat ) {
+			this.on( 'load', function( evt ) {
+				var outer = this.getElement(),
+					inner = outer.getFirst();
+				inner.remove();
+				inner.appendTo( outer );
+			}, this );
+		}
+
+		initDragAndDrop( this );
+		initResizeHandles( this );
+
+		// Insert the title.
+		( new CKEDITOR.dom.text( definition.title, CKEDITOR.document ) ).appendTo( this.parts.title );
+
+		// Insert the tabs and contents.
+		for ( i = 0; i < definition.contents.length; i++ ) {
+			var page = definition.contents[ i ];
+			page && this.addPage( page );
+		}
+
+		this.parts[ 'tabs' ].on( 'click', function( evt ) {
+			var target = evt.data.getTarget();
+			// If we aren't inside a tab, bail out.
+			if ( target.hasClass( 'cke_dialog_tab' ) ) {
+				// Get the ID of the tab, without the 'cke_' prefix and the unique number suffix.
+				var id = target.$.id;
+				this.selectPage( id.substring( 4, id.lastIndexOf( '_' ) ) );
+
+				if ( this._.tabBarMode ) {
+					this._.tabBarMode = false;
+					this._.currentFocusIndex = -1;
+					changeFocus( 1 );
+				}
+				evt.data.preventDefault();
+			}
+		}, this );
+
+		// Insert buttons.
+		var buttonsHtml = [],
+			buttons = CKEDITOR.dialog._.uiElementBuilders.hbox.build( this, {
+				type: 'hbox',
+				className: 'cke_dialog_footer_buttons',
+				widths: [],
+				children: definition.buttons
+			}, buttonsHtml ).getChild();
+		this.parts.footer.setHtml( buttonsHtml.join( '' ) );
+
+		for ( i = 0; i < buttons.length; i++ )
+			this._.buttons[ buttons[ i ].id ] = buttons[ i ];
+	};
+
+	// Focusable interface. Use it via dialog.addFocusable.
+	function Focusable( dialog, element, index ) {
+		this.element = element;
+		this.focusIndex = index;
+		// TODO: support tabIndex for focusables.
+		this.tabIndex = 0;
+		this.isFocusable = function() {
+			return !element.getAttribute( 'disabled' ) && element.isVisible();
+		};
+		this.focus = function() {
+			dialog._.currentFocusIndex = this.focusIndex;
+			this.element.focus();
+		};
+		// Bind events
+		element.on( 'keydown', function( e ) {
+			if ( e.data.getKeystroke() in { 32: 1, 13: 1 } )
+				this.fire( 'click' );
+		} );
+		element.on( 'focus', function() {
+			this.fire( 'mouseover' );
+		} );
+		element.on( 'blur', function() {
+			this.fire( 'mouseout' );
+		} );
+	}
+
+	// Re-layout the dialog on window resize.
+	function resizeWithWindow( dialog ) {
+		var win = CKEDITOR.document.getWindow();
+		function resizeHandler() { dialog.layout(); }
+		win.on( 'resize', resizeHandler );
+		dialog.on( 'hide', function() { win.removeListener( 'resize', resizeHandler ); } );
+	}
+
+	CKEDITOR.dialog.prototype = {
+		destroy: function() {
+			this.hide();
+			this._.element.remove();
+		},
+
+		/**
+		 * Resizes the dialog.
+		 *
+		 *		dialogObj.resize( 800, 640 );
+		 *
+		 * @method
+		 * @param {Number} width The width of the dialog in pixels.
+		 * @param {Number} height The height of the dialog in pixels.
+		 */
+		resize: ( function() {
+			return function( width, height ) {
+				if ( this._.contentSize && this._.contentSize.width == width && this._.contentSize.height == height )
+					return;
+
+				CKEDITOR.dialog.fire( 'resize', {
+					dialog: this,
+					width: width,
+					height: height
+				}, this._.editor );
+
+				this.fire( 'resize', {
+					width: width,
+					height: height
+				}, this._.editor );
+
+				var contents = this.parts.contents;
+				contents.setStyles( {
+					width: width + 'px',
+					height: height + 'px'
+				} );
+
+				// Update dialog position when dimension get changed in RTL.
+				if ( this._.editor.lang.dir == 'rtl' && this._.position )
+					this._.position.x = CKEDITOR.document.getWindow().getViewPaneSize().width - this._.contentSize.width - parseInt( this._.element.getFirst().getStyle( 'right' ), 10 );
+
+				this._.contentSize = { width: width, height: height };
+			};
+		} )(),
+
+		/**
+		 * Gets the current size of the dialog in pixels.
+		 *
+		 * var width = dialogObj.getSize().width;
+		 *
+		 * @returns {Object}
+		 * @returns {Number} return.width
+		 * @returns {Number} return.height
+		 */
+		getSize: function() {
+			var element = this._.element.getFirst();
+			return { width: element.$.offsetWidth || 0, height: element.$.offsetHeight || 0 };
+		},
+
+		/**
+		 * Moves the dialog to an `(x, y)` coordinate relative to the window.
+		 *
+		 * dialogObj.move( 10, 40 );
+		 *
+		 * @method
+		 * @param {Number} x The target x-coordinate.
+		 * @param {Number} y The target y-coordinate.
+		 * @param {Boolean} save Flag indicate whether the dialog position should be remembered on next open up.
+		 */
+		move: function( x, y, save ) {
+
+			// The dialog may be fixed positioned or absolute positioned. Ask the
+			// browser what is the current situation first.
+			var element = this._.element.getFirst(), rtl = this._.editor.lang.dir == 'rtl';
+			var isFixed = element.getComputedStyle( 'position' ) == 'fixed';
+
+			// (#8888) In some cases of a very small viewport, dialog is incorrectly
+			// positioned in IE7. It also happens that it remains sticky and user cannot
+			// scroll down/up to reveal dialog's content below/above the viewport; this is
+			// cumbersome.
+			// The only way to fix this is to move mouse out of the browser and
+			// go back to see that dialog position is automagically fixed. No events,
+			// no style change - pure magic. This is a IE7 rendering issue, which can be
+			// fixed with dummy style redraw on each move.
+			if ( CKEDITOR.env.ie )
+				element.setStyle( 'zoom', '100%' );
+
+			if ( isFixed && this._.position && this._.position.x == x && this._.position.y == y )
+				return;
+
+			// Save the current position.
+			this._.position = { x: x, y: y };
+
+			// If not fixed positioned, add scroll position to the coordinates.
+			if ( !isFixed ) {
+				var scrollPosition = CKEDITOR.document.getWindow().getScrollPosition();
+				x += scrollPosition.x;
+				y += scrollPosition.y;
+			}
+
+			// Translate coordinate for RTL.
+			if ( rtl ) {
+				var dialogSize = this.getSize(), viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize();
+				x = viewPaneSize.width - dialogSize.width - x;
+			}
+
+			var styles = { 'top': ( y > 0 ? y : 0 ) + 'px' };
+			styles[ rtl ? 'right' : 'left' ] = ( x > 0 ? x : 0 ) + 'px';
+
+			element.setStyles( styles );
+
+			save && ( this._.moved = 1 );
+		},
+
+		/**
+		 * Gets the dialog's position in the window.
+		 *
+		 *		var dialogX = dialogObj.getPosition().x;
+		 *
+		 * @returns {Object}
+		 * @returns {Number} return.x
+		 * @returns {Number} return.y
+		 */
+		getPosition: function() {
+			return CKEDITOR.tools.extend( {}, this._.position );
+		},
+
+		/**
+		 * Shows the dialog box.
+		 *
+		 *		dialogObj.show();
+		 */
+		show: function() {
+			// Insert the dialog's element to the root document.
+			var element = this._.element;
+			var definition = this.definition;
+			if ( !( element.getParent() && element.getParent().equals( CKEDITOR.document.getBody() ) ) )
+				element.appendTo( CKEDITOR.document.getBody() );
+			else
+				element.setStyle( 'display', 'block' );
+
+			// FIREFOX BUG: Fix vanishing caret for Firefox 2 or Gecko 1.8.
+			if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 ) {
+				var dialogElement = this.parts.dialog;
+				dialogElement.setStyle( 'position', 'absolute' );
+				setTimeout( function() {
+					dialogElement.setStyle( 'position', 'fixed' );
+				}, 0 );
+			}
+
+
+			// First, set the dialog to an appropriate size.
+			this.resize( this._.contentSize && this._.contentSize.width || definition.width || definition.minWidth, this._.contentSize && this._.contentSize.height || definition.height || definition.minHeight );
+
+			// Reset all inputs back to their default value.
+			this.reset();
+
+			// Select the first tab by default.
+			this.selectPage( this.definition.contents[ 0 ].id );
+
+			// Set z-index.
+			if ( CKEDITOR.dialog._.currentZIndex === null )
+				CKEDITOR.dialog._.currentZIndex = this._.editor.config.baseFloatZIndex;
+			this._.element.getFirst().setStyle( 'z-index', CKEDITOR.dialog._.currentZIndex += 10 );
+
+			// Maintain the dialog ordering and dialog cover.
+			if ( CKEDITOR.dialog._.currentTop === null ) {
+				CKEDITOR.dialog._.currentTop = this;
+				this._.parentDialog = null;
+				showCover( this._.editor );
+
+			} else {
+				this._.parentDialog = CKEDITOR.dialog._.currentTop;
+				var parentElement = this._.parentDialog.getElement().getFirst();
+				parentElement.$.style.zIndex -= Math.floor( this._.editor.config.baseFloatZIndex / 2 );
+				CKEDITOR.dialog._.currentTop = this;
+			}
+
+			element.on( 'keydown', accessKeyDownHandler );
+			element.on( CKEDITOR.env.opera ? 'keypress' : 'keyup', accessKeyUpHandler );
+
+			// Reset the hasFocus state.
+			this._.hasFocus = false;
+
+			for ( var i in definition.contents ) {
+				if ( !definition.contents[ i ] )
+					continue;
+
+				var content = definition.contents[ i ],
+					tab = this._.tabs[ content.id ],
+					requiredContent = content.requiredContent,
+					enableElements = 0;
+
+				if ( !tab )
+					continue;
+
+				for ( var j in this._.contents[ content.id ] ) {
+					var elem = this._.contents[ content.id ][ j ];
+
+					if ( elem.type == 'hbox' || elem.type == 'vbox' || !elem.getInputElement() )
+						continue;
+
+					if ( elem.requiredContent && !this._.editor.activeFilter.check( elem.requiredContent ) )
+						elem.disable();
+					else {
+						elem.enable();
+						enableElements++;
+					}
+				}
+
+				if ( !enableElements || ( requiredContent && !this._.editor.activeFilter.check( requiredContent ) ) )
+					tab[ 0 ].addClass( 'cke_dialog_tab_disabled' );
+				else
+					tab[ 0 ].removeClass( 'cke_dialog_tab_disabled' );
+			}
+
+			CKEDITOR.tools.setTimeout( function() {
+				this.layout();
+				resizeWithWindow( this );
+
+				this.parts.dialog.setStyle( 'visibility', '' );
+
+				// Execute onLoad for the first show.
+				this.fireOnce( 'load', {} );
+				CKEDITOR.ui.fire( 'ready', this );
+
+				this.fire( 'show', {} );
+				this._.editor.fire( 'dialogShow', this );
+
+				if ( !this._.parentDialog )
+					this._.editor.focusManager.lock();
+
+				// Save the initial values of the dialog.
+				this.foreach( function( contentObj ) {
+					contentObj.setInitValue && contentObj.setInitValue();
+				} );
+
+			}, 100, this );
+		},
+
+		/**
+		 * Rearrange the dialog to its previous position or the middle of the window.
+		 *
+		 * @since 3.5
+		 */
+		layout: function() {
+			var el = this.parts.dialog;
+			var dialogSize = this.getSize();
+			var win = CKEDITOR.document.getWindow(),
+					viewSize = win.getViewPaneSize();
+
+			var posX = ( viewSize.width - dialogSize.width ) / 2,
+				posY = ( viewSize.height - dialogSize.height ) / 2;
+
+			// Switch to absolute position when viewport is smaller than dialog size.
+			if ( !CKEDITOR.env.ie6Compat ) {
+				if ( dialogSize.height + ( posY > 0 ? posY : 0 ) > viewSize.height ||
+						 dialogSize.width + ( posX > 0 ? posX : 0 ) > viewSize.width )
+					el.setStyle( 'position', 'absolute' );
+				else
+					el.setStyle( 'position', 'fixed' );
+			}
+
+			this.move( this._.moved ? this._.position.x : posX,
+					this._.moved ? this._.position.y : posY );
+		},
+
+		/**
+		 * Executes a function for each UI element.
+		 *
+		 * @param {Function} fn Function to execute for each UI element.
+		 * @returns {CKEDITOR.dialog} The current dialog object.
+		 */
+		foreach: function( fn ) {
+			for ( var i in this._.contents ) {
+				for ( var j in this._.contents[ i ] )
+					fn.call( this, this._.contents[ i ][ j ] );
+			}
+			return this;
+		},
+
+		/**
+		 * Resets all input values in the dialog.
+		 *
+		 *		dialogObj.reset();
+		 *
+		 * @method
+		 * @chainable
+		 */
+		reset: ( function() {
+			var fn = function( widget ) {
+					if ( widget.reset )
+						widget.reset( 1 );
+				};
+			return function() {
+				this.foreach( fn );
+				return this;
+			};
+		} )(),
+
+
+		/**
+		 * Calls the {@link CKEDITOR.dialog.definition.uiElement#setup} method of each
+		 * of the UI elements, with the arguments passed through it.
+		 * It is usually being called when the dialog is opened, to put the initial value inside the field.
+		 *
+		 *		dialogObj.setupContent();
+		 *
+		 *		var timestamp = ( new Date() ).valueOf();
+		 *		dialogObj.setupContent( timestamp );
+		 */
+		setupContent: function() {
+			var args = arguments;
+			this.foreach( function( widget ) {
+				if ( widget.setup )
+					widget.setup.apply( widget, args );
+			} );
+		},
+
+		/**
+		 * Calls the {@link CKEDITOR.dialog.definition.uiElement#commit} method of each
+		 * of the UI elements, with the arguments passed through it.
+		 * It is usually being called when the user confirms the dialog, to process the values.
+		 *
+		 *		dialogObj.commitContent();
+		 *
+		 *		var timestamp = ( new Date() ).valueOf();
+		 *		dialogObj.commitContent( timestamp );
+		 */
+		commitContent: function() {
+			var args = arguments;
+			this.foreach( function( widget ) {
+				// Make sure IE triggers "change" event on last focused input before closing the dialog. (#7915)
+				if ( CKEDITOR.env.ie && this._.currentFocusIndex == widget.focusIndex )
+					widget.getInputElement().$.blur();
+
+				if ( widget.commit )
+					widget.commit.apply( widget, args );
+			} );
+		},
+
+		/**
+		 * Hides the dialog box.
+		 *
+		 *		dialogObj.hide();
+		 */
+		hide: function() {
+			if ( !this.parts.dialog.isVisible() )
+				return;
+
+			this.fire( 'hide', {} );
+			this._.editor.fire( 'dialogHide', this );
+			// Reset the tab page.
+			this.selectPage( this._.tabIdList[ 0 ] );
+			var element = this._.element;
+			element.setStyle( 'display', 'none' );
+			this.parts.dialog.setStyle( 'visibility', 'hidden' );
+			// Unregister all access keys associated with this dialog.
+			unregisterAccessKey( this );
+
+			// Close any child(top) dialogs first.
+			while ( CKEDITOR.dialog._.currentTop != this )
+				CKEDITOR.dialog._.currentTop.hide();
+
+			// Maintain dialog ordering and remove cover if needed.
+			if ( !this._.parentDialog )
+				hideCover( this._.editor );
+			else {
+				var parentElement = this._.parentDialog.getElement().getFirst();
+				parentElement.setStyle( 'z-index', parseInt( parentElement.$.style.zIndex, 10 ) + Math.floor( this._.editor.config.baseFloatZIndex / 2 ) );
+			}
+			CKEDITOR.dialog._.currentTop = this._.parentDialog;
+
+			// Deduct or clear the z-index.
+			if ( !this._.parentDialog ) {
+				CKEDITOR.dialog._.currentZIndex = null;
+
+				// Remove access key handlers.
+				element.removeListener( 'keydown', accessKeyDownHandler );
+				element.removeListener( CKEDITOR.env.opera ? 'keypress' : 'keyup', accessKeyUpHandler );
+
+				var editor = this._.editor;
+				editor.focus();
+
+				// Give a while before unlock, waiting for focus to return to the editable. (#172)
+				setTimeout( function() { editor.focusManager.unlock(); }, 0 );
+
+			} else
+				CKEDITOR.dialog._.currentZIndex -= 10;
+
+			delete this._.parentDialog;
+			// Reset the initial values of the dialog.
+			this.foreach( function( contentObj ) {
+				contentObj.resetInitValue && contentObj.resetInitValue();
+			} );
+		},
+
+		/**
+		 * Adds a tabbed page into the dialog.
+		 *
+		 * @param {Object} contents Content definition.
+		 */
+		addPage: function( contents ) {
+			if ( contents.requiredContent && !this._.editor.filter.check( contents.requiredContent ) )
+				return;
+
+			var pageHtml = [],
+				titleHtml = contents.label ? ' title="' + CKEDITOR.tools.htmlEncode( contents.label ) + '"' : '',
+				elements = contents.elements,
+				vbox = CKEDITOR.dialog._.uiElementBuilders.vbox.build( this, {
+					type: 'vbox',
+					className: 'cke_dialog_page_contents',
+					children: contents.elements,
+					expand: !!contents.expand,
+					padding: contents.padding,
+					style: contents.style || 'width: 100%;'
+				}, pageHtml );
+
+			var contentMap = this._.contents[ contents.id ] = {},
+				cursor,
+				children = vbox.getChild(),
+				enabledFields = 0;
+
+			while ( ( cursor = children.shift() ) ) {
+				// Count all allowed fields.
+				if ( !cursor.notAllowed && cursor.type != 'hbox' && cursor.type != 'vbox' )
+					enabledFields++;
+
+				contentMap[ cursor.id ] = cursor;
+				if ( typeof( cursor.getChild ) == 'function' )
+					children.push.apply( children, cursor.getChild() );
+			}
+
+			// If all fields are disabled (because they are not allowed) hide this tab.
+			if ( !enabledFields )
+				contents.hidden = true;
+
+			// Create the HTML for the tab and the content block.
+			var page = CKEDITOR.dom.element.createFromHtml( pageHtml.join( '' ) );
+			page.setAttribute( 'role', 'tabpanel' );
+
+			var env = CKEDITOR.env;
+			var tabId = 'cke_' + contents.id + '_' + CKEDITOR.tools.getNextNumber(),
+				tab = CKEDITOR.dom.element.createFromHtml( [
+					'<a class="cke_dialog_tab"',
+						( this._.pageCount > 0 ? ' cke_last' : 'cke_first' ),
+						titleHtml,
+						( !!contents.hidden ? ' style="display:none"' : '' ),
+						' id="', tabId, '"',
+						env.gecko && env.version >= 10900 && !env.hc ? '' : ' href="javascript:void(0)"',
+						' tabIndex="-1"',
+						' hidefocus="true"',
+						' role="tab">',
+							contents.label,
+					'</a>'
+					].join( '' ) );
+
+			page.setAttribute( 'aria-labelledby', tabId );
+
+			// Take records for the tabs and elements created.
+			this._.tabs[ contents.id ] = [ tab, page ];
+			this._.tabIdList.push( contents.id );
+			!contents.hidden && this._.pageCount++;
+			this._.lastTab = tab;
+			this.updateStyle();
+
+			// Attach the DOM nodes.
+
+			page.setAttribute( 'name', contents.id );
+			page.appendTo( this.parts.contents );
+
+			tab.unselectable();
+			this.parts.tabs.append( tab );
+
+			// Add access key handlers if access key is defined.
+			if ( contents.accessKey ) {
+				registerAccessKey( this, this, 'CTRL+' + contents.accessKey, tabAccessKeyDown, tabAccessKeyUp );
+				this._.accessKeyMap[ 'CTRL+' + contents.accessKey ] = contents.id;
+			}
+		},
+
+		/**
+		 * Activates a tab page in the dialog by its id.
+		 *
+		 *		dialogObj.selectPage( 'tab_1' );
+		 *
+		 * @param {String} id The id of the dialog tab to be activated.
+		 */
+		selectPage: function( id ) {
+			if ( this._.currentTabId == id )
+				return;
+
+			if ( this._.tabs[ id ][ 0 ].hasClass( 'cke_dialog_tab_disabled' ) )
+				return;
+
+			// If event was canceled - do nothing.
+			if ( this.fire( 'selectPage', { page: id, currentPage: this._.currentTabId } ) === false )
+				return;
+
+			// Hide the non-selected tabs and pages.
+			for ( var i in this._.tabs ) {
+				var tab = this._.tabs[ i ][ 0 ],
+					page = this._.tabs[ i ][ 1 ];
+				if ( i != id ) {
+					tab.removeClass( 'cke_dialog_tab_selected' );
+					page.hide();
+				}
+				page.setAttribute( 'aria-hidden', i != id );
+			}
+
+			var selected = this._.tabs[ id ];
+			selected[ 0 ].addClass( 'cke_dialog_tab_selected' );
+
+			// [IE] an invisible input[type='text'] will enlarge it's width
+			// if it's value is long when it shows, so we clear it's value
+			// before it shows and then recover it (#5649)
+			if ( CKEDITOR.env.ie6Compat || CKEDITOR.env.ie7Compat ) {
+				clearOrRecoverTextInputValue( selected[ 1 ] );
+				selected[ 1 ].show();
+				setTimeout( function() {
+					clearOrRecoverTextInputValue( selected[ 1 ], 1 );
+				}, 0 );
+			} else
+				selected[ 1 ].show();
+
+			this._.currentTabId = id;
+			this._.currentTabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, id );
+		},
+
+		/**
+		 * Dialog state-specific style updates.
+		 */
+		updateStyle: function() {
+			// If only a single page shown, a different style is used in the central pane.
+			this.parts.dialog[ ( this._.pageCount === 1 ? 'add' : 'remove' ) + 'Class' ]( 'cke_single_page' );
+		},
+
+		/**
+		 * Hides a page's tab away from the dialog.
+		 *
+		 *		dialog.hidePage( 'tab_3' );
+		 *
+		 * @param {String} id The page's Id.
+		 */
+		hidePage: function( id ) {
+			var tab = this._.tabs[ id ] && this._.tabs[ id ][ 0 ];
+			if ( !tab || this._.pageCount == 1 || !tab.isVisible() )
+				return;
+			// Switch to other tab first when we're hiding the active tab.
+			else if ( id == this._.currentTabId )
+				this.selectPage( getPreviousVisibleTab.call( this ) );
+
+			tab.hide();
+			this._.pageCount--;
+			this.updateStyle();
+		},
+
+		/**
+		 * Unhides a page's tab.
+		 *
+		 *		dialog.showPage( 'tab_2' );
+		 *
+		 * @param {String} id The page's Id.
+		 */
+		showPage: function( id ) {
+			var tab = this._.tabs[ id ] && this._.tabs[ id ][ 0 ];
+			if ( !tab )
+				return;
+			tab.show();
+			this._.pageCount++;
+			this.updateStyle();
+		},
+
+		/**
+		 * Gets the root DOM element of the dialog.
+		 *
+		 *		var dialogElement = dialogObj.getElement().getFirst();
+		 *		dialogElement.setStyle( 'padding', '5px' );
+		 *
+		 * @returns {CKEDITOR.dom.element} The `<span>` element containing this dialog.
+		 */
+		getElement: function() {
+			return this._.element;
+		},
+
+		/**
+		 * Gets the name of the dialog.
+		 *
+		 *		var dialogName = dialogObj.getName();
+		 *
+		 * @returns {String} The name of this dialog.
+		 */
+		getName: function() {
+			return this._.name;
+		},
+
+		/**
+		 * Gets a dialog UI element object from a dialog page.
+		 *
+		 *		dialogObj.getContentElement( 'tabId', 'elementId' ).setValue( 'Example' );
+		 *
+		 * @param {String} pageId id of dialog page.
+		 * @param {String} elementId id of UI element.
+		 * @returns {CKEDITOR.ui.dialog.uiElement} The dialog UI element.
+		 */
+		getContentElement: function( pageId, elementId ) {
+			var page = this._.contents[ pageId ];
+			return page && page[ elementId ];
+		},
+
+		/**
+		 * Gets the value of a dialog UI element.
+		 *
+		 *		alert( dialogObj.getValueOf( 'tabId', 'elementId' ) );
+		 *
+		 * @param {String} pageId id of dialog page.
+		 * @param {String} elementId id of UI element.
+		 * @returns {Object} The value of the UI element.
+		 */
+		getValueOf: function( pageId, elementId ) {
+			return this.getContentElement( pageId, elementId ).getValue();
+		},
+
+		/**
+		 * Sets the value of a dialog UI element.
+		 *
+		 *		dialogObj.setValueOf( 'tabId', 'elementId', 'Example' );
+		 *
+		 * @param {String} pageId id of the dialog page.
+		 * @param {String} elementId id of the UI element.
+		 * @param {Object} value The new value of the UI element.
+		 */
+		setValueOf: function( pageId, elementId, value ) {
+			return this.getContentElement( pageId, elementId ).setValue( value );
+		},
+
+		/**
+		 * Gets the UI element of a button in the dialog's button row.
+		 *
+		 *		@returns {CKEDITOR.ui.dialog.button} The button object.
+		 *
+		 * @param {String} id The id of the button.
+		 */
+		getButton: function( id ) {
+			return this._.buttons[ id ];
+		},
+
+		/**
+		 * Simulates a click to a dialog button in the dialog's button row.
+		 *
+		 * @returns The return value of the dialog's `click` event.
+		 *
+		 * @param {String} id The id of the button.
+		 */
+		click: function( id ) {
+			return this._.buttons[ id ].click();
+		},
+
+		/**
+		 * Disables a dialog button.
+		 *
+		 * @param {String} id The id of the button.
+		 */
+		disableButton: function( id ) {
+			return this._.buttons[ id ].disable();
+		},
+
+		/**
+		 * Enables a dialog button.
+		 *
+		 * @param {String} id The id of the button.
+		 */
+		enableButton: function( id ) {
+			return this._.buttons[ id ].enable();
+		},
+
+		/**
+		 * Gets the number of pages in the dialog.
+		 *
+		 * @returns {Number} Page count.
+		 */
+		getPageCount: function() {
+			return this._.pageCount;
+		},
+
+		/**
+		 * Gets the editor instance which opened this dialog.
+		 *
+		 * @returns {CKEDITOR.editor} Parent editor instances.
+		 */
+		getParentEditor: function() {
+			return this._.editor;
+		},
+
+		/**
+		 * Gets the element that was selected when opening the dialog, if any.
+		 *
+		 * @returns {CKEDITOR.dom.element} The element that was selected, or `null`.
+		 */
+		getSelectedElement: function() {
+			return this.getParentEditor().getSelection().getSelectedElement();
+		},
+
+		/**
+		 * Adds element to dialog's focusable list.
+		 *
+		 * @param {CKEDITOR.dom.element} element
+		 * @param {Number} [index]
+		 */
+		addFocusable: function( element, index ) {
+			if ( typeof index == 'undefined' ) {
+				index = this._.focusList.length;
+				this._.focusList.push( new Focusable( this, element, index ) );
+			} else {
+				this._.focusList.splice( index, 0, new Focusable( this, element, index ) );
+				for ( var i = index + 1; i < this._.focusList.length; i++ )
+					this._.focusList[ i ].focusIndex++;
+			}
+		}
+	};
+
+	CKEDITOR.tools.extend( CKEDITOR.dialog, {
+		/**
+		 * Registers a dialog.
+		 *
+		 *		// Full sample plugin, which does not only register a dialog window but also adds an item to the context menu.
+		 *		// To open the dialog window, choose "Open dialog" in the context menu.
+		 *		CKEDITOR.plugins.add( 'myplugin', {
+		 *			init: function( editor ) {
+		 *				editor.addCommand( 'mydialog',new CKEDITOR.dialogCommand( 'mydialog' ) );
+		 *
+		 *				if ( editor.contextMenu ) {
+		 *					editor.addMenuGroup( 'mygroup', 10 );
+		 *					editor.addMenuItem( 'My Dialog', {
+		 *						label: 'Open dialog',
+		 *						command: 'mydialog',
+		 *						group: 'mygroup'
+		 *					} );
+		 *					editor.contextMenu.addListener( function( element ) {
+		 *						return { 'My Dialog': CKEDITOR.TRISTATE_OFF };
+		 *					} );
+		 *				}
+		 *
+		 *				CKEDITOR.dialog.add( 'mydialog', function( api ) {
+		 *					// CKEDITOR.dialog.definition
+		 *					var dialogDefinition = {
+		 *						title: 'Sample dialog',
+		 *						minWidth: 390,
+		 *						minHeight: 130,
+		 *						contents: [
+		 *							{
+		 *								id: 'tab1',
+		 *								label: 'Label',
+		 *								title: 'Title',
+		 *								expand: true,
+		 *								padding: 0,
+		 *								elements: [
+		 *									{
+		 *										type: 'html',
+		 *										html: '<p>This is some sample HTML content.</p>'
+		 *									},
+		 *									{
+		 *										type: 'textarea',
+		 *										id: 'textareaId',
+		 *										rows: 4,
+		 *										cols: 40
+		 *									}
+		 *								]
+		 *							}
+		 *						],
+		 *						buttons: [ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ],
+		 *						onOk: function() {
+		 *							// "this" is now a CKEDITOR.dialog object.
+		 *							// Accessing dialog elements:
+		 *							var textareaObj = this.getContentElement( 'tab1', 'textareaId' );
+		 *							alert( "You have entered: " + textareaObj.getValue() );
+		 *						}
+		 *					};
+		 *
+		 *					return dialogDefinition;
+		 *				} );
+		 *			}
+		 *		} );
+		 *
+		 *		CKEDITOR.replace( 'editor1', { extraPlugins: 'myplugin' } );
+		 *
+		 * @static
+		 * @param {String} name The dialog's name.
+		 * @param {Function/String} dialogDefinition
+		 * A function returning the dialog's definition, or the URL to the `.js` file holding the function.
+		 * The function should accept an argument `editor` which is the current editor instance, and
+		 * return an object conforming to {@link CKEDITOR.dialog.definition}.
+		 * @see CKEDITOR.dialog.definition
+		 */
+		add: function( name, dialogDefinition ) {
+			// Avoid path registration from multiple instances override definition.
+			if ( !this._.dialogDefinitions[ name ] || typeof dialogDefinition == 'function' )
+				this._.dialogDefinitions[ name ] = dialogDefinition;
+		},
+
+		/**
+		 * @static
+		 * @todo
+		 */
+		exists: function( name ) {
+			return !!this._.dialogDefinitions[ name ];
+		},
+
+		/**
+		 * @static
+		 * @todo
+		 */
+		getCurrent: function() {
+			return CKEDITOR.dialog._.currentTop;
+		},
+
+		/**
+		 * Check whether tab wasn't removed by {@link CKEDITOR.config#removeDialogTabs}.
+		 *
+		 * @since 4.1
+		 * @static
+		 * @param {CKEDITOR.editor} editor
+		 * @param {String} dialogName
+		 * @param {String} tabName
+		 * @returns {Boolean}
+		 */
+		isTabEnabled: function( editor, dialogName, tabName ) {
+			var cfg = editor.config.removeDialogTabs;
+
+			return !( cfg && cfg.match( new RegExp( '(?:^|;)' + dialogName + ':' + tabName + '(?:$|;)', 'i' ) ) );
+		},
+
+		/**
+		 * The default OK button for dialogs. Fires the `ok` event and closes the dialog if the event succeeds.
+		 *
+		 * @static
+		 * @method
+		 */
+		okButton: ( function() {
+			var retval = function( editor, override ) {
+					override = override || {};
+					return CKEDITOR.tools.extend( {
+						id: 'ok',
+						type: 'button',
+						label: editor.lang.common.ok,
+						'class': 'cke_dialog_ui_button_ok',
+						onClick: function( evt ) {
+							var dialog = evt.data.dialog;
+							if ( dialog.fire( 'ok', { hide: true } ).hide !== false )
+								dialog.hide();
+						}
+					}, override, true );
+				};
+			retval.type = 'button';
+			retval.override = function( override ) {
+				return CKEDITOR.tools.extend( function( editor ) {
+					return retval( editor, override );
+				}, { type: 'button' }, true );
+			};
+			return retval;
+		} )(),
+
+		/**
+		 * The default cancel button for dialogs. Fires the `cancel` event and
+		 * closes the dialog if no UI element value changed.
+		 *
+		 * @static
+		 * @method
+		 */
+		cancelButton: ( function() {
+			var retval = function( editor, override ) {
+					override = override || {};
+					return CKEDITOR.tools.extend( {
+						id: 'cancel',
+						type: 'button',
+						label: editor.lang.common.cancel,
+						'class': 'cke_dialog_ui_button_cancel',
+						onClick: function( evt ) {
+							var dialog = evt.data.dialog;
+							if ( dialog.fire( 'cancel', { hide: true } ).hide !== false )
+								dialog.hide();
+						}
+					}, override, true );
+				};
+			retval.type = 'button';
+			retval.override = function( override ) {
+				return CKEDITOR.tools.extend( function( editor ) {
+					return retval( editor, override );
+				}, { type: 'button' }, true );
+			};
+			return retval;
+		} )(),
+
+		/**
+		 * Registers a dialog UI element.
+		 *
+		 * @static
+		 * @param {String} typeName The name of the UI element.
+		 * @param {Function} builder The function to build the UI element.
+		 */
+		addUIElement: function( typeName, builder ) {
+			this._.uiElementBuilders[ typeName ] = builder;
+		}
+	} );
+
+	CKEDITOR.dialog._ = {
+		uiElementBuilders: {},
+
+		dialogDefinitions: {},
+
+		currentTop: null,
+
+		currentZIndex: null
+	};
+
+	// "Inherit" (copy actually) from CKEDITOR.event.
+	CKEDITOR.event.implementOn( CKEDITOR.dialog );
+	CKEDITOR.event.implementOn( CKEDITOR.dialog.prototype );
+
+	var defaultDialogDefinition = {
+		resizable: CKEDITOR.DIALOG_RESIZE_BOTH,
+		minWidth: 600,
+		minHeight: 400,
+		buttons: [ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ]
+	};
+
+	// Tool function used to return an item from an array based on its id
+	// property.
+	var getById = function( array, id, recurse ) {
+			for ( var i = 0, item;
+			( item = array[ i ] ); i++ ) {
+				if ( item.id == id )
+					return item;
+				if ( recurse && item[ recurse ] ) {
+					var retval = getById( item[ recurse ], id, recurse );
+					if ( retval )
+						return retval;
+				}
+			}
+			return null;
+		};
+
+	// Tool function used to add an item into an array.
+	var addById = function( array, newItem, nextSiblingId, recurse, nullIfNotFound ) {
+			if ( nextSiblingId ) {
+				for ( var i = 0, item;
+				( item = array[ i ] ); i++ ) {
+					if ( item.id == nextSiblingId ) {
+						array.splice( i, 0, newItem );
+						return newItem;
+					}
+
+					if ( recurse && item[ recurse ] ) {
+						var retval = addById( item[ recurse ], newItem, nextSiblingId, recurse, true );
+						if ( retval )
+							return retval;
+					}
+				}
+
+				if ( nullIfNotFound )
+					return null;
+			}
+
+			array.push( newItem );
+			return newItem;
+		};
+
+	// Tool function used to remove an item from an array based on its id.
+	var removeById = function( array, id, recurse ) {
+			for ( var i = 0, item;
+			( item = array[ i ] ); i++ ) {
+				if ( item.id == id )
+					return array.splice( i, 1 );
+				if ( recurse && item[ recurse ] ) {
+					var retval = removeById( item[ recurse ], id, recurse );
+					if ( retval )
+						return retval;
+				}
+			}
+			return null;
+		};
+
+	/**
+	 * This class is not really part of the API. It is the `definition` property value
+	 * passed to `dialogDefinition` event handlers.
+	 *
+	 *		CKEDITOR.on( 'dialogDefinition', function( evt ) {
+	 *			var definition = evt.data.definition;
+	 *			var content = definition.getContents( 'page1' );
+	 * 			// ...
+	 *		} );
+	 *
+	 * @private
+	 * @class CKEDITOR.dialog.definitionObject
+	 * @extends CKEDITOR.dialog.definition
+	 * @constructor Creates a definitionObject class instance.
+	 */
+	var definitionObject = function( dialog, dialogDefinition ) {
+			// TODO : Check if needed.
+			this.dialog = dialog;
+
+			// Transform the contents entries in contentObjects.
+			var contents = dialogDefinition.contents;
+			for ( var i = 0, content;
+			( content = contents[ i ] ); i++ )
+				contents[ i ] = content && new contentObject( dialog, content );
+
+			CKEDITOR.tools.extend( this, dialogDefinition );
+		};
+
+	definitionObject.prototype = {
+		/**
+		 * Gets a content definition.
+		 *
+		 * @param {String} id The id of the content definition.
+		 * @returns {CKEDITOR.dialog.definition.content} The content definition matching id.
+		 */
+		getContents: function( id ) {
+			return getById( this.contents, id );
+		},
+
+		/**
+		 * Gets a button definition.
+		 *
+		 * @param {String} id The id of the button definition.
+		 * @returns {CKEDITOR.dialog.definition.button} The button definition matching id.
+		 */
+		getButton: function( id ) {
+			return getById( this.buttons, id );
+		},
+
+		/**
+		 * Adds a content definition object under this dialog definition.
+		 *
+		 * @param {CKEDITOR.dialog.definition.content} contentDefinition The
+		 * content definition.
+		 * @param {String} [nextSiblingId] The id of an existing content
+		 * definition which the new content definition will be inserted
+		 * before. Omit if the new content definition is to be inserted as
+		 * the last item.
+		 * @returns {CKEDITOR.dialog.definition.content} The inserted content definition.
+		 */
+		addContents: function( contentDefinition, nextSiblingId ) {
+			return addById( this.contents, contentDefinition, nextSiblingId );
+		},
+
+		/**
+		 * Adds a button definition object under this dialog definition.
+		 *
+		 * @param {CKEDITOR.dialog.definition.button} buttonDefinition The
+		 * button definition.
+		 * @param {String} [nextSiblingId] The id of an existing button
+		 * definition which the new button definition will be inserted
+		 * before. Omit if the new button definition is to be inserted as
+		 * the last item.
+		 * @returns {CKEDITOR.dialog.definition.button} The inserted button definition.
+		 */
+		addButton: function( buttonDefinition, nextSiblingId ) {
+			return addById( this.buttons, buttonDefinition, nextSiblingId );
+		},
+
+		/**
+		 * Removes a content definition from this dialog definition.
+		 *
+		 * @param {String} id The id of the content definition to be removed.
+		 * @returns {CKEDITOR.dialog.definition.content} The removed content definition.
+		 */
+		removeContents: function( id ) {
+			removeById( this.contents, id );
+		},
+
+		/**
+		 * Removes a button definition from the dialog definition.
+		 *
+		 * @param {String} id The id of the button definition to be removed.
+		 * @returns {CKEDITOR.dialog.definition.button} The removed button definition.
+		 */
+		removeButton: function( id ) {
+			removeById( this.buttons, id );
+		}
+	};
+
+	/**
+	 * This class is not really part of the API. It is the template of the
+	 * objects representing content pages inside the
+	 * CKEDITOR.dialog.definitionObject.
+	 *
+	 *		CKEDITOR.on( 'dialogDefinition', function( evt ) {
+	 *			var definition = evt.data.definition;
+	 *			var content = definition.getContents( 'page1' );
+	 *			content.remove( 'textInput1' );
+	 *			// ...
+	 *		} );
+	 *
+	 * @private
+	 * @class CKEDITOR.dialog.definition.contentObject
+	 * @constructor Creates a contentObject class instance.
+	 */
+	function contentObject( dialog, contentDefinition ) {
+		this._ = {
+			dialog: dialog
+		};
+
+		CKEDITOR.tools.extend( this, contentDefinition );
+	}
+
+	contentObject.prototype = {
+		/**
+		 * Gets a UI element definition under the content definition.
+		 *
+		 * @param {String} id The id of the UI element definition.
+		 * @returns {CKEDITOR.dialog.definition.uiElement}
+		 */
+		get: function( id ) {
+			return getById( this.elements, id, 'children' );
+		},
+
+		/**
+		 * Adds a UI element definition to the content definition.
+		 *
+		 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition The
+		 * UI elemnet definition to be added.
+		 * @param {String} nextSiblingId The id of an existing UI element
+		 * definition which the new UI element definition will be inserted
+		 * before. Omit if the new button definition is to be inserted as
+		 * the last item.
+		 * @returns {CKEDITOR.dialog.definition.uiElement} The element definition inserted.
+		 */
+		add: function( elementDefinition, nextSiblingId ) {
+			return addById( this.elements, elementDefinition, nextSiblingId, 'children' );
+		},
+
+		/**
+		 * Removes a UI element definition from the content definition.
+		 *
+		 * @param {String} id The id of the UI element definition to be removed.
+		 * @returns {CKEDITOR.dialog.definition.uiElement} The element definition removed.
+		 */
+		remove: function( id ) {
+			removeById( this.elements, id, 'children' );
+		}
+	};
+
+	function initDragAndDrop( dialog ) {
+		var lastCoords = null,
+			abstractDialogCoords = null,
+			element = dialog.getElement().getFirst(),
+			editor = dialog.getParentEditor(),
+			magnetDistance = editor.config.dialog_magnetDistance,
+			margins = CKEDITOR.skin.margins || [ 0, 0, 0, 0 ];
+
+		if ( typeof magnetDistance == 'undefined' )
+			magnetDistance = 20;
+
+		function mouseMoveHandler( evt ) {
+			var dialogSize = dialog.getSize(),
+				viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize(),
+				x = evt.data.$.screenX,
+				y = evt.data.$.screenY,
+				dx = x - lastCoords.x,
+				dy = y - lastCoords.y,
+				realX, realY;
+
+			lastCoords = { x: x, y: y };
+			abstractDialogCoords.x += dx;
+			abstractDialogCoords.y += dy;
+
+			if ( abstractDialogCoords.x + margins[ 3 ] < magnetDistance )
+				realX = -margins[ 3 ];
+			else if ( abstractDialogCoords.x - margins[ 1 ] > viewPaneSize.width - dialogSize.width - magnetDistance )
+				realX = viewPaneSize.width - dialogSize.width + ( editor.lang.dir == 'rtl' ? 0 : margins[ 1 ] );
+			else
+				realX = abstractDialogCoords.x;
+
+			if ( abstractDialogCoords.y + margins[ 0 ] < magnetDistance )
+				realY = -margins[ 0 ];
+			else if ( abstractDialogCoords.y - margins[ 2 ] > viewPaneSize.height - dialogSize.height - magnetDistance )
+				realY = viewPaneSize.height - dialogSize.height + margins[ 2 ];
+			else
+				realY = abstractDialogCoords.y;
+
+			dialog.move( realX, realY, 1 );
+
+			evt.data.preventDefault();
+		}
+
+		function mouseUpHandler( evt ) {
+			CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
+			CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
+
+			if ( CKEDITOR.env.ie6Compat ) {
+				var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
+				coverDoc.removeListener( 'mousemove', mouseMoveHandler );
+				coverDoc.removeListener( 'mouseup', mouseUpHandler );
+			}
+		}
+
+		dialog.parts.title.on( 'mousedown', function( evt ) {
+			lastCoords = { x: evt.data.$.screenX, y: evt.data.$.screenY };
+
+			CKEDITOR.document.on( 'mousemove', mouseMoveHandler );
+			CKEDITOR.document.on( 'mouseup', mouseUpHandler );
+			abstractDialogCoords = dialog.getPosition();
+
+			if ( CKEDITOR.env.ie6Compat ) {
+				var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
+				coverDoc.on( 'mousemove', mouseMoveHandler );
+				coverDoc.on( 'mouseup', mouseUpHandler );
+			}
+
+			evt.data.preventDefault();
+		}, dialog );
+	}
+
+	function initResizeHandles( dialog ) {
+		var def = dialog.definition,
+			resizable = def.resizable;
+
+		if ( resizable == CKEDITOR.DIALOG_RESIZE_NONE )
+			return;
+
+		var editor = dialog.getParentEditor();
+		var wrapperWidth, wrapperHeight, viewSize, origin, startSize, dialogCover;
+
+		var mouseDownFn = CKEDITOR.tools.addFunction( function( $event ) {
+			startSize = dialog.getSize();
+
+			var content = dialog.parts.contents,
+				iframeDialog = content.$.getElementsByTagName( 'iframe' ).length;
+
+			// Shim to help capturing "mousemove" over iframe.
+			if ( iframeDialog ) {
+				dialogCover = CKEDITOR.dom.element.createFromHtml( '<div class="cke_dialog_resize_cover" style="height: 100%; position: absolute; width: 100%;"></div>' );
+				content.append( dialogCover );
+			}
+
+			// Calculate the offset between content and chrome size.
+			wrapperHeight = startSize.height - dialog.parts.contents.getSize( 'height', !( CKEDITOR.env.gecko || CKEDITOR.env.opera || CKEDITOR.env.ie && CKEDITOR.env.quirks ) );
+			wrapperWidth = startSize.width - dialog.parts.contents.getSize( 'width', 1 );
+
+			origin = { x: $event.screenX, y: $event.screenY };
+
+			viewSize = CKEDITOR.document.getWindow().getViewPaneSize();
+
+			CKEDITOR.document.on( 'mousemove', mouseMoveHandler );
+			CKEDITOR.document.on( 'mouseup', mouseUpHandler );
+
+			if ( CKEDITOR.env.ie6Compat ) {
+				var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
+				coverDoc.on( 'mousemove', mouseMoveHandler );
+				coverDoc.on( 'mouseup', mouseUpHandler );
+			}
+
+			$event.preventDefault && $event.preventDefault();
+		} );
+
+		// Prepend the grip to the dialog.
+		dialog.on( 'load', function() {
+			var direction = '';
+			if ( resizable == CKEDITOR.DIALOG_RESIZE_WIDTH )
+				direction = ' cke_resizer_horizontal';
+			else if ( resizable == CKEDITOR.DIALOG_RESIZE_HEIGHT )
+				direction = ' cke_resizer_vertical';
+			var resizer = CKEDITOR.dom.element.createFromHtml(
+				'<div' +
+				' class="cke_resizer' + direction + ' cke_resizer_' + editor.lang.dir + '"' +
+				' title="' + CKEDITOR.tools.htmlEncode( editor.lang.common.resize ) + '"' +
+				' onmousedown="CKEDITOR.tools.callFunction(' + mouseDownFn + ', event )">' +
+				// BLACK LOWER RIGHT TRIANGLE (ltr)
+				// BLACK LOWER LEFT TRIANGLE (rtl)
+				( editor.lang.dir == 'ltr' ? '\u25E2' : '\u25E3' ) +
+				'</div>' );
+			dialog.parts.footer.append( resizer, 1 );
+		} );
+		editor.on( 'destroy', function() {
+			CKEDITOR.tools.removeFunction( mouseDownFn );
+		} );
+
+		function mouseMoveHandler( evt ) {
+			var rtl = editor.lang.dir == 'rtl',
+				dx = ( evt.data.$.screenX - origin.x ) * ( rtl ? -1 : 1 ),
+				dy = evt.data.$.screenY - origin.y,
+				width = startSize.width,
+				height = startSize.height,
+				internalWidth = width + dx * ( dialog._.moved ? 1 : 2 ),
+				internalHeight = height + dy * ( dialog._.moved ? 1 : 2 ),
+				element = dialog._.element.getFirst(),
+				right = rtl && element.getComputedStyle( 'right' ),
+				position = dialog.getPosition();
+
+			if ( position.y + internalHeight > viewSize.height )
+				internalHeight = viewSize.height - position.y;
+
+			if ( ( rtl ? right : position.x ) + internalWidth > viewSize.width )
+				internalWidth = viewSize.width - ( rtl ? right : position.x );
+
+			// Make sure the dialog will not be resized to the wrong side when it's in the leftmost position for RTL.
+			if ( ( resizable == CKEDITOR.DIALOG_RESIZE_WIDTH || resizable == CKEDITOR.DIALOG_RESIZE_BOTH ) )
+				width = Math.max( def.minWidth || 0, internalWidth - wrapperWidth );
+
+			if ( resizable == CKEDITOR.DIALOG_RESIZE_HEIGHT || resizable == CKEDITOR.DIALOG_RESIZE_BOTH )
+				height = Math.max( def.minHeight || 0, internalHeight - wrapperHeight );
+
+			dialog.resize( width, height );
+
+			if ( !dialog._.moved )
+				dialog.layout();
+
+			evt.data.preventDefault();
+		}
+
+		function mouseUpHandler() {
+			CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
+			CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
+
+			if ( dialogCover ) {
+				dialogCover.remove();
+				dialogCover = null;
+			}
+
+			if ( CKEDITOR.env.ie6Compat ) {
+				var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
+				coverDoc.removeListener( 'mouseup', mouseUpHandler );
+				coverDoc.removeListener( 'mousemove', mouseMoveHandler );
+			}
+		}
+	}
+
+	var resizeCover;
+	// Caching resuable covers and allowing only one cover
+	// on screen.
+	var covers = {},
+		currentCover;
+
+	function cancelEvent( ev ) {
+		ev.data.preventDefault( 1 );
+	}
+
+	function showCover( editor ) {
+		var win = CKEDITOR.document.getWindow();
+		var config = editor.config,
+			backgroundColorStyle = config.dialog_backgroundCoverColor || 'white',
+			backgroundCoverOpacity = config.dialog_backgroundCoverOpacity,
+			baseFloatZIndex = config.baseFloatZIndex,
+			coverKey = CKEDITOR.tools.genKey( backgroundColorStyle, backgroundCoverOpacity, baseFloatZIndex ),
+			coverElement = covers[ coverKey ];
+
+		if ( !coverElement ) {
+			var html = [
+				'<div tabIndex="-1" style="position: ', ( CKEDITOR.env.ie6Compat ? 'absolute' : 'fixed' ),
+				'; z-index: ', baseFloatZIndex,
+				'; top: 0px; left: 0px; ',
+				( !CKEDITOR.env.ie6Compat ? 'background-color: ' + backgroundColorStyle : '' ),
+				'" class="cke_dialog_background_cover">'
+				];
+
+			if ( CKEDITOR.env.ie6Compat ) {
+				// Support for custom document.domain in IE.
+				var iframeHtml = '<html><body style=\\\'background-color:' + backgroundColorStyle + ';\\\'></body></html>';
+
+				html.push( '<iframe' +
+					' hidefocus="true"' +
+					' frameborder="0"' +
+					' id="cke_dialog_background_iframe"' +
+					' src="javascript:' );
+
+				html.push( 'void((function(){' + encodeURIComponent(
+					'document.open();' +
+					// Support for custom document.domain in IE.
+					'(' + CKEDITOR.tools.fixDomain + ')();' +
+					'document.write( \'' + iframeHtml + '\' );' +
+					'document.close();'
+				) + '})())' );
+
+				html.push( '"' +
+					' style="' +
+						'position:absolute;' +
+						'left:0;' +
+						'top:0;' +
+						'width:100%;' +
+						'height: 100%;' +
+						'filter: progid:DXImageTransform.Microsoft.Alpha(opacity=0)">' +
+					'</iframe>' );
+			}
+
+			html.push( '</div>' );
+
+			coverElement = CKEDITOR.dom.element.createFromHtml( html.join( '' ) );
+			coverElement.setOpacity( backgroundCoverOpacity != undefined ? backgroundCoverOpacity : 0.5 );
+
+			coverElement.on( 'keydown', cancelEvent );
+			coverElement.on( 'keypress', cancelEvent );
+			coverElement.on( 'keyup', cancelEvent );
+
+			coverElement.appendTo( CKEDITOR.document.getBody() );
+			covers[ coverKey ] = coverElement;
+		} else
+			coverElement.show();
+
+		// Makes the dialog cover a focus holder as well.
+		editor.focusManager.add( coverElement );
+
+		currentCover = coverElement;
+		var resizeFunc = function() {
+				var size = win.getViewPaneSize();
+				coverElement.setStyles( {
+					width: size.width + 'px',
+					height: size.height + 'px'
+				} );
+			};
+
+		var scrollFunc = function() {
+				var pos = win.getScrollPosition(),
+					cursor = CKEDITOR.dialog._.currentTop;
+				coverElement.setStyles( {
+					left: pos.x + 'px',
+					top: pos.y + 'px'
+				} );
+
+				if ( cursor ) {
+					do {
+						var dialogPos = cursor.getPosition();
+						cursor.move( dialogPos.x, dialogPos.y );
+					} while ( ( cursor = cursor._.parentDialog ) );
+				}
+			};
+
+		resizeCover = resizeFunc;
+		win.on( 'resize', resizeFunc );
+		resizeFunc();
+		// Using Safari/Mac, focus must be kept where it is (#7027)
+		if ( !( CKEDITOR.env.mac && CKEDITOR.env.webkit ) )
+			coverElement.focus();
+
+		if ( CKEDITOR.env.ie6Compat ) {
+			// IE BUG: win.$.onscroll assignment doesn't work.. it must be window.onscroll.
+			// So we need to invent a really funny way to make it work.
+			var myScrollHandler = function() {
+					scrollFunc();
+					arguments.callee.prevScrollHandler.apply( this, arguments );
+				};
+			win.$.setTimeout( function() {
+				myScrollHandler.prevScrollHandler = window.onscroll ||
+				function() {};
+				window.onscroll = myScrollHandler;
+			}, 0 );
+			scrollFunc();
+		}
+	}
+
+	function hideCover( editor ) {
+		if ( !currentCover )
+			return;
+
+		editor.focusManager.remove( currentCover );
+		var win = CKEDITOR.document.getWindow();
+		currentCover.hide();
+		win.removeListener( 'resize', resizeCover );
+
+		if ( CKEDITOR.env.ie6Compat ) {
+			win.$.setTimeout( function() {
+				var prevScrollHandler = window.onscroll && window.onscroll.prevScrollHandler;
+				window.onscroll = prevScrollHandler || null;
+			}, 0 );
+		}
+		resizeCover = null;
+	}
+
+	function removeCovers() {
+		for ( var coverId in covers )
+			covers[ coverId ].remove();
+		covers = {};
+	}
+
+	var accessKeyProcessors = {};
+
+	var accessKeyDownHandler = function( evt ) {
+			var ctrl = evt.data.$.ctrlKey || evt.data.$.metaKey,
+				alt = evt.data.$.altKey,
+				shift = evt.data.$.shiftKey,
+				key = String.fromCharCode( evt.data.$.keyCode ),
+				keyProcessor = accessKeyProcessors[ ( ctrl ? 'CTRL+' : '' ) + ( alt ? 'ALT+' : '' ) + ( shift ? 'SHIFT+' : '' ) + key ];
+
+			if ( !keyProcessor || !keyProcessor.length )
+				return;
+
+			keyProcessor = keyProcessor[ keyProcessor.length - 1 ];
+			keyProcessor.keydown && keyProcessor.keydown.call( keyProcessor.uiElement, keyProcessor.dialog, keyProcessor.key );
+			evt.data.preventDefault();
+		};
+
+	var accessKeyUpHandler = function( evt ) {
+			var ctrl = evt.data.$.ctrlKey || evt.data.$.metaKey,
+				alt = evt.data.$.altKey,
+				shift = evt.data.$.shiftKey,
+				key = String.fromCharCode( evt.data.$.keyCode ),
+				keyProcessor = accessKeyProcessors[ ( ctrl ? 'CTRL+' : '' ) + ( alt ? 'ALT+' : '' ) + ( shift ? 'SHIFT+' : '' ) + key ];
+
+			if ( !keyProcessor || !keyProcessor.length )
+				return;
+
+			keyProcessor = keyProcessor[ keyProcessor.length - 1 ];
+			if ( keyProcessor.keyup ) {
+				keyProcessor.keyup.call( keyProcessor.uiElement, keyProcessor.dialog, keyProcessor.key );
+				evt.data.preventDefault();
+			}
+		};
+
+	var registerAccessKey = function( uiElement, dialog, key, downFunc, upFunc ) {
+			var procList = accessKeyProcessors[ key ] || ( accessKeyProcessors[ key ] = [] );
+			procList.push( {
+				uiElement: uiElement,
+				dialog: dialog,
+				key: key,
+				keyup: upFunc || uiElement.accessKeyUp,
+				keydown: downFunc || uiElement.accessKeyDown
+			} );
+		};
+
+	var unregisterAccessKey = function( obj ) {
+			for ( var i in accessKeyProcessors ) {
+				var list = accessKeyProcessors[ i ];
+				for ( var j = list.length - 1; j >= 0; j-- ) {
+					if ( list[ j ].dialog == obj || list[ j ].uiElement == obj )
+						list.splice( j, 1 );
+				}
+				if ( list.length === 0 )
+					delete accessKeyProcessors[ i ];
+			}
+		};
+
+	var tabAccessKeyUp = function( dialog, key ) {
+			if ( dialog._.accessKeyMap[ key ] )
+				dialog.selectPage( dialog._.accessKeyMap[ key ] );
+		};
+
+	var tabAccessKeyDown = function( dialog, key ) {};
+
+	( function() {
+		CKEDITOR.ui.dialog = {
+			/**
+			 * The base class of all dialog UI elements.
+			 *
+			 * @class CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a uiElement class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition Element
+			 * definition.
+			 *
+			 * Accepted fields:
+			 *
+			 * * `id` (Required) The id of the UI element. See {@link CKEDITOR.dialog#getContentElement}.
+			 * * `type` (Required) The type of the UI element. The
+			 *     value to this field specifies which UI element class will be used to
+			 *     generate the final widget.
+			 * * `title` (Optional) The popup tooltip for the UI
+			 *     element.
+			 * * `hidden` (Optional) A flag that tells if the element
+			 *     should be initially visible.
+			 * * `className` (Optional) Additional CSS class names
+			 *     to add to the UI element. Separated by space.
+			 * * `style` (Optional) Additional CSS inline styles
+			 *     to add to the UI element. A semicolon (;) is required after the last
+			 *     style declaration.
+			 * * `accessKey` (Optional) The alphanumeric access key
+			 *     for this element. Access keys are automatically prefixed by CTRL.
+			 * * `on*` (Optional) Any UI element definition field that
+			 *     starts with `on` followed immediately by a capital letter and
+			 *     probably more letters is an event handler. Event handlers may be further
+			 *     divided into registered event handlers and DOM event handlers. Please
+			 *     refer to {@link CKEDITOR.ui.dialog.uiElement#registerEvents} and
+			 *     {@link CKEDITOR.ui.dialog.uiElement#eventProcessors} for more information.
+			 *
+			 * @param {Array} htmlList
+			 * List of HTML code to be added to the dialog's content area.
+			 * @param {Function/String} [nodeNameArg='div']
+			 * A function returning a string, or a simple string for the node name for
+			 * the root DOM node.
+			 * @param {Function/Object} [stylesArg={}]
+			 * A function returning an object, or a simple object for CSS styles applied
+			 * to the DOM node.
+			 * @param {Function/Object} [attributesArg={}]
+			 * A fucntion returning an object, or a simple object for attributes applied
+			 * to the DOM node.
+			 * @param {Function/String} [contentsArg='']
+			 * A function returning a string, or a simple string for the HTML code inside
+			 * the root DOM node. Default is empty string.
+			 */
+			uiElement: function( dialog, elementDefinition, htmlList, nodeNameArg, stylesArg, attributesArg, contentsArg ) {
+				if ( arguments.length < 4 )
+					return;
+
+				var nodeName = ( nodeNameArg.call ? nodeNameArg( elementDefinition ) : nodeNameArg ) || 'div',
+					html = [ '<', nodeName, ' ' ],
+					styles = ( stylesArg && stylesArg.call ? stylesArg( elementDefinition ) : stylesArg ) || {},
+					attributes = ( attributesArg && attributesArg.call ? attributesArg( elementDefinition ) : attributesArg ) || {},
+					innerHTML = ( contentsArg && contentsArg.call ? contentsArg.call( this, dialog, elementDefinition ) : contentsArg ) || '',
+					domId = this.domId = attributes.id || CKEDITOR.tools.getNextId() + '_uiElement',
+					id = this.id = elementDefinition.id,
+					i;
+
+				if ( elementDefinition.requiredContent && !dialog.getParentEditor().filter.check( elementDefinition.requiredContent ) ) {
+					styles.display = 'none';
+					this.notAllowed = true;
+				}
+
+				// Set the id, a unique id is required for getElement() to work.
+				attributes.id = domId;
+
+				// Set the type and definition CSS class names.
+				var classes = {};
+				if ( elementDefinition.type )
+					classes[ 'cke_dialog_ui_' + elementDefinition.type ] = 1;
+				if ( elementDefinition.className )
+					classes[ elementDefinition.className ] = 1;
+				if ( elementDefinition.disabled )
+					classes[ 'cke_disabled' ] = 1;
+
+				var attributeClasses = ( attributes[ 'class' ] && attributes[ 'class' ].split ) ? attributes[ 'class' ].split( ' ' ) : [];
+				for ( i = 0; i < attributeClasses.length; i++ ) {
+					if ( attributeClasses[ i ] )
+						classes[ attributeClasses[ i ] ] = 1;
+				}
+				var finalClasses = [];
+				for ( i in classes )
+					finalClasses.push( i );
+				attributes[ 'class' ] = finalClasses.join( ' ' );
+
+				// Set the popup tooltop.
+				if ( elementDefinition.title )
+					attributes.title = elementDefinition.title;
+
+				// Write the inline CSS styles.
+				var styleStr = ( elementDefinition.style || '' ).split( ';' );
+
+				// Element alignment support.
+				if ( elementDefinition.align ) {
+					var align = elementDefinition.align;
+					styles[ 'margin-left' ] = align == 'left' ? 0 : 'auto';
+					styles[ 'margin-right' ] = align == 'right' ? 0 : 'auto';
+				}
+
+				for ( i in styles )
+					styleStr.push( i + ':' + styles[ i ] );
+				if ( elementDefinition.hidden )
+					styleStr.push( 'display:none' );
+				for ( i = styleStr.length - 1; i >= 0; i-- ) {
+					if ( styleStr[ i ] === '' )
+						styleStr.splice( i, 1 );
+				}
+				if ( styleStr.length > 0 )
+					attributes.style = ( attributes.style ? ( attributes.style + '; ' ) : '' ) + styleStr.join( '; ' );
+
+				// Write the attributes.
+				for ( i in attributes )
+					html.push( i + '="' + CKEDITOR.tools.htmlEncode( attributes[ i ] ) + '" ' );
+
+				// Write the content HTML.
+				html.push( '>', innerHTML, '</', nodeName, '>' );
+
+				// Add contents to the parent HTML array.
+				htmlList.push( html.join( '' ) );
+
+				( this._ || ( this._ = {} ) ).dialog = dialog;
+
+				// Override isChanged if it is defined in element definition.
+				if ( typeof( elementDefinition.isChanged ) == 'boolean' )
+					this.isChanged = function() {
+					return elementDefinition.isChanged;
+				};
+				if ( typeof( elementDefinition.isChanged ) == 'function' )
+					this.isChanged = elementDefinition.isChanged;
+
+				// Overload 'get(set)Value' on definition.
+				if ( typeof( elementDefinition.setValue ) == 'function' ) {
+					this.setValue = CKEDITOR.tools.override( this.setValue, function( org ) {
+						return function( val ) {
+							org.call( this, elementDefinition.setValue.call( this, val ) );
+						};
+					} );
+				}
+
+				if ( typeof( elementDefinition.getValue ) == 'function' ) {
+					this.getValue = CKEDITOR.tools.override( this.getValue, function( org ) {
+						return function() {
+							return elementDefinition.getValue.call( this, org.call( this ) );
+						};
+					} );
+				}
+
+				// Add events.
+				CKEDITOR.event.implementOn( this );
+
+				this.registerEvents( elementDefinition );
+				if ( this.accessKeyUp && this.accessKeyDown && elementDefinition.accessKey )
+					registerAccessKey( this, dialog, 'CTRL+' + elementDefinition.accessKey );
+
+				var me = this;
+				dialog.on( 'load', function() {
+					var input = me.getInputElement();
+					if ( input ) {
+						var focusClass = me.type in { 'checkbox': 1, 'ratio': 1 } && CKEDITOR.env.ie && CKEDITOR.env.version < 8 ? 'cke_dialog_ui_focused' : '';
+						input.on( 'focus', function() {
+							dialog._.tabBarMode = false;
+							dialog._.hasFocus = true;
+							me.fire( 'focus' );
+							focusClass && this.addClass( focusClass );
+
+						} );
+
+						input.on( 'blur', function() {
+							me.fire( 'blur' );
+							focusClass && this.removeClass( focusClass );
+						} );
+					}
+				} );
+
+				// Completes this object with everything we have in the
+				// definition.
+				CKEDITOR.tools.extend( this, elementDefinition );
+
+				// Register the object as a tab focus if it can be included.
+				if ( this.keyboardFocusable ) {
+					this.tabIndex = elementDefinition.tabIndex || 0;
+
+					this.focusIndex = dialog._.focusList.push( this ) - 1;
+					this.on( 'focus', function() {
+						dialog._.currentFocusIndex = me.focusIndex;
+					} );
+				}
+			},
+
+			/**
+			 * Horizontal layout box for dialog UI elements, auto-expends to available width of container.
+			 *
+			 * @class CKEDITOR.ui.dialog.hbox
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a hbox class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {Array} childObjList
+			 * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
+			 * @param {Array} childHtmlList
+			 * Array of HTML code that correspond to the HTML output of all the
+			 * objects in childObjList.
+			 * @param {Array} htmlList
+			 * Array of HTML code that this element will output to.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `widths` (Optional) The widths of child cells.
+			 * * `height` (Optional) The height of the layout.
+			 * * `padding` (Optional) The padding width inside child cells.
+			 * * `align` (Optional) The alignment of the whole layout.
+			 */
+			hbox: function( dialog, childObjList, childHtmlList, htmlList, elementDefinition ) {
+				if ( arguments.length < 4 )
+					return;
+
+				this._ || ( this._ = {} );
+
+				var children = this._.children = childObjList,
+					widths = elementDefinition && elementDefinition.widths || null,
+					height = elementDefinition && elementDefinition.height || null,
+					styles = {},
+					i;
+				/** @ignore */
+				var innerHTML = function() {
+						var html = [ '<tbody><tr class="cke_dialog_ui_hbox">' ];
+						for ( i = 0; i < childHtmlList.length; i++ ) {
+							var className = 'cke_dialog_ui_hbox_child',
+								styles = [];
+							if ( i === 0 )
+								className = 'cke_dialog_ui_hbox_first';
+							if ( i == childHtmlList.length - 1 )
+								className = 'cke_dialog_ui_hbox_last';
+							html.push( '<td class="', className, '" role="presentation" ' );
+							if ( widths ) {
+								if ( widths[ i ] )
+									styles.push( 'width:' + cssLength( widths[ i ] ) );
+							} else
+								styles.push( 'width:' + Math.floor( 100 / childHtmlList.length ) + '%' );
+							if ( height )
+								styles.push( 'height:' + cssLength( height ) );
+							if ( elementDefinition && elementDefinition.padding != undefined )
+								styles.push( 'padding:' + cssLength( elementDefinition.padding ) );
+							// In IE Quirks alignment has to be done on table cells. (#7324)
+							if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && children[ i ].align )
+								styles.push( 'text-align:' + children[ i ].align );
+							if ( styles.length > 0 )
+								html.push( 'style="' + styles.join( '; ' ) + '" ' );
+							html.push( '>', childHtmlList[ i ], '</td>' );
+						}
+						html.push( '</tr></tbody>' );
+						return html.join( '' );
+					};
+
+				var attribs = { role: 'presentation' };
+				elementDefinition && elementDefinition.align && ( attribs.align = elementDefinition.align );
+
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition || { type: 'hbox' }, htmlList, 'table', styles, attribs, innerHTML );
+			},
+
+			/**
+			 * Vertical layout box for dialog UI elements.
+			 *
+			 * @class CKEDITOR.ui.dialog.vbox
+			 * @extends CKEDITOR.ui.dialog.hbox
+			 * @constructor Creates a vbox class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {Array} childObjList
+			 * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
+			 * @param {Array} childHtmlList
+			 * Array of HTML code that correspond to the HTML output of all the
+			 * objects in childObjList.
+			 * @param {Array} htmlList Array of HTML code that this element will output to.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `width` (Optional) The width of the layout.
+			 * * `heights` (Optional) The heights of individual cells.
+			 * * `align` (Optional) The alignment of the layout.
+			 * * `padding` (Optional) The padding width inside child cells.
+			 * * `expand` (Optional) Whether the layout should expand
+			 *     vertically to fill its container.
+			 */
+			vbox: function( dialog, childObjList, childHtmlList, htmlList, elementDefinition ) {
+				if ( arguments.length < 3 )
+					return;
+
+				this._ || ( this._ = {} );
+
+				var children = this._.children = childObjList,
+					width = elementDefinition && elementDefinition.width || null,
+					heights = elementDefinition && elementDefinition.heights || null;
+				/** @ignore */
+				var innerHTML = function() {
+						var html = [ '<table role="presentation" cellspacing="0" border="0" ' ];
+						html.push( 'style="' );
+						if ( elementDefinition && elementDefinition.expand )
+							html.push( 'height:100%;' );
+						html.push( 'width:' + cssLength( width || '100%' ), ';' );
+
+						// (#10123) Temp fix for dialog broken layout in latest webkit.
+						if ( CKEDITOR.env.webkit )
+							html.push( 'float:none;' );
+
+						html.push( '"' );
+						html.push( 'align="', CKEDITOR.tools.htmlEncode(
+						( elementDefinition && elementDefinition.align ) || ( dialog.getParentEditor().lang.dir == 'ltr' ? 'left' : 'right' ) ), '" ' );
+
+						html.push( '><tbody>' );
+						for ( var i = 0; i < childHtmlList.length; i++ ) {
+							var styles = [];
+							html.push( '<tr><td role="presentation" ' );
+							if ( width )
+								styles.push( 'width:' + cssLength( width || '100%' ) );
+							if ( heights )
+								styles.push( 'height:' + cssLength( heights[ i ] ) );
+							else if ( elementDefinition && elementDefinition.expand )
+								styles.push( 'height:' + Math.floor( 100 / childHtmlList.length ) + '%' );
+							if ( elementDefinition && elementDefinition.padding != undefined )
+								styles.push( 'padding:' + cssLength( elementDefinition.padding ) );
+							// In IE Quirks alignment has to be done on table cells. (#7324)
+							if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && children[ i ].align )
+								styles.push( 'text-align:' + children[ i ].align );
+							if ( styles.length > 0 )
+								html.push( 'style="', styles.join( '; ' ), '" ' );
+							html.push( ' class="cke_dialog_ui_vbox_child">', childHtmlList[ i ], '</td></tr>' );
+						}
+						html.push( '</tbody></table>' );
+						return html.join( '' );
+					};
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition || { type: 'vbox' }, htmlList, 'div', null, { role: 'presentation' }, innerHTML );
+			}
+		};
+	} )();
+
+	/** @class CKEDITOR.ui.dialog.uiElement */
+	CKEDITOR.ui.dialog.uiElement.prototype = {
+		/**
+		 * Gets the root DOM element of this dialog UI object.
+		 *
+		 *		uiElement.getElement().hide();
+		 *
+		 * @returns {CKEDITOR.dom.element} Root DOM element of UI object.
+		 */
+		getElement: function() {
+			return CKEDITOR.document.getById( this.domId );
+		},
+
+		/**
+		 * Gets the DOM element that the user inputs values.
+		 *
+		 * This function is used by {@link #setValue}, {@link #getValue} and {@link #focus}. It should
+		 * be overrided in child classes where the input element isn't the root
+		 * element.
+		 *
+		 *		var rawValue = textInput.getInputElement().$.value;
+		 *
+		 * @returns {CKEDITOR.dom.element} The element where the user input values.
+		 */
+		getInputElement: function() {
+			return this.getElement();
+		},
+
+		/**
+		 * Gets the parent dialog object containing this UI element.
+		 *
+		 *		var dialog = uiElement.getDialog();
+		 *
+		 * @returns {CKEDITOR.dialog} Parent dialog object.
+		 */
+		getDialog: function() {
+			return this._.dialog;
+		},
+
+		/**
+		 * Sets the value of this dialog UI object.
+		 *
+		 *		uiElement.setValue( 'Dingo' );
+		 *
+		 * @chainable
+		 * @param {Object} value The new value.
+		 * @param {Boolean} noChangeEvent Internal commit, to supress `change` event on this element.
+		 */
+		setValue: function( value, noChangeEvent ) {
+			this.getInputElement().setValue( value );
+			!noChangeEvent && this.fire( 'change', { value: value } );
+			return this;
+		},
+
+		/**
+		 * Gets the current value of this dialog UI object.
+		 *
+		 *		var myValue = uiElement.getValue();
+		 *
+		 * @returns {Object} The current value.
+		 */
+		getValue: function() {
+			return this.getInputElement().getValue();
+		},
+
+		/**
+		 * Tells whether the UI object's value has changed.
+		 *
+		 *		if ( uiElement.isChanged() )
+		 *			confirm( 'Value changed! Continue?' );
+		 *
+		 * @returns {Boolean} `true` if changed, `false` if not changed.
+		 */
+		isChanged: function() {
+			// Override in input classes.
+			return false;
+		},
+
+		/**
+		 * Selects the parent tab of this element. Usually called by focus() or overridden focus() methods.
+		 *
+		 *		focus : function() {
+		 *			this.selectParentTab();
+		 *			// do something else.
+		 *		}
+		 *
+		 * @chainable
+		 */
+		selectParentTab: function() {
+			var element = this.getInputElement(),
+				cursor = element,
+				tabId;
+			while ( ( cursor = cursor.getParent() ) && cursor.$.className.search( 'cke_dialog_page_contents' ) == -1 ) {
+				/*jsl:pass*/
+			}
+
+			// Some widgets don't have parent tabs (e.g. OK and Cancel buttons).
+			if ( !cursor )
+				return this;
+
+			tabId = cursor.getAttribute( 'name' );
+			// Avoid duplicate select.
+			if ( this._.dialog._.currentTabId != tabId )
+				this._.dialog.selectPage( tabId );
+			return this;
+		},
+
+		/**
+		 * Puts the focus to the UI object. Switches tabs if the UI object isn't in the active tab page.
+		 *
+		 *		uiElement.focus();
+		 *
+		 * @chainable
+		 */
+		focus: function() {
+			this.selectParentTab().getInputElement().focus();
+			return this;
+		},
+
+		/**
+		 * Registers the `on*` event handlers defined in the element definition.
+		 *
+		 * The default behavior of this function is:
+		 *
+		 * 1. If the on* event is defined in the class's eventProcesors list,
+		 *     then the registration is delegated to the corresponding function
+		 *     in the eventProcessors list.
+		 * 2. If the on* event is not defined in the eventProcessors list, then
+		 *     register the event handler under the corresponding DOM event of
+		 *     the UI element's input DOM element (as defined by the return value
+		 *     of {@link #getInputElement}).
+		 *
+		 * This function is only called at UI element instantiation, but can
+		 * be overridded in child classes if they require more flexibility.
+		 *
+		 * @chainable
+		 * @param {CKEDITOR.dialog.definition.uiElement} definition The UI element
+		 * definition.
+		 */
+		registerEvents: function( definition ) {
+			var regex = /^on([A-Z]\w+)/,
+				match;
+
+			var registerDomEvent = function( uiElement, dialog, eventName, func ) {
+					dialog.on( 'load', function() {
+						uiElement.getInputElement().on( eventName, func, uiElement );
+					} );
+				};
+
+			for ( var i in definition ) {
+				if ( !( match = i.match( regex ) ) )
+					continue;
+				if ( this.eventProcessors[ i ] )
+					this.eventProcessors[ i ].call( this, this._.dialog, definition[ i ] );
+				else
+					registerDomEvent( this, this._.dialog, match[ 1 ].toLowerCase(), definition[ i ] );
+			}
+
+			return this;
+		},
+
+		/**
+		 * The event processor list used by
+		 * {@link CKEDITOR.ui.dialog.uiElement#getInputElement} at UI element
+		 * instantiation. The default list defines three `on*` events:
+		 *
+		 * 1. `onLoad` - Called when the element's parent dialog opens for the
+		 *     first time.
+		 * 2. `onShow` - Called whenever the element's parent dialog opens.
+		 * 3. `onHide` - Called whenever the element's parent dialog closes.
+		 *
+		 *		// This connects the 'click' event in CKEDITOR.ui.dialog.button to onClick
+		 *		// handlers in the UI element's definitions.
+		 *		CKEDITOR.ui.dialog.button.eventProcessors = CKEDITOR.tools.extend( {},
+		 *			CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
+		 *			{ onClick : function( dialog, func ) { this.on( 'click', func ); } },
+		 *			true
+		 *		);
+		 *
+		 * @property {Object}
+		 */
+		eventProcessors: {
+			onLoad: function( dialog, func ) {
+				dialog.on( 'load', func, this );
+			},
+
+			onShow: function( dialog, func ) {
+				dialog.on( 'show', func, this );
+			},
+
+			onHide: function( dialog, func ) {
+				dialog.on( 'hide', func, this );
+			}
+		},
+
+		/**
+		 * The default handler for a UI element's access key down event, which
+		 * tries to put focus to the UI element.
+		 *
+		 * Can be overridded in child classes for more sophisticaed behavior.
+		 *
+		 * @param {CKEDITOR.dialog} dialog The parent dialog object.
+		 * @param {String} key The key combination pressed. Since access keys
+		 * are defined to always include the `CTRL` key, its value should always
+		 * include a `'CTRL+'` prefix.
+		 */
+		accessKeyDown: function( dialog, key ) {
+			this.focus();
+		},
+
+		/**
+		 * The default handler for a UI element's access key up event, which
+		 * does nothing.
+		 *
+		 * Can be overridded in child classes for more sophisticated behavior.
+		 *
+		 * @param {CKEDITOR.dialog} dialog The parent dialog object.
+		 * @param {String} key The key combination pressed. Since access keys
+		 * are defined to always include the `CTRL` key, its value should always
+		 * include a `'CTRL+'` prefix.
+		 */
+		accessKeyUp: function( dialog, key ) {},
+
+		/**
+		 * Disables a UI element.
+		 */
+		disable: function() {
+			var element = this.getElement(),
+				input = this.getInputElement();
+			input.setAttribute( 'disabled', 'true' );
+			element.addClass( 'cke_disabled' );
+		},
+
+		/**
+		 * Enables a UI element.
+		 */
+		enable: function() {
+			var element = this.getElement(),
+				input = this.getInputElement();
+			input.removeAttribute( 'disabled' );
+			element.removeClass( 'cke_disabled' );
+		},
+
+		/**
+		 * Determines whether an UI element is enabled or not.
+		 *
+		 * @returns {Boolean} Whether the UI element is enabled.
+		 */
+		isEnabled: function() {
+			return !this.getElement().hasClass( 'cke_disabled' );
+		},
+
+		/**
+		 * Determines whether an UI element is visible or not.
+		 *
+		 * @returns {Boolean} Whether the UI element is visible.
+		 */
+		isVisible: function() {
+			return this.getInputElement().isVisible();
+		},
+
+		/**
+		 * Determines whether an UI element is focus-able or not.
+		 * Focus-able is defined as being both visible and enabled.
+		 *
+		 * @returns {Boolean} Whether the UI element can be focused.
+		 */
+		isFocusable: function() {
+			if ( !this.isEnabled() || !this.isVisible() )
+				return false;
+			return true;
+		}
+	};
+
+	/** @class CKEDITOR.ui.dialog.hbox */
+	CKEDITOR.ui.dialog.hbox.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement, {
+		/**
+		 * Gets a child UI element inside this container.
+		 *
+		 *		var checkbox = hbox.getChild( [0,1] );
+		 *		checkbox.setValue( true );
+		 *
+		 * @param {Array/Number} indices An array or a single number to indicate the child's
+		 * position in the container's descendant tree. Omit to get all the children in an array.
+		 * @returns {Array/CKEDITOR.ui.dialog.uiElement} Array of all UI elements in the container
+		 * if no argument given, or the specified UI element if indices is given.
+		 */
+		getChild: function( indices ) {
+			// If no arguments, return a clone of the children array.
+			if ( arguments.length < 1 )
+				return this._.children.concat();
+
+			// If indices isn't array, make it one.
+			if ( !indices.splice )
+				indices = [ indices ];
+
+			// Retrieve the child element according to tree position.
+			if ( indices.length < 2 )
+				return this._.children[ indices[ 0 ] ];
+			else
+				return ( this._.children[ indices[ 0 ] ] && this._.children[ indices[ 0 ] ].getChild ) ? this._.children[ indices[ 0 ] ].getChild( indices.slice( 1, indices.length ) ) : null;
+		}
+	}, true );
+
+	CKEDITOR.ui.dialog.vbox.prototype = new CKEDITOR.ui.dialog.hbox();
+
+	( function() {
+		var commonBuilder = {
+			build: function( dialog, elementDefinition, output ) {
+				var children = elementDefinition.children,
+					child,
+					childHtmlList = [],
+					childObjList = [];
+				for ( var i = 0;
+				( i < children.length && ( child = children[ i ] ) ); i++ ) {
+					var childHtml = [];
+					childHtmlList.push( childHtml );
+					childObjList.push( CKEDITOR.dialog._.uiElementBuilders[ child.type ].build( dialog, child, childHtml ) );
+				}
+				return new CKEDITOR.ui.dialog[ elementDefinition.type ]( dialog, childObjList, childHtmlList, output, elementDefinition );
+			}
+		};
+
+		CKEDITOR.dialog.addUIElement( 'hbox', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'vbox', commonBuilder );
+	} )();
+
+	/**
+	 * Generic dialog command. It opens a specific dialog when executed.
+	 *
+	 *		// Register the "link" command, which opens the "link" dialog.
+	 *		editor.addCommand( 'link', new CKEDITOR.dialogCommand( 'link' ) );
+	 *
+	 * @class
+	 * @constructor Creates a dialogCommand class instance.
+	 * @extends CKEDITOR.commandDefinition
+	 * @param {String} dialogName The name of the dialog to open when executing
+	 * this command.
+	 * @param {Object} [ext] Additional command definition's properties.
+	 */
+	CKEDITOR.dialogCommand = function( dialogName, ext ) {
+		this.dialogName = dialogName;
+		CKEDITOR.tools.extend( this, ext, true );
+	};
+
+	CKEDITOR.dialogCommand.prototype = {
+		exec: function( editor ) {
+			// Special treatment for Opera. (#8031)
+			CKEDITOR.env.opera ? CKEDITOR.tools.setTimeout( function() {
+				editor.openDialog( this.dialogName );
+			}, 0, this ) : editor.openDialog( this.dialogName );
+		},
+
+		// Dialog commands just open a dialog ui, thus require no undo logic,
+		// undo support should dedicate to specific dialog implementation.
+		canUndo: false,
+
+		editorFocus: 1
+	};
+
+	( function() {
+		var notEmptyRegex = /^([a]|[^a])+$/,
+			integerRegex = /^\d*$/,
+			numberRegex = /^\d*(?:\.\d+)?$/,
+			htmlLengthRegex = /^(((\d*(\.\d+))|(\d*))(px|\%)?)?$/,
+			cssLengthRegex = /^(((\d*(\.\d+))|(\d*))(px|em|ex|in|cm|mm|pt|pc|\%)?)?$/i,
+			inlineStyleRegex = /^(\s*[\w-]+\s*:\s*[^:;]+(?:;|$))*$/;
+
+		CKEDITOR.VALIDATE_OR = 1;
+		CKEDITOR.VALIDATE_AND = 2;
+
+		CKEDITOR.dialog.validate = {
+			functions: function() {
+				var args = arguments;
+				return function() {
+					/**
+					 * It's important for validate functions to be able to accept the value
+					 * as argument in addition to this.getValue(), so that it is possible to
+					 * combine validate functions together to make more sophisticated
+					 * validators.
+					 */
+					var value = this && this.getValue ? this.getValue() : args[ 0 ];
+
+					var msg = undefined,
+						relation = CKEDITOR.VALIDATE_AND,
+						functions = [],
+						i;
+
+					for ( i = 0; i < args.length; i++ ) {
+						if ( typeof( args[ i ] ) == 'function' )
+							functions.push( args[ i ] );
+						else
+							break;
+					}
+
+					if ( i < args.length && typeof( args[ i ] ) == 'string' ) {
+						msg = args[ i ];
+						i++;
+					}
+
+					if ( i < args.length && typeof( args[ i ] ) == 'number' )
+						relation = args[ i ];
+
+					var passed = ( relation == CKEDITOR.VALIDATE_AND ? true : false );
+					for ( i = 0; i < functions.length; i++ ) {
+						if ( relation == CKEDITOR.VALIDATE_AND )
+							passed = passed && functions[ i ]( value );
+						else
+							passed = passed || functions[ i ]( value );
+					}
+
+					return !passed ? msg : true;
+				};
+			},
+
+			regex: function( regex, msg ) {
+				/*
+				 * Can be greatly shortened by deriving from functions validator if code size
+				 * turns out to be more important than performance.
+				 */
+				return function() {
+					var value = this && this.getValue ? this.getValue() : arguments[ 0 ];
+					return !regex.test( value ) ? msg : true;
+				};
+			},
+
+			notEmpty: function( msg ) {
+				return this.regex( notEmptyRegex, msg );
+			},
+
+			integer: function( msg ) {
+				return this.regex( integerRegex, msg );
+			},
+
+			'number': function( msg ) {
+				return this.regex( numberRegex, msg );
+			},
+
+			'cssLength': function( msg ) {
+				return this.functions( function( val ) {
+					return cssLengthRegex.test( CKEDITOR.tools.trim( val ) );
+				}, msg );
+			},
+
+			'htmlLength': function( msg ) {
+				return this.functions( function( val ) {
+					return htmlLengthRegex.test( CKEDITOR.tools.trim( val ) );
+				}, msg );
+			},
+
+			'inlineStyle': function( msg ) {
+				return this.functions( function( val ) {
+					return inlineStyleRegex.test( CKEDITOR.tools.trim( val ) );
+				}, msg );
+			},
+
+			equals: function( value, msg ) {
+				return this.functions( function( val ) {
+					return val == value;
+				}, msg );
+			},
+
+			notEqual: function( value, msg ) {
+				return this.functions( function( val ) {
+					return val != value;
+				}, msg );
+			}
+		};
+
+		CKEDITOR.on( 'instanceDestroyed', function( evt ) {
+			// Remove dialog cover on last instance destroy.
+			if ( CKEDITOR.tools.isEmpty( CKEDITOR.instances ) ) {
+				var currentTopDialog;
+				while ( ( currentTopDialog = CKEDITOR.dialog._.currentTop ) )
+					currentTopDialog.hide();
+				removeCovers();
+			}
+
+			var dialogs = evt.editor._.storedDialogs;
+			for ( var name in dialogs )
+				dialogs[ name ].destroy();
+
+		} );
+
+	} )();
+
+	// Extend the CKEDITOR.editor class with dialog specific functions.
+	CKEDITOR.tools.extend( CKEDITOR.editor.prototype, {
+		/**
+		 * Loads and opens a registered dialog.
+		 *
+		 *		CKEDITOR.instances.editor1.openDialog( 'smiley' );
+		 *
+		 * @member CKEDITOR.editor
+		 * @param {String} dialogName The registered name of the dialog.
+		 * @param {Function} callback The function to be invoked after dialog instance created.
+		 * @returns {CKEDITOR.dialog} The dialog object corresponding to the dialog displayed.
+		 * `null` if the dialog name is not registered.
+		 * @see CKEDITOR.dialog#add
+		 */
+		openDialog: function( dialogName, callback ) {
+			var dialog = null, dialogDefinitions = CKEDITOR.dialog._.dialogDefinitions[ dialogName ];
+
+			if ( CKEDITOR.dialog._.currentTop === null )
+				showCover( this );
+
+			// If the dialogDefinition is already loaded, open it immediately.
+			if ( typeof dialogDefinitions == 'function' ) {
+				var storedDialogs = this._.storedDialogs || ( this._.storedDialogs = {} );
+
+				dialog = storedDialogs[ dialogName ] || ( storedDialogs[ dialogName ] = new CKEDITOR.dialog( this, dialogName ) );
+
+				callback && callback.call( dialog, dialog );
+				dialog.show();
+
+			} else if ( dialogDefinitions == 'failed' ) {
+				hideCover( this );
+				throw new Error( '[CKEDITOR.dialog.openDialog] Dialog "' + dialogName + '" failed when loading definition.' );
+			} else if ( typeof dialogDefinitions == 'string' ) {
+
+				CKEDITOR.scriptLoader.load( CKEDITOR.getUrl( dialogDefinitions ),
+					function() {
+						var dialogDefinition = CKEDITOR.dialog._.dialogDefinitions[ dialogName ];
+						// In case of plugin error, mark it as loading failed.
+						if ( typeof dialogDefinition != 'function' )
+							CKEDITOR.dialog._.dialogDefinitions[ dialogName ] = 'failed';
+
+						this.openDialog( dialogName, callback );
+					}, this, 0, 1 );
+			}
+
+			CKEDITOR.skin.loadPart( 'dialog' );
+
+			return dialog;
+		}
+	} );
+} )();
+
+CKEDITOR.plugins.add( 'dialog', {
+	requires: 'dialogui',
+	init: function( editor ) {
+		editor.on( 'doubleclick', function( evt ) {
+			if ( evt.data.dialog )
+				editor.openDialog( evt.data.dialog );
+		}, null, null, 999 );
+	}
+} );
+
+// Dialog related configurations.
+
+/**
+ * The color of the dialog background cover. It should be a valid CSS color string.
+ *
+ *		config.dialog_backgroundCoverColor = 'rgb(255, 254, 253)';
+ *
+ * @cfg {String} [dialog_backgroundCoverColor='white']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The opacity of the dialog background cover. It should be a number within the
+ * range `[0.0, 1.0]`.
+ *
+ *		config.dialog_backgroundCoverOpacity = 0.7;
+ *
+ * @cfg {Number} [dialog_backgroundCoverOpacity=0.5]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * If the dialog has more than one tab, put focus into the first tab as soon as dialog is opened.
+ *
+ *		config.dialog_startupFocusTab = true;
+ *
+ * @cfg {Boolean} [dialog_startupFocusTab=false]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The distance of magnetic borders used in moving and resizing dialogs,
+ * measured in pixels.
+ *
+ *		config.dialog_magnetDistance = 30;
+ *
+ * @cfg {Number} [dialog_magnetDistance=20]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The guideline to follow when generating the dialog buttons. There are 3 possible options:
+ *
+ * * `'OS'` - the buttons will be displayed in the default order of the user's OS;
+ * * `'ltr'` - for Left-To-Right order;
+ * * `'rtl'` - for Right-To-Left order.
+ *
+ * Example:
+ *
+ *		config.dialog_buttonsOrder = 'rtl';
+ *
+ * @since 3.5
+ * @cfg {String} [dialog_buttonsOrder='OS']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The dialog contents to removed. It's a string composed by dialog name and tab name with a colon between them.
+ *
+ * Separate each pair with semicolon (see example).
+ *
+ * **Note:** All names are case-sensitive.
+ *
+ * **Note:** Be cautious when specifying dialog tabs that are mandatory,
+ * like `'info'`, dialog functionality might be broken because of this!
+ *
+ *		config.removeDialogTabs = 'flash:advanced;image:Link';
+ *
+ * @since 3.5
+ * @cfg {String} [removeDialogTabs='']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Tells if user should not be asked to confirm close, if any dialog field was modified.
+ * By default it is set to `false` meaning that the confirmation dialog will be shown.
+ *
+ *		config.dialog_noConfirmCancel = true;
+ *
+ * @since 4.3
+ * @cfg {Boolean} [dialog_noConfirmCancel=false]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Fired when a dialog definition is about to be used to create a dialog into
+ * an editor instance. This event makes it possible to customize the definition
+ * before creating it.
+ *
+ * Note that this event is called only the first time a specific dialog is
+ * opened. Successive openings will use the cached dialog, and this event will
+ * not get fired.
+ *
+ * @event dialogDefinition
+ * @member CKEDITOR
+ * @param {CKEDITOR.dialog.definition} data The dialog defination that
+ * is being loaded.
+ * @param {CKEDITOR.editor} editor The editor instance that will use the dialog.
+ */
+
+/**
+ * Fired when a tab is going to be selected in a dialog.
+ *
+ * @event selectPage
+ * @member CKEDITOR.dialog
+ * @param data
+ * @param {String} data.page The id of the page that it's gonna be selected.
+ * @param {String} data.currentPage The id of the current page.
+ */
+
+/**
+ * Fired when the user tries to dismiss a dialog.
+ *
+ * @event cancel
+ * @member CKEDITOR.dialog
+ * @param data
+ * @param {Boolean} data.hide Whether the event should proceed or not.
+ */
+
+/**
+ * Fired when the user tries to confirm a dialog.
+ *
+ * @event ok
+ * @member CKEDITOR.dialog
+ * @param data
+ * @param {Boolean} data.hide Whether the event should proceed or not.
+ */
+
+/**
+ * Fired when a dialog is shown.
+ *
+ * @event show
+ * @member CKEDITOR.dialog
+ */
+
+/**
+ * Fired when a dialog is shown.
+ *
+ * @event dialogShow
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {CKEDITOR.dialog} data The opened dialog instance.
+ */
+
+/**
+ * Fired when a dialog is hidden.
+ *
+ * @event hide
+ * @member CKEDITOR.dialog
+ */
+
+/**
+ * Fired when a dialog is hidden.
+ *
+ * @event dialogHide
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {CKEDITOR.dialog} data The hidden dialog instance.
+ */
+
+/**
+ * Fired when a dialog is being resized. The event is fired on
+ * both the {@link CKEDITOR.dialog} object and the dialog instance
+ * since 3.5.3, previously it's available only in the global object.
+ *
+ * @static
+ * @event resize
+ * @member CKEDITOR.dialog
+ * @param data
+ * @param {CKEDITOR.dialog} data.dialog The dialog being resized (if
+ * it's fired on the dialog itself, this parameter isn't sent).
+ * @param {String} data.skin The skin name.
+ * @param {Number} data.width The new width.
+ * @param {Number} data.height The new height.
+ */
+
+/**
+ * Fired when a dialog is being resized. The event is fired on
+ * both the {@link CKEDITOR.dialog} object and the dialog instance
+ * since 3.5.3, previously it's available only in the global object.
+ *
+ * @since 3.5
+ * @event resize
+ * @member CKEDITOR.dialog
+ * @param data
+ * @param {Number} data.width The new width.
+ * @param {Number} data.height The new height.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/dialogui/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/dialogui/plugin.js
new file mode 100644
index 00000000..96568ce6
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/dialogui/plugin.js
@@ -0,0 +1,1409 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "dialogui" plugin.
+ */
+
+CKEDITOR.plugins.add( 'dialogui', {
+	onLoad: function() {
+
+		var initPrivateObject = function( elementDefinition ) {
+				this._ || ( this._ = {} );
+				this._[ 'default' ] = this._.initValue = elementDefinition[ 'default' ] || '';
+				this._.required = elementDefinition[ 'required' ] || false;
+				var args = [ this._ ];
+				for ( var i = 1; i < arguments.length; i++ )
+					args.push( arguments[ i ] );
+				args.push( true );
+				CKEDITOR.tools.extend.apply( CKEDITOR.tools, args );
+				return this._;
+			},
+			textBuilder = {
+				build: function( dialog, elementDefinition, output ) {
+					return new CKEDITOR.ui.dialog.textInput( dialog, elementDefinition, output );
+				}
+			},
+			commonBuilder = {
+				build: function( dialog, elementDefinition, output ) {
+					return new CKEDITOR.ui.dialog[ elementDefinition.type ]( dialog, elementDefinition, output );
+				}
+			},
+			containerBuilder = {
+				build: function( dialog, elementDefinition, output ) {
+					var children = elementDefinition.children,
+						child,
+						childHtmlList = [],
+						childObjList = [];
+					for ( var i = 0;
+					( i < children.length && ( child = children[ i ] ) ); i++ ) {
+						var childHtml = [];
+						childHtmlList.push( childHtml );
+						childObjList.push( CKEDITOR.dialog._.uiElementBuilders[ child.type ].build( dialog, child, childHtml ) );
+					}
+					return new CKEDITOR.ui.dialog[ elementDefinition.type ]( dialog, childObjList, childHtmlList, output, elementDefinition );
+				}
+			},
+			commonPrototype = {
+				isChanged: function() {
+					return this.getValue() != this.getInitValue();
+				},
+
+				reset: function( noChangeEvent ) {
+					this.setValue( this.getInitValue(), noChangeEvent );
+				},
+
+				setInitValue: function() {
+					this._.initValue = this.getValue();
+				},
+
+				resetInitValue: function() {
+					this._.initValue = this._[ 'default' ];
+				},
+
+				getInitValue: function() {
+					return this._.initValue;
+				}
+			},
+			commonEventProcessors = CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors, {
+				onChange: function( dialog, func ) {
+					if ( !this._.domOnChangeRegistered ) {
+						dialog.on( 'load', function() {
+							this.getInputElement().on( 'change', function() {
+								// Make sure 'onchange' doesn't get fired after dialog closed. (#5719)
+								if ( !dialog.parts.dialog.isVisible() )
+									return;
+
+								this.fire( 'change', { value: this.getValue() } );
+							}, this );
+						}, this );
+						this._.domOnChangeRegistered = true;
+					}
+
+					this.on( 'change', func );
+				}
+			}, true ),
+			eventRegex = /^on([A-Z]\w+)/,
+			cleanInnerDefinition = function( def ) {
+				// An inner UI element should not have the parent's type, title or events.
+				for ( var i in def ) {
+					if ( eventRegex.test( i ) || i == 'title' || i == 'type' )
+						delete def[ i ];
+				}
+				return def;
+			};
+
+		CKEDITOR.tools.extend( CKEDITOR.ui.dialog, {
+			/**
+			 * Base class for all dialog elements with a textual label on the left.
+			 *
+			 * @class CKEDITOR.ui.dialog.labeledElement
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a labeledElement class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `label` (Required) The label string.
+			 * * `labelLayout` (Optional) Put 'horizontal' here if the
+			 *     label element is to be layed out horizontally. Otherwise a vertical
+			 *     layout will be used.
+			 * * `widths` (Optional) This applies only for horizontal
+			 *     layouts - an 2-element array of lengths to specify the widths of the
+			 *     label and the content element.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 * @param {Function} contentHtml
+			 * A function returning the HTML code string to be added inside the content
+			 * cell.
+			 */
+			labeledElement: function( dialog, elementDefinition, htmlList, contentHtml ) {
+				if ( arguments.length < 4 )
+					return;
+
+				var _ = initPrivateObject.call( this, elementDefinition );
+				_.labelId = CKEDITOR.tools.getNextId() + '_label';
+				var children = this._.children = [];
+
+				var innerHTML = function() {
+						var html = [],
+							requiredClass = elementDefinition.required ? ' cke_required' : '';
+						if ( elementDefinition.labelLayout != 'horizontal' ) {
+							html.push(
+								'<label class="cke_dialog_ui_labeled_label' + requiredClass + '" ', ' id="' + _.labelId + '"',
+									( _.inputId ? ' for="' + _.inputId + '"' : '' ),
+									( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) + '>',
+									elementDefinition.label,
+								'</label>',
+								'<div class="cke_dialog_ui_labeled_content"',
+									( elementDefinition.controlStyle ? ' style="' + elementDefinition.controlStyle + '"' : '' ),
+									' role="radiogroup" aria-labelledby="' + _.labelId + '">',
+									contentHtml.call( this, dialog, elementDefinition ),
+								'</div>' );
+						} else {
+							var hboxDefinition = {
+								type: 'hbox',
+								widths: elementDefinition.widths,
+								padding: 0,
+								children: [
+									{
+									type: 'html',
+									html: '<label class="cke_dialog_ui_labeled_label' + requiredClass + '"' +
+										' id="' + _.labelId + '"' +
+										' for="' + _.inputId + '"' +
+										( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) + '>' +
+											CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
+										'</span>'
+								},
+									{
+									type: 'html',
+									html: '<span class="cke_dialog_ui_labeled_content"' + ( elementDefinition.controlStyle ? ' style="' + elementDefinition.controlStyle + '"' : '' ) + '>' +
+										contentHtml.call( this, dialog, elementDefinition ) +
+										'</span>'
+								}
+								]
+							};
+							CKEDITOR.dialog._.uiElementBuilders.hbox.build( dialog, hboxDefinition, html );
+						}
+						return html.join( '' );
+					};
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'div', null, { role: 'presentation' }, innerHTML );
+			},
+
+			/**
+			 * A text input with a label. This UI element class represents both the
+			 * single-line text inputs and password inputs in dialog boxes.
+			 *
+			 * @class CKEDITOR.ui.dialog.textInput
+			 * @extends CKEDITOR.ui.dialog.labeledElement
+			 * @constructor Creates a textInput class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `default` (Optional) The default value.
+			 * * `validate` (Optional) The validation function.
+			 * * `maxLength` (Optional) The maximum length of text box contents.
+			 * * `size` (Optional) The size of the text box. This is
+			 *     usually overridden by the size defined by the skin, however.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			textInput: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				initPrivateObject.call( this, elementDefinition );
+				var domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textInput',
+					attributes = { 'class': 'cke_dialog_ui_input_' + elementDefinition.type, id: domId, type: elementDefinition.type },
+					i;
+
+				// Set the validator, if any.
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				// Set the max length and size.
+				if ( elementDefinition.maxLength )
+					attributes.maxlength = elementDefinition.maxLength;
+				if ( elementDefinition.size )
+					attributes.size = elementDefinition.size;
+
+				if ( elementDefinition.inputStyle )
+					attributes.style = elementDefinition.inputStyle;
+
+				// If user presses Enter in a text box, it implies clicking OK for the dialog.
+				var me = this,
+					keyPressedOnMe = false;
+				dialog.on( 'load', function() {
+					me.getInputElement().on( 'keydown', function( evt ) {
+						if ( evt.data.getKeystroke() == 13 )
+							keyPressedOnMe = true;
+					} );
+
+					// Lower the priority this 'keyup' since 'ok' will close the dialog.(#3749)
+					me.getInputElement().on( 'keyup', function( evt ) {
+						if ( evt.data.getKeystroke() == 13 && keyPressedOnMe ) {
+							dialog.getButton( 'ok' ) && setTimeout( function() {
+								dialog.getButton( 'ok' ).click();
+							}, 0 );
+							keyPressedOnMe = false;
+						}
+					}, null, null, 1000 );
+				} );
+
+				var innerHTML = function() {
+						// IE BUG: Text input fields in IE at 100% would exceed a <td> or inline
+						// container's width, so need to wrap it inside a <div>.
+						var html = [ '<div class="cke_dialog_ui_input_', elementDefinition.type, '" role="presentation"' ];
+
+						if ( elementDefinition.width )
+							html.push( 'style="width:' + elementDefinition.width + '" ' );
+
+						html.push( '><input ' );
+
+						attributes[ 'aria-labelledby' ] = this._.labelId;
+						this._.required && ( attributes[ 'aria-required' ] = this._.required );
+						for ( var i in attributes )
+							html.push( i + '="' + attributes[ i ] + '" ' );
+						html.push( ' /></div>' );
+						return html.join( '' );
+					};
+				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
+			},
+
+			/**
+			 * A text area with a label on the top or left.
+			 *
+			 * @class CKEDITOR.ui.dialog.textarea
+			 * @extends CKEDITOR.ui.dialog.labeledElement
+			 * @constructor Creates a textarea class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 *
+			 * The element definition. Accepted fields:
+			 *
+			 * * `rows` (Optional) The number of rows displayed.
+			 *     Defaults to 5 if not defined.
+			 * * `cols` (Optional) The number of cols displayed.
+			 *     Defaults to 20 if not defined. Usually overridden by skins.
+			 * * `default` (Optional) The default value.
+			 * * `validate` (Optional) The validation function.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			textarea: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				initPrivateObject.call( this, elementDefinition );
+				var me = this,
+					domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textarea',
+					attributes = {};
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				// Generates the essential attributes for the textarea tag.
+				attributes.rows = elementDefinition.rows || 5;
+				attributes.cols = elementDefinition.cols || 20;
+
+				attributes[ 'class' ] = 'cke_dialog_ui_input_textarea ' + ( elementDefinition[ 'class' ] || '' );
+
+				if ( typeof elementDefinition.inputStyle != 'undefined' )
+					attributes.style = elementDefinition.inputStyle;
+
+				if ( elementDefinition.dir )
+					attributes.dir = elementDefinition.dir;
+
+				var innerHTML = function() {
+						attributes[ 'aria-labelledby' ] = this._.labelId;
+						this._.required && ( attributes[ 'aria-required' ] = this._.required );
+						var html = [ '<div class="cke_dialog_ui_input_textarea" role="presentation"><textarea id="', domId, '" ' ];
+						for ( var i in attributes )
+							html.push( i + '="' + CKEDITOR.tools.htmlEncode( attributes[ i ] ) + '" ' );
+						html.push( '>', CKEDITOR.tools.htmlEncode( me._[ 'default' ] ), '</textarea></div>' );
+						return html.join( '' );
+					};
+				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
+			},
+
+			/**
+			 * A single checkbox with a label on the right.
+			 *
+			 * @class CKEDITOR.ui.dialog.checkbox
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a checkbox class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `checked` (Optional) Whether the checkbox is checked
+			 *     on instantiation. Defaults to false.
+			 * * `validate` (Optional) The validation function.
+			 * * `label` (Optional) The checkbox label.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			checkbox: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				var _ = initPrivateObject.call( this, elementDefinition, { 'default': !!elementDefinition[ 'default' ] } );
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				var innerHTML = function() {
+						var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition, {
+							id: elementDefinition.id ? elementDefinition.id + '_checkbox' : CKEDITOR.tools.getNextId() + '_checkbox'
+						}, true ),
+							html = [];
+
+						var labelId = CKEDITOR.tools.getNextId() + '_label';
+						var attributes = { 'class': 'cke_dialog_ui_checkbox_input', type: 'checkbox', 'aria-labelledby': labelId };
+						cleanInnerDefinition( myDefinition );
+						if ( elementDefinition[ 'default' ] )
+							attributes.checked = 'checked';
+
+						if ( typeof myDefinition.inputStyle != 'undefined' )
+							myDefinition.style = myDefinition.inputStyle;
+
+						_.checkbox = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'input', null, attributes );
+						html.push( ' <label id="', labelId, '" for="', attributes.id, '"' + ( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) + '>', CKEDITOR.tools.htmlEncode( elementDefinition.label ), '</label>' );
+						return html.join( '' );
+					};
+
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'span', null, null, innerHTML );
+			},
+
+			/**
+			 * A group of radio buttons.
+			 *
+			 * @class CKEDITOR.ui.dialog.radio
+			 * @extends CKEDITOR.ui.dialog.labeledElement
+			 * @constructor Creates a radio class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `default` (Required) The default value.
+			 * * `validate` (Optional) The validation function.
+			 * * `items` (Required) An array of options. Each option
+			 *     is a 1- or 2-item array of format `[ 'Description', 'Value' ]`. If `'Value'`
+			 *     is missing, then the value would be assumed to be the same as the description.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			radio: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				initPrivateObject.call( this, elementDefinition );
+
+				if ( !this._[ 'default' ] )
+					this._[ 'default' ] = this._.initValue = elementDefinition.items[ 0 ][ 1 ];
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.valdiate;
+
+				var children = [],
+					me = this;
+
+				var innerHTML = function() {
+					var inputHtmlList = [],
+						html = [],
+						commonName = ( elementDefinition.id ? elementDefinition.id : CKEDITOR.tools.getNextId() ) + '_radio';
+
+					for ( var i = 0; i < elementDefinition.items.length; i++ ) {
+						var item = elementDefinition.items[ i ],
+							title = item[ 2 ] !== undefined ? item[ 2 ] : item[ 0 ],
+							value = item[ 1 ] !== undefined ? item[ 1 ] : item[ 0 ],
+							inputId = CKEDITOR.tools.getNextId() + '_radio_input',
+							labelId = inputId + '_label',
+
+							inputDefinition = CKEDITOR.tools.extend( {}, elementDefinition, {
+								id: inputId,
+								title: null,
+								type: null
+							}, true ),
+
+							labelDefinition = CKEDITOR.tools.extend( {}, inputDefinition, {
+								title: title
+							}, true ),
+
+							inputAttributes = {
+								type: 'radio',
+								'class': 'cke_dialog_ui_radio_input',
+								name: commonName,
+								value: value,
+								'aria-labelledby': labelId
+							},
+
+							inputHtml = [];
+
+						if ( me._[ 'default' ] == value )
+							inputAttributes.checked = 'checked';
+
+						cleanInnerDefinition( inputDefinition );
+						cleanInnerDefinition( labelDefinition );
+
+						if ( typeof inputDefinition.inputStyle != 'undefined' )
+							inputDefinition.style = inputDefinition.inputStyle;
+
+						// Make inputs of radio type focusable (#10866).
+						inputDefinition.keyboardFocusable = true;
+
+						children.push( new CKEDITOR.ui.dialog.uiElement( dialog, inputDefinition, inputHtml, 'input', null, inputAttributes ) );
+
+						inputHtml.push( ' ' );
+
+						new CKEDITOR.ui.dialog.uiElement( dialog, labelDefinition, inputHtml, 'label', null, {
+							id: labelId,
+							'for': inputAttributes.id
+						}, item[ 0 ] );
+
+						inputHtmlList.push( inputHtml.join( '' ) );
+					}
+
+					new CKEDITOR.ui.dialog.hbox( dialog, children, inputHtmlList, html );
+
+					return html.join( '' );
+				};
+
+				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
+				this._.children = children;
+			},
+
+			/**
+			 * A button with a label inside.
+			 *
+			 * @class CKEDITOR.ui.dialog.button
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a button class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `label` (Required) The button label.
+			 * * `disabled` (Optional) Set to true if you want the
+			 *     button to appear in disabled state.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			button: function( dialog, elementDefinition, htmlList ) {
+				if ( !arguments.length )
+					return;
+
+				if ( typeof elementDefinition == 'function' )
+					elementDefinition = elementDefinition( dialog.getParentEditor() );
+
+				initPrivateObject.call( this, elementDefinition, { disabled: elementDefinition.disabled || false } );
+
+				// Add OnClick event to this input.
+				CKEDITOR.event.implementOn( this );
+
+				var me = this;
+
+				// Register an event handler for processing button clicks.
+				dialog.on( 'load', function( eventInfo ) {
+					var element = this.getElement();
+
+					( function() {
+						element.on( 'click', function( evt ) {
+							me.click();
+							// #9958
+							evt.data.preventDefault();
+						} );
+
+						element.on( 'keydown', function( evt ) {
+							if ( evt.data.getKeystroke() in { 32: 1 } ) {
+								me.click();
+								evt.data.preventDefault();
+							}
+						} );
+					} )();
+
+					element.unselectable();
+				}, this );
+
+				var outerDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
+				delete outerDefinition.style;
+
+				var labelId = CKEDITOR.tools.getNextId() + '_label';
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, outerDefinition, htmlList, 'a', null, {
+					style: elementDefinition.style,
+					href: 'javascript:void(0)',
+					title: elementDefinition.label,
+					hidefocus: 'true',
+					'class': elementDefinition[ 'class' ],
+					role: 'button',
+					'aria-labelledby': labelId
+				}, '<span id="' + labelId + '" class="cke_dialog_ui_button">' +
+											CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
+										'</span>' );
+			},
+
+			/**
+			 * A select box.
+			 *
+			 * @class CKEDITOR.ui.dialog.select
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a button class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `default` (Required) The default value.
+			 * * `validate` (Optional) The validation function.
+			 * * `items` (Required) An array of options. Each option
+			 *     is a 1- or 2-item array of format `[ 'Description', 'Value' ]`. If `'Value'`
+			 *     is missing, then the value would be assumed to be the same as the
+			 *     description.
+			 * * `multiple` (Optional) Set this to true if you'd like
+			 *     to have a multiple-choice select box.
+			 * * `size` (Optional) The number of items to display in
+			 *     the select box.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			select: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				var _ = initPrivateObject.call( this, elementDefinition );
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				_.inputId = CKEDITOR.tools.getNextId() + '_select';
+
+				var innerHTML = function() {
+						var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition, {
+							id: elementDefinition.id ? elementDefinition.id + '_select' : CKEDITOR.tools.getNextId() + '_select'
+						}, true ),
+							html = [],
+							innerHTML = [],
+							attributes = { 'id': _.inputId, 'class': 'cke_dialog_ui_input_select', 'aria-labelledby': this._.labelId };
+
+						html.push( '<div class="cke_dialog_ui_input_', elementDefinition.type, '" role="presentation"' );
+						if ( elementDefinition.width )
+							html.push( 'style="width:' + elementDefinition.width + '" ' );
+						html.push( '>' );
+
+						// Add multiple and size attributes from element definition.
+						if ( elementDefinition.size != undefined )
+							attributes.size = elementDefinition.size;
+						if ( elementDefinition.multiple != undefined )
+							attributes.multiple = elementDefinition.multiple;
+
+						cleanInnerDefinition( myDefinition );
+						for ( var i = 0, item; i < elementDefinition.items.length && ( item = elementDefinition.items[ i ] ); i++ ) {
+							innerHTML.push( '<option value="', CKEDITOR.tools.htmlEncode( item[ 1 ] !== undefined ? item[ 1 ] : item[ 0 ] ).replace( /"/g, '&quot;' ), '" /> ', CKEDITOR.tools.htmlEncode( item[ 0 ] ) );
+						}
+
+						if ( typeof myDefinition.inputStyle != 'undefined' )
+							myDefinition.style = myDefinition.inputStyle;
+
+						_.select = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'select', null, attributes, innerHTML.join( '' ) );
+
+						html.push( '</div>' );
+
+						return html.join( '' );
+					};
+
+				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
+			},
+
+			/**
+			 * A file upload input.
+			 *
+			 * @class CKEDITOR.ui.dialog.file
+			 * @extends CKEDITOR.ui.dialog.labeledElement
+			 * @constructor Creates a file class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `validate` (Optional) The validation function.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			file: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				if ( elementDefinition[ 'default' ] === undefined )
+					elementDefinition[ 'default' ] = '';
+
+				var _ = CKEDITOR.tools.extend( initPrivateObject.call( this, elementDefinition ), { definition: elementDefinition, buttons: [] } );
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				/** @ignore */
+				var innerHTML = function() {
+						_.frameId = CKEDITOR.tools.getNextId() + '_fileInput';
+
+						var html = [
+							'<iframe' +
+								' frameborder="0"' +
+								' allowtransparency="0"' +
+								' class="cke_dialog_ui_input_file"' +
+								' role="presentation"' +
+								' id="', _.frameId, '"' +
+								' title="', elementDefinition.label, '"' +
+								' src="javascript:void(' ];
+
+						// Support for custom document.domain on IE. (#10165)
+						html.push( CKEDITOR.env.ie ?
+							'(function(){' + encodeURIComponent(
+								'document.open();' +
+								'(' + CKEDITOR.tools.fixDomain + ')();' +
+								'document.close();'
+							) + '})()'
+							:
+							'0' );
+
+						html.push( ')">' +
+							'</iframe>' );
+
+						return html.join( '' );
+					};
+
+				// IE BUG: Parent container does not resize to contain the iframe automatically.
+				dialog.on( 'load', function() {
+					var iframe = CKEDITOR.document.getById( _.frameId ),
+						contentDiv = iframe.getParent();
+					contentDiv.addClass( 'cke_dialog_ui_input_file' );
+				} );
+
+				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
+			},
+
+			/**
+			 * A button for submitting the file in a file upload input.
+			 *
+			 * @class CKEDITOR.ui.dialog.fileButton
+			 * @extends CKEDITOR.ui.dialog.button
+			 * @constructor Creates a fileButton class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `for` (Required) The file input's page and element Id
+			 *     to associate to, in a 2-item array format: `[ 'page_id', 'element_id' ]`.
+			 * * `validate` (Optional) The validation function.
+			 *
+			 * @param {Array} htmlList List of HTML code to output to.
+			 */
+			fileButton: function( dialog, elementDefinition, htmlList ) {
+				if ( arguments.length < 3 )
+					return;
+
+				var _ = initPrivateObject.call( this, elementDefinition ),
+					me = this;
+
+				if ( elementDefinition.validate )
+					this.validate = elementDefinition.validate;
+
+				var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
+				var onClick = myDefinition.onClick;
+				myDefinition.className = ( myDefinition.className ? myDefinition.className + ' ' : '' ) + 'cke_dialog_ui_button';
+				myDefinition.onClick = function( evt ) {
+					var target = elementDefinition[ 'for' ]; // [ pageId, elementId ]
+					if ( !onClick || onClick.call( this, evt ) !== false ) {
+						dialog.getContentElement( target[ 0 ], target[ 1 ] ).submit();
+						this.disable();
+					}
+				};
+
+				dialog.on( 'load', function() {
+					dialog.getContentElement( elementDefinition[ 'for' ][ 0 ], elementDefinition[ 'for' ][ 1 ] )._.buttons.push( me );
+				} );
+
+				CKEDITOR.ui.dialog.button.call( this, dialog, myDefinition, htmlList );
+			},
+
+			html: ( function() {
+				var myHtmlRe = /^\s*<[\w:]+\s+([^>]*)?>/,
+					theirHtmlRe = /^(\s*<[\w:]+(?:\s+[^>]*)?)((?:.|\r|\n)+)$/,
+					emptyTagRe = /\/$/;
+				/**
+				 * A dialog element made from raw HTML code.
+				 *
+				 * @class CKEDITOR.ui.dialog.html
+				 * @extends CKEDITOR.ui.dialog.uiElement
+				 * @constructor Creates a html class instance.
+				 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+				 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition Element definition.
+				 * Accepted fields:
+				 *
+				 * * `html` (Required) HTML code of this element.
+				 *
+				 * @param {Array} htmlList List of HTML code to be added to the dialog's content area.
+				 */
+				return function( dialog, elementDefinition, htmlList ) {
+					if ( arguments.length < 3 )
+						return;
+
+					var myHtmlList = [],
+						myHtml,
+						theirHtml = elementDefinition.html,
+						myMatch, theirMatch;
+
+					// If the HTML input doesn't contain any tags at the beginning, add a <span> tag around it.
+					if ( theirHtml.charAt( 0 ) != '<' )
+						theirHtml = '<span>' + theirHtml + '</span>';
+
+					// Look for focus function in definition.
+					var focus = elementDefinition.focus;
+					if ( focus ) {
+						var oldFocus = this.focus;
+						this.focus = function() {
+							( typeof focus == 'function' ? focus : oldFocus ).call( this );
+							this.fire( 'focus' );
+						};
+						if ( elementDefinition.isFocusable ) {
+							var oldIsFocusable = this.isFocusable;
+							this.isFocusable = oldIsFocusable;
+						}
+						this.keyboardFocusable = true;
+					}
+
+					CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, myHtmlList, 'span', null, null, '' );
+
+					// Append the attributes created by the uiElement call to the real HTML.
+					myHtml = myHtmlList.join( '' );
+					myMatch = myHtml.match( myHtmlRe );
+					theirMatch = theirHtml.match( theirHtmlRe ) || [ '', '', '' ];
+
+					if ( emptyTagRe.test( theirMatch[ 1 ] ) ) {
+						theirMatch[ 1 ] = theirMatch[ 1 ].slice( 0, -1 );
+						theirMatch[ 2 ] = '/' + theirMatch[ 2 ];
+					}
+
+					htmlList.push( [ theirMatch[ 1 ], ' ', myMatch[ 1 ] || '', theirMatch[ 2 ] ].join( '' ) );
+				};
+			} )(),
+
+			/**
+			 * Form fieldset for grouping dialog UI elements.
+			 *
+			 * @class CKEDITOR.ui.dialog.fieldset
+			 * @extends CKEDITOR.ui.dialog.uiElement
+			 * @constructor Creates a fieldset class instance.
+			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
+			 * @param {Array} childObjList
+			 * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
+			 * @param {Array} childHtmlList Array of HTML code that correspond to the HTML output of all the
+			 * objects in childObjList.
+			 * @param {Array} htmlList Array of HTML code that this element will output to.
+			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
+			 * The element definition. Accepted fields:
+			 *
+			 * * `label` (Optional) The legend of the this fieldset.
+			 * * `children` (Required) An array of dialog field definitions which will be grouped inside this fieldset.
+			 *
+			 */
+			fieldset: function( dialog, childObjList, childHtmlList, htmlList, elementDefinition ) {
+				var legendLabel = elementDefinition.label;
+				/** @ignore */
+				var innerHTML = function() {
+						var html = [];
+						legendLabel && html.push( '<legend' +
+							( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) +
+							'>' + legendLabel + '</legend>' );
+						for ( var i = 0; i < childHtmlList.length; i++ )
+							html.push( childHtmlList[ i ] );
+						return html.join( '' );
+					};
+
+				this._ = { children: childObjList };
+				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'fieldset', null, null, innerHTML );
+			}
+
+		}, true );
+
+		CKEDITOR.ui.dialog.html.prototype = new CKEDITOR.ui.dialog.uiElement;
+
+		/** @class CKEDITOR.ui.dialog.labeledElement */
+		CKEDITOR.ui.dialog.labeledElement.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement, {
+			/**
+			 * Sets the label text of the element.
+			 *
+			 * @param {String} label The new label text.
+			 * @returns {CKEDITOR.ui.dialog.labeledElement} The current labeled element.
+			 */
+			setLabel: function( label ) {
+				var node = CKEDITOR.document.getById( this._.labelId );
+				if ( node.getChildCount() < 1 )
+				( new CKEDITOR.dom.text( label, CKEDITOR.document ) ).appendTo( node );
+				else
+					node.getChild( 0 ).$.nodeValue = label;
+				return this;
+			},
+
+			/**
+			 * Retrieves the current label text of the elment.
+			 *
+			 * @returns {String} The current label text.
+			 */
+			getLabel: function() {
+				var node = CKEDITOR.document.getById( this._.labelId );
+				if ( !node || node.getChildCount() < 1 )
+					return '';
+				else
+					return node.getChild( 0 ).getText();
+			},
+
+			/**
+			 * Defines the onChange event for UI element definitions.
+			 * @property {Object}
+			 */
+			eventProcessors: commonEventProcessors
+		}, true );
+
+		/** @class CKEDITOR.ui.dialog.button */
+		CKEDITOR.ui.dialog.button.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement, {
+			/**
+			 * Simulates a click to the button.
+			 *
+			 * @returns {Object} Return value of the `click` event.
+			 */
+			click: function() {
+				if ( !this._.disabled )
+					return this.fire( 'click', { dialog: this._.dialog } );
+				return false;
+			},
+
+			/**
+			 * Enables the button.
+			 */
+			enable: function() {
+				this._.disabled = false;
+				var element = this.getElement();
+				element && element.removeClass( 'cke_disabled' );
+			},
+
+			/**
+			 * Disables the button.
+			 */
+			disable: function() {
+				this._.disabled = true;
+				this.getElement().addClass( 'cke_disabled' );
+			},
+
+			/**
+			 * @todo
+			 */
+			isVisible: function() {
+				return this.getElement().getFirst().isVisible();
+			},
+
+			/**
+			 * @todo
+			 */
+			isEnabled: function() {
+				return !this._.disabled;
+			},
+
+			/**
+			 * Defines the onChange event and onClick for button element definitions.
+			 *
+			 * @property {Object}
+			 */
+			eventProcessors: CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors, {
+				onClick: function( dialog, func ) {
+					this.on( 'click', function() {
+						func.apply( this, arguments );
+					} );
+				}
+			}, true ),
+
+			/**
+			 * Handler for the element's access key up event. Simulates a click to
+			 * the button.
+			 */
+			accessKeyUp: function() {
+				this.click();
+			},
+
+			/**
+			 * Handler for the element's access key down event. Simulates a mouse
+			 * down to the button.
+			 */
+			accessKeyDown: function() {
+				this.focus();
+			},
+
+			keyboardFocusable: true
+		}, true );
+
+		/** @class CKEDITOR.ui.dialog.textInput */
+		CKEDITOR.ui.dialog.textInput.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement, {
+			/**
+			 * Gets the text input DOM element under this UI object.
+			 *
+			 * @returns {CKEDITOR.dom.element} The DOM element of the text input.
+			 */
+			getInputElement: function() {
+				return CKEDITOR.document.getById( this._.inputId );
+			},
+
+			/**
+			 * Puts focus into the text input.
+			 */
+			focus: function() {
+				var me = this.selectParentTab();
+
+				// GECKO BUG: setTimeout() is needed to workaround invisible selections.
+				setTimeout( function() {
+					var element = me.getInputElement();
+					element && element.$.focus();
+				}, 0 );
+			},
+
+			/**
+			 * Selects all the text in the text input.
+			 */
+			select: function() {
+				var me = this.selectParentTab();
+
+				// GECKO BUG: setTimeout() is needed to workaround invisible selections.
+				setTimeout( function() {
+					var e = me.getInputElement();
+					if ( e ) {
+						e.$.focus();
+						e.$.select();
+					}
+				}, 0 );
+			},
+
+			/**
+			 * Handler for the text input's access key up event. Makes a `select()`
+			 * call to the text input.
+			 */
+			accessKeyUp: function() {
+				this.select();
+			},
+
+			/**
+			 * Sets the value of this text input object.
+			 *
+			 *		uiElement.setValue( 'Blamo' );
+			 *
+			 * @param {Object} value The new value.
+			 * @returns {CKEDITOR.ui.dialog.textInput} The current UI element.
+			 */
+			setValue: function( value ) {
+				!value && ( value = '' );
+				return CKEDITOR.ui.dialog.uiElement.prototype.setValue.apply( this, arguments );
+			},
+
+			keyboardFocusable: true
+		}, commonPrototype, true );
+
+		CKEDITOR.ui.dialog.textarea.prototype = new CKEDITOR.ui.dialog.textInput();
+
+		/** @class CKEDITOR.ui.dialog.select */
+		CKEDITOR.ui.dialog.select.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement, {
+			/**
+			 * Gets the DOM element of the select box.
+			 *
+			 * @returns {CKEDITOR.dom.element} The `<select>` element of this UI element.
+			 */
+			getInputElement: function() {
+				return this._.select.getElement();
+			},
+
+			/**
+			 * Adds an option to the select box.
+			 *
+			 * @param {String} label Option label.
+			 * @param {String} value (Optional) Option value, if not defined it'll be
+			 * assumed to be the same as the label.
+			 * @param {Number} index (Optional) Position of the option to be inserted
+			 * to. If not defined the new option will be inserted to the end of list.
+			 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
+			 */
+			add: function( label, value, index ) {
+				var option = new CKEDITOR.dom.element( 'option', this.getDialog().getParentEditor().document ),
+					selectElement = this.getInputElement().$;
+				option.$.text = label;
+				option.$.value = ( value === undefined || value === null ) ? label : value;
+				if ( index === undefined || index === null ) {
+					if ( CKEDITOR.env.ie )
+						selectElement.add( option.$ );
+					else
+						selectElement.add( option.$, null );
+				} else
+					selectElement.add( option.$, index );
+				return this;
+			},
+
+			/**
+			 * Removes an option from the selection list.
+			 *
+			 * @param {Number} index Index of the option to be removed.
+			 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
+			 */
+			remove: function( index ) {
+				var selectElement = this.getInputElement().$;
+				selectElement.remove( index );
+				return this;
+			},
+
+			/**
+			 * Clears all options out of the selection list.
+			 *
+			 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
+			 */
+			clear: function() {
+				var selectElement = this.getInputElement().$;
+				while ( selectElement.length > 0 )
+					selectElement.remove( 0 );
+				return this;
+			},
+
+			keyboardFocusable: true
+		}, commonPrototype, true );
+
+		/** @class CKEDITOR.ui.dialog.checkbox */
+		CKEDITOR.ui.dialog.checkbox.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement, {
+			/**
+			 * Gets the checkbox DOM element.
+			 *
+			 * @returns {CKEDITOR.dom.element} The DOM element of the checkbox.
+			 */
+			getInputElement: function() {
+				return this._.checkbox.getElement();
+			},
+
+			/**
+			 * Sets the state of the checkbox.
+			 *
+			 * @param {Boolean} checked `true` to tick the checkbox, `false` to untick it.
+			 * @param {Boolean} noChangeEvent Internal commit, to supress `change` event on this element.
+			 */
+			setValue: function( checked, noChangeEvent ) {
+				this.getInputElement().$.checked = checked;
+				!noChangeEvent && this.fire( 'change', { value: checked } );
+			},
+
+			/**
+			 * Gets the state of the checkbox.
+			 *
+			 * @returns {Boolean} true means the checkbox is ticked, false means it's not ticked.
+			 */
+			getValue: function() {
+				return this.getInputElement().$.checked;
+			},
+
+			/**
+			 * Handler for the access key up event. Toggles the checkbox.
+			 */
+			accessKeyUp: function() {
+				this.setValue( !this.getValue() );
+			},
+
+			/**
+			 * Defines the onChange event for UI element definitions.
+			 *
+			 * @property {Object}
+			 */
+			eventProcessors: {
+				onChange: function( dialog, func ) {
+					if ( !CKEDITOR.env.ie || ( CKEDITOR.env.version > 8 ) )
+						return commonEventProcessors.onChange.apply( this, arguments );
+					else {
+						dialog.on( 'load', function() {
+							var element = this._.checkbox.getElement();
+							element.on( 'propertychange', function( evt ) {
+								evt = evt.data.$;
+								if ( evt.propertyName == 'checked' )
+									this.fire( 'change', { value: element.$.checked } );
+							}, this );
+						}, this );
+						this.on( 'change', func );
+					}
+					return null;
+				}
+			},
+
+			keyboardFocusable: true
+		}, commonPrototype, true );
+
+		/** @class CKEDITOR.ui.dialog.radio */
+		CKEDITOR.ui.dialog.radio.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement, {
+			/**
+			 * Checks one of the radio buttons in this button group.
+			 *
+			 * @param {String} value The value of the button to be chcked.
+			 * @param {Boolean} noChangeEvent Internal commit, to supress `change` event on this element.
+			 */
+			setValue: function( value, noChangeEvent ) {
+				var children = this._.children,
+					item;
+				for ( var i = 0;
+				( i < children.length ) && ( item = children[ i ] ); i++ )
+					item.getElement().$.checked = ( item.getValue() == value );
+				!noChangeEvent && this.fire( 'change', { value: value } );
+			},
+
+			/**
+			 * Gets the value of the currently checked radio button.
+			 *
+			 * @returns {String} The currently checked button's value.
+			 */
+			getValue: function() {
+				var children = this._.children;
+				for ( var i = 0; i < children.length; i++ ) {
+					if ( children[ i ].getElement().$.checked )
+						return children[ i ].getValue();
+				}
+				return null;
+			},
+
+			/**
+			 * Handler for the access key up event. Focuses the currently
+			 * selected radio button, or the first radio button if none is selected.
+			 */
+			accessKeyUp: function() {
+				var children = this._.children,
+					i;
+				for ( i = 0; i < children.length; i++ ) {
+					if ( children[ i ].getElement().$.checked ) {
+						children[ i ].getElement().focus();
+						return;
+					}
+				}
+				children[ 0 ].getElement().focus();
+			},
+
+			/**
+			 * Defines the onChange event for UI element definitions.
+			 *
+			 * @property {Object}
+			 */
+			eventProcessors: {
+				onChange: function( dialog, func ) {
+					if ( !CKEDITOR.env.ie )
+						return commonEventProcessors.onChange.apply( this, arguments );
+					else {
+						dialog.on( 'load', function() {
+							var children = this._.children,
+								me = this;
+							for ( var i = 0; i < children.length; i++ ) {
+								var element = children[ i ].getElement();
+								element.on( 'propertychange', function( evt ) {
+									evt = evt.data.$;
+									if ( evt.propertyName == 'checked' && this.$.checked )
+										me.fire( 'change', { value: this.getAttribute( 'value' ) } );
+								} );
+							}
+						}, this );
+						this.on( 'change', func );
+					}
+					return null;
+				}
+			}
+		}, commonPrototype, true );
+
+		/** @class CKEDITOR.ui.dialog.file */
+		CKEDITOR.ui.dialog.file.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement, commonPrototype, {
+			/**
+			 * Gets the `<input>` element of this file input.
+			 *
+			 * @returns {CKEDITOR.dom.element} The file input element.
+			 */
+			getInputElement: function() {
+				var frameDocument = CKEDITOR.document.getById( this._.frameId ).getFrameDocument();
+				return frameDocument.$.forms.length > 0 ? new CKEDITOR.dom.element( frameDocument.$.forms[ 0 ].elements[ 0 ] ) : this.getElement();
+			},
+
+			/**
+			 * Uploads the file in the file input.
+			 *
+			 * @returns {CKEDITOR.ui.dialog.file} This object.
+			 */
+			submit: function() {
+				this.getInputElement().getParent().$.submit();
+				return this;
+			},
+
+			/**
+			 * Get the action assigned to the form.
+			 *
+			 * @returns {String} The value of the action.
+			 */
+			getAction: function() {
+				return this.getInputElement().getParent().$.action;
+			},
+
+			/**
+			 * The events must be applied on the inner input element, and
+			 * that must be done when the iframe & form has been loaded.
+			 */
+			registerEvents: function( definition ) {
+				var regex = /^on([A-Z]\w+)/,
+					match;
+
+				var registerDomEvent = function( uiElement, dialog, eventName, func ) {
+						uiElement.on( 'formLoaded', function() {
+							uiElement.getInputElement().on( eventName, func, uiElement );
+						} );
+					};
+
+				for ( var i in definition ) {
+					if ( !( match = i.match( regex ) ) )
+						continue;
+
+					if ( this.eventProcessors[ i ] )
+						this.eventProcessors[ i ].call( this, this._.dialog, definition[ i ] );
+					else
+						registerDomEvent( this, this._.dialog, match[ 1 ].toLowerCase(), definition[ i ] );
+				}
+
+				return this;
+			},
+
+			/**
+			 * Redraws the file input and resets the file path in the file input.
+			 * The redraw logic is necessary because non-IE browsers tend to clear
+			 * the `<iframe>` containing the file input after closing the dialog.
+			 */
+			reset: function() {
+				var _ = this._,
+					frameElement = CKEDITOR.document.getById( _.frameId ),
+					frameDocument = frameElement.getFrameDocument(),
+					elementDefinition = _.definition,
+					buttons = _.buttons,
+					callNumber = this.formLoadedNumber,
+					unloadNumber = this.formUnloadNumber,
+					langDir = _.dialog._.editor.lang.dir,
+					langCode = _.dialog._.editor.langCode;
+
+				// The callback function for the iframe, but we must call tools.addFunction only once
+				// so we store the function number in this.formLoadedNumber
+				if ( !callNumber ) {
+					callNumber = this.formLoadedNumber = CKEDITOR.tools.addFunction( function() {
+						// Now we can apply the events to the input type=file
+						this.fire( 'formLoaded' );
+					}, this );
+
+					// Remove listeners attached to the content of the iframe (the file input)
+					unloadNumber = this.formUnloadNumber = CKEDITOR.tools.addFunction( function() {
+						this.getInputElement().clearCustomData();
+					}, this );
+
+					this.getDialog()._.editor.on( 'destroy', function() {
+						CKEDITOR.tools.removeFunction( callNumber );
+						CKEDITOR.tools.removeFunction( unloadNumber );
+					} );
+				}
+
+				function generateFormField() {
+					frameDocument.$.open();
+
+					var size = '';
+					if ( elementDefinition.size )
+						size = elementDefinition.size - ( CKEDITOR.env.ie ? 7 : 0 ); // "Browse" button is bigger in IE.
+
+					var inputId = _.frameId + '_input';
+
+					frameDocument.$.write( [
+						'<html dir="' + langDir + '" lang="' + langCode + '"><head><title></title></head><body style="margin: 0; overflow: hidden; background: transparent;">',
+							'<form enctype="multipart/form-data" method="POST" dir="' + langDir + '" lang="' + langCode + '" action="',
+								CKEDITOR.tools.htmlEncode( elementDefinition.action ),
+							'">',
+								// Replicate the field label inside of iframe.
+								'<label id="', _.labelId, '" for="', inputId, '" style="display:none">',
+									CKEDITOR.tools.htmlEncode( elementDefinition.label ),
+								'</label>',
+								// Set width to make sure that input is not clipped by the iframe (#11253).
+								'<input style="width:100%" id="', inputId, '" aria-labelledby="', _.labelId, '" type="file" name="',
+									CKEDITOR.tools.htmlEncode( elementDefinition.id || 'cke_upload' ),
+									'" size="',
+									CKEDITOR.tools.htmlEncode( size > 0 ? size : "" ),
+								'" />',
+							'</form>',
+						'</body></html>',
+						'<script>',
+							// Support for custom document.domain in IE.
+							CKEDITOR.env.ie ? '(' + CKEDITOR.tools.fixDomain + ')();' : '',
+
+							'window.parent.CKEDITOR.tools.callFunction(' + callNumber + ');',
+							'window.onbeforeunload = function() {window.parent.CKEDITOR.tools.callFunction(' + unloadNumber + ')}',
+						'</script>'
+					].join( '' ) );
+
+					frameDocument.$.close();
+
+					for ( var i = 0; i < buttons.length; i++ )
+						buttons[ i ].enable();
+				}
+
+				// #3465: Wait for the browser to finish rendering the dialog first.
+				if ( CKEDITOR.env.gecko )
+					setTimeout( generateFormField, 500 );
+				else
+					generateFormField();
+			},
+
+			getValue: function() {
+				return this.getInputElement().$.value || '';
+			},
+
+			/***
+			 * The default value of input `type="file"` is an empty string, but during initialization
+			 * of this UI element, the iframe still isn't ready so it can't be read from that object
+			 * Setting it manually prevents later issues about the current value (`''`) being different
+			 * of the initial value (undefined as it asked for `.value` of a div).
+			 */
+			setInitValue: function() {
+				this._.initValue = '';
+			},
+
+			/**
+			 * Defines the onChange event for UI element definitions.
+			 *
+			 * @property {Object}
+			 */
+			eventProcessors: {
+				onChange: function( dialog, func ) {
+					// If this method is called several times (I'm not sure about how this can happen but the default
+					// onChange processor includes this protection)
+					// In order to reapply to the new element, the property is deleted at the beggining of the registerEvents method
+					if ( !this._.domOnChangeRegistered ) {
+						// By listening for the formLoaded event, this handler will get reapplied when a new
+						// form is created
+						this.on( 'formLoaded', function() {
+							this.getInputElement().on( 'change', function() {
+								this.fire( 'change', { value: this.getValue() } );
+							}, this );
+						}, this );
+						this._.domOnChangeRegistered = true;
+					}
+
+					this.on( 'change', func );
+				}
+			},
+
+			keyboardFocusable: true
+		}, true );
+
+		CKEDITOR.ui.dialog.fileButton.prototype = new CKEDITOR.ui.dialog.button;
+
+		CKEDITOR.ui.dialog.fieldset.prototype = CKEDITOR.tools.clone( CKEDITOR.ui.dialog.hbox.prototype );
+
+		CKEDITOR.dialog.addUIElement( 'text', textBuilder );
+		CKEDITOR.dialog.addUIElement( 'password', textBuilder );
+		CKEDITOR.dialog.addUIElement( 'textarea', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'checkbox', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'radio', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'button', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'select', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'file', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'fileButton', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'html', commonBuilder );
+		CKEDITOR.dialog.addUIElement( 'fieldset', containerBuilder );
+	}
+} );
+
+/**
+ * Fired when the value of the uiElement is changed.
+ *
+ * @event change
+ * @member CKEDITOR.ui.dialog.uiElement
+ */
+
+/**
+ * Fired when the inner frame created by the element is ready.
+ * Each time the button is used or the dialog is loaded a new
+ * form might be created.
+ *
+ * @event formLoaded
+ * @member CKEDITOR.ui.dialog.fileButton
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/enterkey/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/enterkey/plugin.js
new file mode 100644
index 00000000..cb60aba6
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/enterkey/plugin.js
@@ -0,0 +1,529 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'enterkey', {
+		init: function( editor ) {
+			editor.addCommand( 'enter', {
+				modes: { wysiwyg: 1 },
+				editorFocus: false,
+				exec: function( editor ) {
+					enter( editor );
+				}
+			} );
+
+			editor.addCommand( 'shiftEnter', {
+				modes: { wysiwyg: 1 },
+				editorFocus: false,
+				exec: function( editor ) {
+					shiftEnter( editor );
+				}
+			} );
+
+			editor.setKeystroke( [
+				[ 13, 'enter' ],
+				[ CKEDITOR.SHIFT + 13, 'shiftEnter' ]
+			] );
+		}
+	} );
+
+	var whitespaces = CKEDITOR.dom.walker.whitespaces(),
+		bookmark = CKEDITOR.dom.walker.bookmark();
+
+	CKEDITOR.plugins.enterkey = {
+		enterBlock: function( editor, mode, range, forceMode ) {
+			// Get the range for the current selection.
+			range = range || getRange( editor );
+
+			// We may not have valid ranges to work on, like when inside a
+			// contenteditable=false element.
+			if ( !range )
+				return;
+
+			var doc = range.document;
+
+			var atBlockStart = range.checkStartOfBlock(),
+				atBlockEnd = range.checkEndOfBlock(),
+				path = editor.elementPath( range.startContainer ),
+				block = path.block,
+
+				// Determine the block element to be used.
+				blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' ),
+
+				newBlock;
+
+			// Exit the list when we're inside an empty list item block. (#5376)
+			if ( atBlockStart && atBlockEnd ) {
+				// Exit the list when we're inside an empty list item block. (#5376)
+				if ( block && ( block.is( 'li' ) || block.getParent().is( 'li' ) ) ) {
+					var blockParent = block.getParent(),
+						blockGrandParent = blockParent.getParent(),
+
+						firstChild = !block.hasPrevious(),
+						lastChild = !block.hasNext(),
+
+						selection = editor.getSelection(),
+						bookmarks = selection.createBookmarks(),
+
+						orgDir = block.getDirection( 1 ),
+						className = block.getAttribute( 'class' ),
+						style = block.getAttribute( 'style' ),
+						dirLoose = blockGrandParent.getDirection( 1 ) != orgDir,
+
+						enterMode = editor.enterMode,
+						needsBlock = enterMode != CKEDITOR.ENTER_BR || dirLoose || style || className,
+
+						child;
+
+					if ( blockGrandParent.is( 'li' ) ) {
+
+						// If block is the first or the last child of the parent
+						// list, degrade it and move to the outer list:
+						// before the parent list if block is first child and after
+						// the parent list if block is the last child, respectively.
+						//
+						//  <ul>                         =>      <ul>
+						//      <li>                     =>          <li>
+						//          <ul>                 =>              <ul>
+						//              <li>x</li>       =>                  <li>x</li>
+						//              <li>^</li>       =>              </ul>
+						//          </ul>                =>          </li>
+						//      </li>                    =>          <li>^</li>
+						//  </ul>                        =>      </ul>
+						//
+						//                              AND
+						//
+						//  <ul>                         =>      <ul>
+						//      <li>                     =>          <li>^</li>
+						//          <ul>                 =>          <li>
+						//              <li>^</li>       =>              <ul>
+						//              <li>x</li>       =>                  <li>x</li>
+						//          </ul>                =>              </ul>
+						//      </li>                    =>          </li>
+						//  </ul>                        =>      </ul>
+
+						if ( firstChild || lastChild )
+							block[ firstChild ? 'insertBefore' : 'insertAfter' ]( blockGrandParent );
+
+						// If the empty block is neither first nor last child
+						// then split the list and the block as an element
+						// of outer list.
+						//
+						//                              =>      <ul>
+						//                              =>          <li>
+						//  <ul>                        =>              <ul>
+						//      <li>                    =>                  <li>x</li>
+						//          <ul>                =>              </ul>
+						//              <li>x</li>      =>          </li>
+						//              <li>^</li>      =>          <li>^</li>
+						//              <li>y</li>      =>          <li>
+						//          </ul>               =>              <ul>
+						//      </li>                   =>                  <li>y</li>
+						//  </ul>                       =>              </ul>
+						//                              =>          </li>
+						//                              =>      </ul>
+
+						else
+							block.breakParent( blockGrandParent );
+					}
+
+					else if ( !needsBlock ) {
+						block.appendBogus( true );
+
+						// If block is the first or last child of the parent
+						// list, move all block's children out of the list:
+						// before the list if block is first child and after the list
+						// if block is the last child, respectively.
+						//
+						//  <ul>                       =>      <ul>
+						//      <li>x</li>             =>          <li>x</li>
+						//      <li>^</li>             =>      </ul>
+						//  </ul>                      =>      ^
+						//
+						//                            AND
+						//
+						//  <ul>                       =>      ^
+						//      <li>^</li>             =>      <ul>
+						//      <li>x</li>             =>          <li>x</li>
+						//  </ul>                      =>      </ul>
+
+						if ( firstChild || lastChild ) {
+							while ( ( child = block[ firstChild ? 'getFirst' : 'getLast' ]() ) )
+								child[ firstChild ? 'insertBefore' : 'insertAfter' ]( blockParent );
+						}
+
+						// If the empty block is neither first nor last child
+						// then split the list and put all the block contents
+						// between two lists.
+						//
+						//  <ul>                       =>      <ul>
+						//      <li>x</li>             =>          <li>x</li>
+						//      <li>^</li>             =>      </ul>
+						//      <li>y</li>             =>      ^
+						//  </ul>                      =>      <ul>
+						//                             =>          <li>y</li>
+						//                             =>      </ul>
+
+						else {
+							block.breakParent( blockParent );
+
+							while ( ( child = block.getLast() ) )
+								child.insertAfter( blockParent );
+						}
+
+						block.remove();
+					} else {
+						// Use <div> block for ENTER_BR and ENTER_DIV.
+						newBlock = doc.createElement( mode == CKEDITOR.ENTER_P ? 'p' : 'div' );
+
+						if ( dirLoose )
+							newBlock.setAttribute( 'dir', orgDir );
+
+						style && newBlock.setAttribute( 'style', style );
+						className && newBlock.setAttribute( 'class', className );
+
+						// Move all the child nodes to the new block.
+						block.moveChildren( newBlock );
+
+						// If block is the first or last child of the parent
+						// list, move it out of the list:
+						// before the list if block is first child and after the list
+						// if block is the last child, respectively.
+						//
+						//  <ul>                       =>      <ul>
+						//      <li>x</li>             =>          <li>x</li>
+						//      <li>^</li>             =>      </ul>
+						//  </ul>                      =>      <p>^</p>
+						//
+						//                            AND
+						//
+						//  <ul>                       =>      <p>^</p>
+						//      <li>^</li>             =>      <ul>
+						//      <li>x</li>             =>          <li>x</li>
+						//  </ul>                      =>      </ul>
+
+						if ( firstChild || lastChild )
+							newBlock[ firstChild ? 'insertBefore' : 'insertAfter' ]( blockParent );
+
+						// If the empty block is neither first nor last child
+						// then split the list and put the new block between
+						// two lists.
+						//
+						//                             =>       <ul>
+						//     <ul>                    =>           <li>x</li>
+						//         <li>x</li>          =>       </ul>
+						//         <li>^</li>          =>       <p>^</p>
+						//         <li>y</li>          =>       <ul>
+						//     </ul>                   =>           <li>y</li>
+						//                             =>       </ul>
+
+						else {
+							block.breakParent( blockParent );
+							newBlock.insertAfter( blockParent );
+						}
+
+						block.remove();
+					}
+
+					selection.selectBookmarks( bookmarks );
+
+					return;
+				}
+
+				if ( block && block.getParent().is( 'blockquote' ) ) {
+					block.breakParent( block.getParent() );
+
+					// If we were at the start of <blockquote>, there will be an empty element before it now.
+					if ( !block.getPrevious().getFirst( CKEDITOR.dom.walker.invisible( 1 ) ) )
+						block.getPrevious().remove();
+
+					// If we were at the end of <blockquote>, there will be an empty element after it now.
+					if ( !block.getNext().getFirst( CKEDITOR.dom.walker.invisible( 1 ) ) )
+						block.getNext().remove();
+
+					range.moveToElementEditStart( block );
+					range.select();
+					return;
+				}
+			}
+			// Don't split <pre> if we're in the middle of it, act as shift enter key.
+			else if ( block && block.is( 'pre' ) ) {
+				if ( !atBlockEnd ) {
+					enterBr( editor, mode, range, forceMode );
+					return;
+				}
+			}
+
+			// Split the range.
+			var splitInfo = range.splitBlock( blockTag );
+
+			if ( !splitInfo )
+				return;
+
+			// Get the current blocks.
+			var previousBlock = splitInfo.previousBlock,
+				nextBlock = splitInfo.nextBlock;
+
+			var isStartOfBlock = splitInfo.wasStartOfBlock,
+				isEndOfBlock = splitInfo.wasEndOfBlock;
+
+			var node;
+
+			// If this is a block under a list item, split it as well. (#1647)
+			if ( nextBlock ) {
+				node = nextBlock.getParent();
+				if ( node.is( 'li' ) ) {
+					nextBlock.breakParent( node );
+					nextBlock.move( nextBlock.getNext(), 1 );
+				}
+			} else if ( previousBlock && ( node = previousBlock.getParent() ) && node.is( 'li' ) ) {
+				previousBlock.breakParent( node );
+				node = previousBlock.getNext();
+				range.moveToElementEditStart( node );
+				previousBlock.move( previousBlock.getPrevious() );
+			}
+
+			// If we have both the previous and next blocks, it means that the
+			// boundaries were on separated blocks, or none of them where on the
+			// block limits (start/end).
+			if ( !isStartOfBlock && !isEndOfBlock ) {
+				// If the next block is an <li> with another list tree as the first
+				// child, we'll need to append a filler (<br>/NBSP) or the list item
+				// wouldn't be editable. (#1420)
+				if ( nextBlock.is( 'li' ) ) {
+					var walkerRange = range.clone();
+					walkerRange.selectNodeContents( nextBlock );
+					var walker = new CKEDITOR.dom.walker( walkerRange );
+					walker.evaluator = function( node ) {
+						return !( bookmark( node ) || whitespaces( node ) || node.type == CKEDITOR.NODE_ELEMENT && node.getName() in CKEDITOR.dtd.$inline && !( node.getName() in CKEDITOR.dtd.$empty ) );
+					};
+
+					node = walker.next();
+					if ( node && node.type == CKEDITOR.NODE_ELEMENT && node.is( 'ul', 'ol' ) )
+						( CKEDITOR.env.needsBrFiller ? doc.createElement( 'br' ) : doc.createText( '\xa0' ) ).insertBefore( node );
+				}
+
+				// Move the selection to the end block.
+				if ( nextBlock )
+					range.moveToElementEditStart( nextBlock );
+			} else {
+				var newBlockDir;
+
+				if ( previousBlock ) {
+					// Do not enter this block if it's a header tag, or we are in
+					// a Shift+Enter (#77). Create a new block element instead
+					// (later in the code).
+					if ( previousBlock.is( 'li' ) || !( headerTagRegex.test( previousBlock.getName() ) || previousBlock.is( 'pre' ) ) ) {
+						// Otherwise, duplicate the previous block.
+						newBlock = previousBlock.clone();
+					}
+				} else if ( nextBlock )
+					newBlock = nextBlock.clone();
+
+				if ( !newBlock ) {
+					// We have already created a new list item. (#6849)
+					if ( node && node.is( 'li' ) )
+						newBlock = node;
+					else {
+						newBlock = doc.createElement( blockTag );
+						if ( previousBlock && ( newBlockDir = previousBlock.getDirection() ) )
+							newBlock.setAttribute( 'dir', newBlockDir );
+					}
+				}
+				// Force the enter block unless we're talking of a list item.
+				else if ( forceMode && !newBlock.is( 'li' ) )
+					newBlock.renameNode( blockTag );
+
+				// Recreate the inline elements tree, which was available
+				// before hitting enter, so the same styles will be available in
+				// the new block.
+				var elementPath = splitInfo.elementPath;
+				if ( elementPath ) {
+					for ( var i = 0, len = elementPath.elements.length; i < len; i++ ) {
+						var element = elementPath.elements[ i ];
+
+						if ( element.equals( elementPath.block ) || element.equals( elementPath.blockLimit ) )
+							break;
+
+						if ( CKEDITOR.dtd.$removeEmpty[ element.getName() ] ) {
+							element = element.clone();
+							newBlock.moveChildren( element );
+							newBlock.append( element );
+						}
+					}
+				}
+
+				newBlock.appendBogus();
+
+				if ( !newBlock.getParent() )
+					range.insertNode( newBlock );
+
+				// list item start number should not be duplicated (#7330), but we need
+				// to remove the attribute after it's onto the DOM tree because of old IEs (#7581).
+				newBlock.is( 'li' ) && newBlock.removeAttribute( 'value' );
+
+				// This is tricky, but to make the new block visible correctly
+				// we must select it.
+				// The previousBlock check has been included because it may be
+				// empty if we have fixed a block-less space (like ENTER into an
+				// empty table cell).
+				if ( CKEDITOR.env.ie && isStartOfBlock && ( !isEndOfBlock || !previousBlock.getChildCount() ) ) {
+					// Move the selection to the new block.
+					range.moveToElementEditStart( isEndOfBlock ? previousBlock : newBlock );
+					range.select();
+				}
+
+				// Move the selection to the new block.
+				range.moveToElementEditStart( isStartOfBlock && !isEndOfBlock ? nextBlock : newBlock );
+			}
+
+			range.select();
+			range.scrollIntoView();
+		},
+
+		enterBr: function( editor, mode, range, forceMode ) {
+			// Get the range for the current selection.
+			range = range || getRange( editor );
+
+			// We may not have valid ranges to work on, like when inside a
+			// contenteditable=false element.
+			if ( !range )
+				return;
+
+			var doc = range.document;
+
+			// Determine the block element to be used.
+			var blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
+
+			var isEndOfBlock = range.checkEndOfBlock();
+
+			var elementPath = new CKEDITOR.dom.elementPath( editor.getSelection().getStartElement() );
+
+			var startBlock = elementPath.block,
+				startBlockTag = startBlock && elementPath.block.getName();
+
+			var isPre = false;
+
+			if ( !forceMode && startBlockTag == 'li' ) {
+				enterBlock( editor, mode, range, forceMode );
+				return;
+			}
+
+			// If we are at the end of a header block.
+			if ( !forceMode && isEndOfBlock && headerTagRegex.test( startBlockTag ) ) {
+				var newBlock, newBlockDir;
+
+				if ( ( newBlockDir = startBlock.getDirection() ) ) {
+					newBlock = doc.createElement( 'div' );
+					newBlock.setAttribute( 'dir', newBlockDir );
+					newBlock.insertAfter( startBlock );
+					range.setStart( newBlock, 0 );
+				} else {
+					// Insert a <br> after the current paragraph.
+					doc.createElement( 'br' ).insertAfter( startBlock );
+
+					// A text node is required by Gecko only to make the cursor blink.
+					if ( CKEDITOR.env.gecko )
+						doc.createText( '' ).insertAfter( startBlock );
+
+					// IE has different behaviors regarding position.
+					range.setStartAt( startBlock.getNext(), CKEDITOR.env.ie ? CKEDITOR.POSITION_BEFORE_START : CKEDITOR.POSITION_AFTER_START );
+				}
+			} else {
+				var lineBreak;
+
+				// IE<8 prefers text node as line-break inside of <pre> (#4711).
+				if ( startBlockTag == 'pre' && CKEDITOR.env.ie && CKEDITOR.env.version < 8 )
+					lineBreak = doc.createText( '\r' );
+				else
+					lineBreak = doc.createElement( 'br' );
+
+				range.deleteContents();
+				range.insertNode( lineBreak );
+
+				// Old IEs have different behavior regarding position.
+				if ( !CKEDITOR.env.needsBrFiller )
+					range.setStartAt( lineBreak, CKEDITOR.POSITION_AFTER_END );
+				else {
+					// A text node is required by Gecko only to make the cursor blink.
+					// We need some text inside of it, so the bogus <br> is properly
+					// created.
+					doc.createText( '\ufeff' ).insertAfter( lineBreak );
+
+					// If we are at the end of a block, we must be sure the bogus node is available in that block.
+					if ( isEndOfBlock )
+						lineBreak.getParent().appendBogus();
+
+					// Now we can remove the text node contents, so the caret doesn't
+					// stop on it.
+					lineBreak.getNext().$.nodeValue = '';
+
+					range.setStartAt( lineBreak.getNext(), CKEDITOR.POSITION_AFTER_START );
+
+				}
+			}
+
+			// This collapse guarantees the cursor will be blinking.
+			range.collapse( true );
+
+			range.select();
+			range.scrollIntoView();
+		}
+	};
+
+	var plugin = CKEDITOR.plugins.enterkey,
+		enterBr = plugin.enterBr,
+		enterBlock = plugin.enterBlock,
+		headerTagRegex = /^h[1-6]$/;
+
+	function shiftEnter( editor ) {
+		// On SHIFT+ENTER:
+		// 1. We want to enforce the mode to be respected, instead
+		// of cloning the current block. (#77)
+		return enter( editor, editor.activeShiftEnterMode, 1 );
+	}
+
+	function enter( editor, mode, forceMode ) {
+		forceMode = editor.config.forceEnterMode || forceMode;
+
+		// Only effective within document.
+		if ( editor.mode != 'wysiwyg' )
+			return;
+
+		if ( !mode )
+			mode = editor.activeEnterMode;
+
+		// TODO this should be handled by setting editor.activeEnterMode on selection change.
+		// Check path block specialities:
+		// 1. Cannot be a un-splittable element, e.g. table caption;
+		var path = editor.elementPath();
+		if ( !path.isContextFor( 'p' ) ) {
+			mode = CKEDITOR.ENTER_BR;
+			forceMode = 1;
+		}
+
+		editor.fire( 'saveSnapshot' ); // Save undo step.
+
+		if ( mode == CKEDITOR.ENTER_BR )
+			enterBr( editor, mode, null, forceMode );
+		else
+			enterBlock( editor, mode, null, forceMode );
+
+		editor.fire( 'saveSnapshot' );
+	}
+
+	function getRange( editor ) {
+		// Get the selection ranges.
+		var ranges = editor.getSelection().getRanges( true );
+
+		// Delete the contents of all ranges except the first one.
+		for ( var i = ranges.length - 1; i > 0; i-- ) {
+			ranges[ i ].deleteContents();
+		}
+
+		// Return the first range.
+		return ranges[ 0 ];
+	}
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/entities/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/entities/plugin.js
new file mode 100644
index 00000000..87265979
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/entities/plugin.js
@@ -0,0 +1,239 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	// Base HTML entities.
+	var htmlbase = 'nbsp,gt,lt,amp';
+
+	var entities =
+	// Latin-1 Entities
+	'quot,iexcl,cent,pound,curren,yen,brvbar,sect,uml,copy,ordf,laquo,' +
+		'not,shy,reg,macr,deg,plusmn,sup2,sup3,acute,micro,para,middot,' +
+		'cedil,sup1,ordm,raquo,frac14,frac12,frac34,iquest,times,divide,' +
+
+		// Symbols
+		'fnof,bull,hellip,prime,Prime,oline,frasl,weierp,image,real,trade,' +
+		'alefsym,larr,uarr,rarr,darr,harr,crarr,lArr,uArr,rArr,dArr,hArr,' +
+		'forall,part,exist,empty,nabla,isin,notin,ni,prod,sum,minus,lowast,' +
+		'radic,prop,infin,ang,and,or,cap,cup,int,there4,sim,cong,asymp,ne,' +
+		'equiv,le,ge,sub,sup,nsub,sube,supe,oplus,otimes,perp,sdot,lceil,' +
+		'rceil,lfloor,rfloor,lang,rang,loz,spades,clubs,hearts,diams,' +
+
+		// Other Special Characters
+		'circ,tilde,ensp,emsp,thinsp,zwnj,zwj,lrm,rlm,ndash,mdash,lsquo,' +
+		'rsquo,sbquo,ldquo,rdquo,bdquo,dagger,Dagger,permil,lsaquo,rsaquo,' +
+		'euro';
+
+	// Latin Letters Entities
+	var latin = 'Agrave,Aacute,Acirc,Atilde,Auml,Aring,AElig,Ccedil,Egrave,Eacute,' +
+		'Ecirc,Euml,Igrave,Iacute,Icirc,Iuml,ETH,Ntilde,Ograve,Oacute,Ocirc,' +
+		'Otilde,Ouml,Oslash,Ugrave,Uacute,Ucirc,Uuml,Yacute,THORN,szlig,' +
+		'agrave,aacute,acirc,atilde,auml,aring,aelig,ccedil,egrave,eacute,' +
+		'ecirc,euml,igrave,iacute,icirc,iuml,eth,ntilde,ograve,oacute,ocirc,' +
+		'otilde,ouml,oslash,ugrave,uacute,ucirc,uuml,yacute,thorn,yuml,' +
+		'OElig,oelig,Scaron,scaron,Yuml';
+
+	// Greek Letters Entities.
+	var greek = 'Alpha,Beta,Gamma,Delta,Epsilon,Zeta,Eta,Theta,Iota,Kappa,Lambda,Mu,' +
+		'Nu,Xi,Omicron,Pi,Rho,Sigma,Tau,Upsilon,Phi,Chi,Psi,Omega,alpha,' +
+		'beta,gamma,delta,epsilon,zeta,eta,theta,iota,kappa,lambda,mu,nu,xi,' +
+		'omicron,pi,rho,sigmaf,sigma,tau,upsilon,phi,chi,psi,omega,thetasym,' +
+		'upsih,piv';
+
+	// Create a mapping table between one character and its entity form from a list of entity names.
+	// @param reverse {Boolean} Whether to create a reverse map from the entity string form to an actual character.
+	function buildTable( entities, reverse ) {
+		var table = {},
+			regex = [];
+
+		// Entities that the browsers DOM don't transform to the final char
+		// automatically.
+		var specialTable = {
+			nbsp: '\u00A0', // IE | FF
+			shy: '\u00AD', // IE
+			gt: '\u003E', // IE | FF |   --   | Opera
+			lt: '\u003C', // IE | FF | Safari | Opera
+			amp: '\u0026', // ALL
+			apos: '\u0027', // IE
+			quot: '\u0022' // IE
+		};
+
+		entities = entities.replace( /\b(nbsp|shy|gt|lt|amp|apos|quot)(?:,|$)/g, function( match, entity ) {
+			var org = reverse ? '&' + entity + ';' : specialTable[ entity ],
+				result = reverse ? specialTable[ entity ] : '&' + entity + ';';
+
+			table[ org ] = result;
+			regex.push( org );
+			return '';
+		} );
+
+		if ( !reverse && entities ) {
+			// Transforms the entities string into an array.
+			entities = entities.split( ',' );
+
+			// Put all entities inside a DOM element, transforming them to their
+			// final chars.
+			var div = document.createElement( 'div' ),
+				chars;
+			div.innerHTML = '&' + entities.join( ';&' ) + ';';
+			chars = div.innerHTML;
+			div = null;
+
+			// Add all chars to the table.
+			for ( var i = 0; i < chars.length; i++ ) {
+				var charAt = chars.charAt( i );
+				table[ charAt ] = '&' + entities[ i ] + ';';
+				regex.push( charAt );
+			}
+		}
+
+		table.regex = regex.join( reverse ? '|' : '' );
+
+		return table;
+	}
+
+	CKEDITOR.plugins.add( 'entities', {
+		afterInit: function( editor ) {
+			var config = editor.config;
+
+			var dataProcessor = editor.dataProcessor,
+				htmlFilter = dataProcessor && dataProcessor.htmlFilter;
+
+			if ( htmlFilter ) {
+				// Mandatory HTML base entities.
+				var selectedEntities = [];
+
+				if ( config.basicEntities !== false )
+					selectedEntities.push( htmlbase );
+
+				if ( config.entities ) {
+					if ( selectedEntities.length )
+						selectedEntities.push( entities );
+
+					if ( config.entities_latin )
+						selectedEntities.push( latin );
+
+					if ( config.entities_greek )
+						selectedEntities.push( greek );
+
+					if ( config.entities_additional )
+						selectedEntities.push( config.entities_additional );
+				}
+
+				var entitiesTable = buildTable( selectedEntities.join( ',' ) );
+
+				// Create the Regex used to find entities in the text, leave it matches nothing if entities are empty.
+				var entitiesRegex = entitiesTable.regex ? '[' + entitiesTable.regex + ']' : 'a^';
+				delete entitiesTable.regex;
+
+				if ( config.entities && config.entities_processNumerical )
+					entitiesRegex = '[^ -~]|' + entitiesRegex;
+
+				entitiesRegex = new RegExp( entitiesRegex, 'g' );
+
+				function getEntity( character ) {
+					return config.entities_processNumerical == 'force' || !entitiesTable[ character ] ? '&#' + character.charCodeAt( 0 ) + ';'
+						: entitiesTable[ character ];
+				}
+
+				// Decode entities that the browsers has transformed
+				// at first place.
+				var baseEntitiesTable = buildTable( [ htmlbase, 'shy' ].join( ',' ), true ),
+					baseEntitiesRegex = new RegExp( baseEntitiesTable.regex, 'g' );
+
+				function getChar( character ) {
+					return baseEntitiesTable[ character ];
+				}
+
+				htmlFilter.addRules( {
+					text: function( text ) {
+						return text.replace( baseEntitiesRegex, getChar ).replace( entitiesRegex, getEntity );
+					}
+				}, {
+					applyToAll: true,
+					excludeNestedEditable: true
+				} );
+			}
+		}
+	} );
+} )();
+
+/**
+ * Whether to escape basic HTML entities in the document, including:
+ *
+ * * `nbsp`
+ * * `gt`
+ * * `lt`
+ * * `amp`
+ *
+ * **Note:** It should not be subject to change unless when outputting a non-HTML data format like BBCode.
+ *
+ *		config.basicEntities = false;
+ *
+ * @cfg {Boolean} [basicEntities=true]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.basicEntities = true;
+
+/**
+ * Whether to use HTML entities in the output.
+ *
+ *		config.entities = false;
+ *
+ * @cfg {Boolean} [entities=true]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.entities = true;
+
+/**
+ * Whether to convert some Latin characters (Latin alphabet No. 1, ISO 8859-1)
+ * to HTML entities. The list of entities can be found in the
+ * [W3C HTML 4.01 Specification, section 24.2.1](http://www.w3.org/TR/html4/sgml/entities.html#h-24.2.1).
+ *
+ *		config.entities_latin = false;
+ *
+ * @cfg {Boolean} [entities_latin=true]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.entities_latin = true;
+
+/**
+ * Whether to convert some symbols, mathematical symbols, and Greek letters to
+ * HTML entities. This may be more relevant for users typing text written in Greek.
+ * The list of entities can be found in the
+ * [W3C HTML 4.01 Specification, section 24.3.1(http://www.w3.org/TR/html4/sgml/entities.html#h-24.3.1).
+ *
+ *		config.entities_greek = false;
+ *
+ * @cfg {Boolean} [entities_greek=true]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.entities_greek = true;
+
+/**
+ * Whether to convert all remaining characters not included in the ASCII
+ * character table to their relative decimal numeric representation of HTML entity.
+ * When set to `force`, it will convert all entities into this format.
+ *
+ * For example the phrase `'This is Chinese: 汉语.'` is output
+ * as `'This is Chinese: &#27721;&#35821;.'`
+ *
+ *		config.entities_processNumerical = true;
+ *		config.entities_processNumerical = 'force'; // Converts from '&nbsp;' into '&#160;';
+ *
+ * @cfg {Boolean/String} [entities_processNumerical=false]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * A comma separated list of  additional entities to be used. Entity names
+ * or numbers must be used in a form that excludes the `'&amp;'` prefix and the `';'` ending.
+ *
+ *		config.entities_additional = '#1049'; // Adds Cyrillic capital letter Short I (Й).
+ *
+ * @cfg {String} [entities_additional='#39' (The single quote (') character)]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.entities_additional = '#39';
diff --git a/lam/templates/lib/extra/ckeditor/plugins/fakeobjects/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/fakeobjects/plugin.js
new file mode 100644
index 00000000..7b81703f
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/fakeobjects/plugin.js
@@ -0,0 +1,178 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	var cssStyle = CKEDITOR.htmlParser.cssStyle,
+		cssLength = CKEDITOR.tools.cssLength;
+
+	var cssLengthRegex = /^((?:\d*(?:\.\d+))|(?:\d+))(.*)?$/i;
+
+	// Replacing the former CSS length value with the later one, with
+	// adjustment to the length  unit.
+	function replaceCssLength( length1, length2 ) {
+		var parts1 = cssLengthRegex.exec( length1 ),
+			parts2 = cssLengthRegex.exec( length2 );
+
+		// Omit pixel length unit when necessary,
+		// e.g. replaceCssLength( 10, '20px' ) -> 20
+		if ( parts1 ) {
+			if ( !parts1[ 2 ] && parts2[ 2 ] == 'px' )
+				return parts2[ 1 ];
+			if ( parts1[ 2 ] == 'px' && !parts2[ 2 ] )
+				return parts2[ 1 ] + 'px';
+		}
+
+		return length2;
+	}
+
+	var htmlFilterRules = {
+		elements: {
+			$: function( element ) {
+				var attributes = element.attributes,
+					realHtml = attributes && attributes[ 'data-cke-realelement' ],
+					realFragment = realHtml && new CKEDITOR.htmlParser.fragment.fromHtml( decodeURIComponent( realHtml ) ),
+					realElement = realFragment && realFragment.children[ 0 ];
+
+				// Width/height in the fake object are subjected to clone into the real element.
+				if ( realElement && element.attributes[ 'data-cke-resizable' ] ) {
+					var styles = new cssStyle( element ).rules,
+						realAttrs = realElement.attributes,
+						width = styles.width,
+						height = styles.height;
+
+					width && ( realAttrs.width = replaceCssLength( realAttrs.width, width ) );
+					height && ( realAttrs.height = replaceCssLength( realAttrs.height, height ) );
+				}
+
+				return realElement;
+			}
+		}
+	};
+
+	var plugin = CKEDITOR.plugins.add( 'fakeobjects', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+
+		init: function( editor ) {
+			// Allow image with all styles and classes plus src, alt and title attributes.
+			// We need them when fakeobject is pasted.
+			editor.filter.allow( 'img[!data-cke-realelement,src,alt,title](*){*}', 'fakeobjects' );
+		},
+
+		afterInit: function( editor ) {
+			var dataProcessor = editor.dataProcessor,
+				htmlFilter = dataProcessor && dataProcessor.htmlFilter;
+
+			if ( htmlFilter )
+				htmlFilter.addRules( htmlFilterRules );
+		}
+	} );
+
+	/**
+	 * @member CKEDITOR.editor
+	 * @todo
+	 */
+	CKEDITOR.editor.prototype.createFakeElement = function( realElement, className, realElementType, isResizable ) {
+		var lang = this.lang.fakeobjects,
+			label = lang[ realElementType ] || lang.unknown;
+
+		var attributes = {
+			'class': className,
+			'data-cke-realelement': encodeURIComponent( realElement.getOuterHtml() ),
+			'data-cke-real-node-type': realElement.type,
+			alt: label,
+			title: label,
+			align: realElement.getAttribute( 'align' ) || ''
+		};
+
+		// Do not set "src" on high-contrast so the alt text is displayed. (#8945)
+		if ( !CKEDITOR.env.hc )
+			attributes.src = CKEDITOR.getUrl( plugin.path + 'images/spacer.gif' );
+
+		if ( realElementType )
+			attributes[ 'data-cke-real-element-type' ] = realElementType;
+
+		if ( isResizable ) {
+			attributes[ 'data-cke-resizable' ] = isResizable;
+
+			var fakeStyle = new cssStyle();
+
+			var width = realElement.getAttribute( 'width' ),
+				height = realElement.getAttribute( 'height' );
+
+			width && ( fakeStyle.rules.width = cssLength( width ) );
+			height && ( fakeStyle.rules.height = cssLength( height ) );
+			fakeStyle.populate( attributes );
+		}
+
+		return this.document.createElement( 'img', { attributes: attributes } );
+	};
+
+	/**
+	 * @member CKEDITOR.editor
+	 * @todo
+	 */
+	CKEDITOR.editor.prototype.createFakeParserElement = function( realElement, className, realElementType, isResizable ) {
+		var lang = this.lang.fakeobjects,
+			label = lang[ realElementType ] || lang.unknown,
+			html;
+
+		var writer = new CKEDITOR.htmlParser.basicWriter();
+		realElement.writeHtml( writer );
+		html = writer.getHtml();
+
+		var attributes = {
+			'class': className,
+			'data-cke-realelement': encodeURIComponent( html ),
+			'data-cke-real-node-type': realElement.type,
+			alt: label,
+			title: label,
+			align: realElement.attributes.align || ''
+		};
+
+		// Do not set "src" on high-contrast so the alt text is displayed. (#8945)
+		if ( !CKEDITOR.env.hc )
+			attributes.src = CKEDITOR.getUrl( plugin.path + 'images/spacer.gif' );
+
+		if ( realElementType )
+			attributes[ 'data-cke-real-element-type' ] = realElementType;
+
+		if ( isResizable ) {
+			attributes[ 'data-cke-resizable' ] = isResizable;
+			var realAttrs = realElement.attributes,
+				fakeStyle = new cssStyle();
+
+			var width = realAttrs.width,
+				height = realAttrs.height;
+
+			width != undefined && ( fakeStyle.rules.width = cssLength( width ) );
+			height != undefined && ( fakeStyle.rules.height = cssLength( height ) );
+			fakeStyle.populate( attributes );
+		}
+
+		return new CKEDITOR.htmlParser.element( 'img', attributes );
+	};
+
+	/**
+	 * @member CKEDITOR.editor
+	 * @todo
+	 */
+	CKEDITOR.editor.prototype.restoreRealElement = function( fakeElement ) {
+		if ( fakeElement.data( 'cke-real-node-type' ) != CKEDITOR.NODE_ELEMENT )
+			return null;
+
+		var element = CKEDITOR.dom.element.createFromHtml( decodeURIComponent( fakeElement.data( 'cke-realelement' ) ), this.document );
+
+		if ( fakeElement.data( 'cke-resizable' ) ) {
+			var width = fakeElement.getStyle( 'width' ),
+				height = fakeElement.getStyle( 'height' );
+
+			width && element.setAttribute( 'width', replaceCssLength( element.getAttribute( 'width' ), width ) );
+			height && element.setAttribute( 'height', replaceCssLength( element.getAttribute( 'height' ), height ) );
+		}
+
+		return element;
+	};
+
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/floatingspace/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/floatingspace/plugin.js
new file mode 100644
index 00000000..7434eb8f
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/floatingspace/plugin.js
@@ -0,0 +1,379 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	var floatSpaceTpl = CKEDITOR.addTemplate( 'floatcontainer', '<div' +
+			' id="cke_{name}"' +
+			' class="cke {id} cke_reset_all cke_chrome cke_editor_{name} cke_float cke_{langDir} ' + CKEDITOR.env.cssClass + '"' +
+			' dir="{langDir}"' +
+			' title="' + ( CKEDITOR.env.gecko ? ' ' : '' ) + '"' +
+			' lang="{langCode}"' +
+			' role="application"' +
+			' style="{style}"' +
+			' aria-labelledby="cke_{name}_arialbl"' +
+			'>' +
+				'<span id="cke_{name}_arialbl" class="cke_voice_label">{voiceLabel}</span>' +
+				'<div class="cke_inner">' +
+					'<div id="{topId}" class="cke_top" role="presentation">{content}</div>' +
+				'</div>' +
+			'</div>' ),
+		win = CKEDITOR.document.getWindow(),
+		pixelate = CKEDITOR.tools.cssLength;
+
+	CKEDITOR.plugins.add( 'floatingspace', {
+		init: function( editor ) {
+			// Add listener with lower priority than that in themedui creator.
+			// Thereby floatingspace will be created only if themedui wasn't used.
+			editor.on( 'loaded', function() {
+				attach( this );
+			}, null, null, 20 );
+		}
+	} );
+
+	function scrollOffset( side ) {
+		var pageOffset = side == 'left' ? 'pageXOffset' : 'pageYOffset',
+			docScrollOffset = side == 'left' ? 'scrollLeft' : 'scrollTop';
+
+		return ( pageOffset in win.$ ) ?
+				win.$[ pageOffset ]
+			:
+				CKEDITOR.document.$.documentElement[ docScrollOffset ];
+	}
+
+	function attach( editor ) {
+		var config = editor.config,
+
+			// Get the HTML for the predefined spaces.
+			topHtml = editor.fire( 'uiSpace', { space: 'top', html: '' } ).html,
+
+			// Re-positioning of the space.
+			layout = ( function() {
+				// Mode indicates the vertical aligning mode.
+				var mode, editable,
+					spaceRect, editorRect, viewRect, spaceHeight, pageScrollX,
+
+					// Allow minor adjustments of the float space from custom configs.
+					dockedOffsetX = config.floatSpaceDockedOffsetX || 0,
+					dockedOffsetY = config.floatSpaceDockedOffsetY || 0,
+					pinnedOffsetX = config.floatSpacePinnedOffsetX || 0,
+					pinnedOffsetY = config.floatSpacePinnedOffsetY || 0;
+
+				// Update the float space position.
+				function updatePos( pos, prop, val ) {
+					floatSpace.setStyle( prop, pixelate( val ) );
+					floatSpace.setStyle( 'position', pos );
+				}
+
+				// Change the current mode and update float space position accordingly.
+				function changeMode( newMode ) {
+					var editorPos = editable.getDocumentPosition();
+
+					switch ( newMode ) {
+						case 'top':
+							updatePos( 'absolute', 'top', editorPos.y - spaceHeight - dockedOffsetY );
+							break;
+						case 'pin':
+							updatePos( 'fixed', 'top', pinnedOffsetY );
+							break;
+						case 'bottom':
+							updatePos( 'absolute', 'top', editorPos.y + ( editorRect.height || editorRect.bottom - editorRect.top ) + dockedOffsetY );
+							break;
+					}
+
+					mode = newMode;
+				}
+
+				return function( evt ) {
+					// #10112 Do not fail on editable-less editor.
+					if ( !( editable = editor.editable() ) )
+						return;
+
+					// Show up the space on focus gain.
+					evt && evt.name == 'focus' && floatSpace.show();
+
+					// Reset the horizontal position for below measurement.
+					floatSpace.removeStyle( 'left' );
+					floatSpace.removeStyle( 'right' );
+
+					// Compute the screen position from the TextRectangle object would
+					// be very simple, even though the "width"/"height" property is not
+					// available for all, it's safe to figure that out from the rest.
+
+					// http://help.dottoro.com/ljgupwlp.php
+					spaceRect = floatSpace.getClientRect();
+					editorRect = editable.getClientRect();
+					viewRect = win.getViewPaneSize();
+					spaceHeight = spaceRect.height;
+					pageScrollX = scrollOffset( 'left' );
+
+					// We initialize it as pin mode.
+					if ( !mode ) {
+						mode = 'pin';
+						changeMode( 'pin' );
+						// Call for a refresh to the actual layout.
+						layout( evt );
+						return;
+					}
+
+					// +------------------------ Viewport -+ \
+					// |                                   |  |-> floatSpaceDockedOffsetY
+					// | ................................. | /
+					// |                                   |
+					// |   +------ Space -+                |
+					// |   |              |                |
+					// |   +--------------+                |
+					// |   +------------------ Editor -+   |
+					// |   |                           |   |
+					//
+					if ( spaceHeight + dockedOffsetY <= editorRect.top )
+						changeMode( 'top' );
+
+					//     +- - - - - - - - -  Editor -+
+					//     |                           |
+					// +------------------------ Viewport -+ \
+					// |   |                           |   |  |-> floatSpacePinnedOffsetY
+					// | ................................. | /
+					// |   +------ Space -+            |   |
+					// |   |              |            |   |
+					// |   +--------------+            |   |
+					// |   |                           |   |
+					// |   +---------------------------+   |
+					// +-----------------------------------+
+					//
+					else if ( spaceHeight + dockedOffsetY > viewRect.height - editorRect.bottom )
+						changeMode( 'pin' );
+
+					//     +- - - - - - - - -  Editor -+
+					//     |                           |
+					// +------------------------ Viewport -+ \
+					// |   |                           |   |  |-> floatSpacePinnedOffsetY
+					// | ................................. | /
+					// |   |                           |   |
+					// |   |                           |   |
+					// |   +---------------------------+   |
+					// |   +------ Space -+                |
+					// |   |              |                |
+					// |   +--------------+                |
+					//
+					else
+						changeMode( 'bottom' );
+
+					var mid = viewRect.width / 2,
+						alignSide =
+								( editorRect.left > 0 && editorRect.right < viewRect.width && editorRect.width > spaceRect.width ) ?
+										( editor.config.contentsLangDirection == 'rtl' ? 'right' : 'left' )
+									:
+										( mid - editorRect.left > editorRect.right - mid ? 'left' : 'right' ),
+						offset;
+
+					// (#9769) If viewport width is less than space width,
+					// make sure space never cross the left boundary of the viewport.
+					// In other words: top-left corner of the space is always visible.
+					if ( spaceRect.width > viewRect.width ) {
+						alignSide = 'left';
+						offset = 0;
+					}
+					else {
+						if ( alignSide == 'left' ) {
+							// If the space rect fits into viewport, align it
+							// to the left edge of editor:
+							//
+							// +------------------------ Viewport -+
+							// |                                   |
+							// |   +------------- Space -+         |
+							// |   |                     |         |
+							// |   +---------------------+         |
+							// |   +------------------ Editor -+   |
+							// |   |                           |   |
+							//
+							if ( editorRect.left > 0 )
+								offset = editorRect.left;
+
+							// If the left part of the editor is cut off by the left
+							// edge of the viewport, stick the space to the viewport:
+							//
+							//       +------------------------ Viewport -+
+							//       |                                   |
+							//       +---------------- Space -+          |
+							//       |                        |          |
+							//       +------------------------+          |
+							//  +----|------------- Editor -+            |
+							//  |    |                      |            |
+							//
+							else
+								offset = 0;
+						}
+						else {
+							// If the space rect fits into viewport, align it
+							// to the right edge of editor:
+							//
+							// +------------------------ Viewport -+
+							// |                                   |
+							// |         +------------- Space -+   |
+							// |         |                     |   |
+							// |         +---------------------+   |
+							// |   +------------------ Editor -+   |
+							// |   |                           |   |
+							//
+							if ( editorRect.right < viewRect.width )
+								offset = viewRect.width - editorRect.right;
+
+							// If the right part of the editor is cut off by the right
+							// edge of the viewport, stick the space to the viewport:
+							//
+							// +------------------------ Viewport -+
+							// |                                   |
+							// |             +------------- Space -+
+							// |             |                     |
+							// |             +---------------------+
+							// |                 +-----------------|- Editor -+
+							// |                 |                 |          |
+							//
+							else
+								offset = 0;
+						}
+
+						// (#9769) Finally, stick the space to the opposite side of
+						// the viewport when it's cut off horizontally on the left/right
+						// side like below.
+						//
+						// This trick reveals cut off space in some edge cases and
+						// hence it improves accessibility.
+						//
+						// +------------------------ Viewport -+
+						// |                                   |
+						// |              +--------------------|-- Space -+
+						// |              |                    |          |
+						// |              +--------------------|----------+
+						// |              +------- Editor -+   |
+						// |              |                |   |
+						//
+						//				becomes:
+						//
+						// +------------------------ Viewport -+
+						// |                                   |
+						// |   +----------------------- Space -+
+						// |   |                               |
+						// |   +-------------------------------+
+						// |              +------- Editor -+   |
+						// |              |                |   |
+						//
+						if ( offset + spaceRect.width > viewRect.width ) {
+							alignSide = alignSide == 'left' ? 'right' : 'left';
+							offset = 0;
+						}
+					}
+
+					// Pin mode is fixed, so don't include scroll-x.
+					// (#9903) For mode is "top" or "bottom", add opposite scroll-x for right-aligned space.
+					var scroll = mode == 'pin' ?
+							0
+						:
+							alignSide == 'left' ? pageScrollX : -pageScrollX;
+
+					floatSpace.setStyle( alignSide, pixelate( ( mode == 'pin' ? pinnedOffsetX : dockedOffsetX ) + offset + scroll ) );
+				};
+			} )();
+
+		if ( topHtml ) {
+			var floatSpace = CKEDITOR.document.getBody().append( CKEDITOR.dom.element.createFromHtml( floatSpaceTpl.output( {
+					content: topHtml,
+					id: editor.id,
+					langDir: editor.lang.dir,
+					langCode: editor.langCode,
+					name: editor.name,
+					style: 'display:none;z-index:' + ( config.baseFloatZIndex - 1 ),
+					topId: editor.ui.spaceId( 'top' ),
+					voiceLabel: editor.lang.editorPanel + ', ' + editor.name
+				} ) ) ),
+
+				// Use event buffers to reduce CPU load when tons of events are fired.
+				changeBuffer = CKEDITOR.tools.eventsBuffer( 500, layout ),
+				uiBuffer = CKEDITOR.tools.eventsBuffer( 100, layout );
+
+			// There's no need for the floatSpace to be selectable.
+			floatSpace.unselectable();
+
+			// Prevent clicking on non-buttons area of the space from blurring editor.
+			floatSpace.on( 'mousedown', function( evt ) {
+				evt = evt.data;
+				if ( !evt.getTarget().hasAscendant( 'a', 1 ) )
+					evt.preventDefault();
+			} );
+
+			editor.on( 'focus', function( evt ) {
+				layout( evt );
+				editor.on( 'change', changeBuffer.input );
+				win.on( 'scroll', uiBuffer.input );
+				win.on( 'resize', uiBuffer.input );
+			} );
+
+			editor.on( 'blur', function() {
+				floatSpace.hide();
+				editor.removeListener( 'change', changeBuffer.input );
+				win.removeListener( 'scroll', uiBuffer.input );
+				win.removeListener( 'resize', uiBuffer.input );
+			} );
+
+			editor.on( 'destroy', function() {
+				win.removeListener( 'scroll', uiBuffer.input );
+				win.removeListener( 'resize', uiBuffer.input );
+				floatSpace.clearCustomData();
+				floatSpace.remove();
+			} );
+
+			// Handle initial focus.
+			if ( editor.focusManager.hasFocus )
+				floatSpace.show();
+
+			// Register this UI space to the focus manager.
+			editor.focusManager.add( floatSpace, 1 );
+		}
+	}
+} )();
+
+/**
+ * Along with {@link #floatSpaceDockedOffsetY} it defines the
+ * amount of offset (in pixels) between float space and the editable left/right
+ * boundaries when space element is docked at either side of the editable.
+ *
+ *		config.floatSpaceDockedOffsetX = 10;
+ *
+ * @cfg {Number} [floatSpaceDockedOffsetX=0]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Along with {@link #floatSpaceDockedOffsetX} it defines the
+ * amount of offset (in pixels) between float space and the editable top/bottom
+ * boundaries when space element is docked at either side of the editable.
+ *
+ *		config.floatSpaceDockedOffsetY = 10;
+ *
+ * @cfg {Number} [floatSpaceDockedOffsetY=0]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Along with {@link #floatSpacePinnedOffsetY} it defines the
+ * amount of offset (in pixels) between float space and the view port boundaries
+ * when space element is pinned.
+ *
+ *		config.floatSpacePinnedOffsetX = 20;
+ *
+ * @cfg {Number} [floatSpacePinnedOffsetX=0]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Along with {@link #floatSpacePinnedOffsetX} it defines the
+ * amount of offset (in pixels) between float space and the view port boundaries
+ * when space element is pinned.
+ *
+ *		config.floatSpacePinnedOffsetY = 20;
+ *
+ * @cfg {Number} [floatSpacePinnedOffsetY=0]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/floatpanel/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/floatpanel/plugin.js
new file mode 100644
index 00000000..6a48c554
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/floatpanel/plugin.js
@@ -0,0 +1,548 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'floatpanel', {
+	requires: 'panel'
+} );
+
+( function() {
+	var panels = {};
+
+	function getPanel( editor, doc, parentElement, definition, level ) {
+		// Generates the panel key: docId-eleId-skinName-langDir[-uiColor][-CSSs][-level]
+		var key = CKEDITOR.tools.genKey( doc.getUniqueId(), parentElement.getUniqueId(), editor.lang.dir, editor.uiColor || '', definition.css || '', level || '' ),
+			panel = panels[ key ];
+
+		if ( !panel ) {
+			panel = panels[ key ] = new CKEDITOR.ui.panel( doc, definition );
+			panel.element = parentElement.append( CKEDITOR.dom.element.createFromHtml( panel.render( editor ), doc ) );
+
+			panel.element.setStyles( {
+				display: 'none',
+				position: 'absolute'
+			} );
+		}
+
+		return panel;
+	}
+
+	/**
+	 * Represents a floating panel UI element.
+	 *
+	 * It's reused by rich combos, color combos, menus, etc.
+	 * and it renders its content using {@link CKEDITOR.ui.panel}.
+	 *
+	 * @class
+	 * @todo
+	 */
+	CKEDITOR.ui.floatPanel = CKEDITOR.tools.createClass( {
+		/**
+		 * Creates a floatPanel class instance.
+		 *
+		 * @constructor
+		 * @param {CKEDITOR.editor} editor
+		 * @param {CKEDITOR.dom.element} parentElement
+		 * @param {Object} definition Definition of the panel that will be floating.
+		 * @param {Number} level
+		 */
+		$: function( editor, parentElement, definition, level ) {
+			definition.forceIFrame = 1;
+
+			// In case of editor with floating toolbar append panels that should float
+			// to the main UI element.
+			if ( definition.toolbarRelated && editor.elementMode == CKEDITOR.ELEMENT_MODE_INLINE )
+				parentElement = CKEDITOR.document.getById( 'cke_' + editor.name );
+
+			var doc = parentElement.getDocument(),
+				panel = getPanel( editor, doc, parentElement, definition, level || 0 ),
+				element = panel.element,
+				iframe = element.getFirst(),
+				that = this;
+
+			// Disable native browser menu. (#4825)
+			element.disableContextMenu();
+
+			this.element = element;
+
+			this._ = {
+				editor: editor,
+				// The panel that will be floating.
+				panel: panel,
+				parentElement: parentElement,
+				definition: definition,
+				document: doc,
+				iframe: iframe,
+				children: [],
+				dir: editor.lang.dir
+			};
+
+			editor.on( 'mode', hide );
+			editor.on( 'resize', hide );
+			// Window resize doesn't cause hide on blur. (#9800)
+			doc.getWindow().on( 'resize', hide );
+
+			// We need a wrapper because events implementation doesn't allow to attach
+			// one listener more than once for the same event on the same object.
+			// Remember that floatPanel#hide is shared between all instances.
+			function hide() {
+				that.hide();
+			}
+		},
+
+		proto: {
+			/**
+			 * @todo
+			 */
+			addBlock: function( name, block ) {
+				return this._.panel.addBlock( name, block );
+			},
+
+			/**
+			 * @todo
+			 */
+			addListBlock: function( name, multiSelect ) {
+				return this._.panel.addListBlock( name, multiSelect );
+			},
+
+			/**
+			 * @todo
+			 */
+			getBlock: function( name ) {
+				return this._.panel.getBlock( name );
+			},
+
+			/**
+			 * Shows panel block.
+			 *
+			 * @param {String} name
+			 * @param {CKEDITOR.dom.element} offsetParent Positioned parent.
+			 * @param {Number} corner
+			 *
+			 * * For LTR (left to right) oriented editor:
+			 *      * `1` = top-left
+			 *      * `2` = top-right
+			 *      * `3` = bottom-right
+			 *      * `4` = bottom-left
+			 * * For RTL (right to left):
+			 *      * `1` = top-right
+			 *      * `2` = top-left
+			 *      * `3` = bottom-left
+			 *      * `4` = bottom-right
+			 *
+			 * @param {Number} [offsetX=0]
+			 * @param {Number} [offsetY=0]
+			 * @param {Function} [callback] A callback function executed when block positioning is done.
+			 * @todo what do exactly these params mean (especially corner)?
+			 */
+			showBlock: function( name, offsetParent, corner, offsetX, offsetY, callback ) {
+				var panel = this._.panel,
+					block = panel.showBlock( name );
+
+				this.allowBlur( false );
+
+				// Record from where the focus is when open panel.
+				var editable = this._.editor.editable();
+				this._.returnFocus = editable.hasFocus ? editable : new CKEDITOR.dom.element( CKEDITOR.document.$.activeElement );
+
+				var element = this.element,
+					iframe = this._.iframe,
+					// Non IE prefer the event into a window object.
+					focused = CKEDITOR.env.ie ? iframe : new CKEDITOR.dom.window( iframe.$.contentWindow ),
+					doc = element.getDocument(),
+					positionedAncestor = this._.parentElement.getPositionedAncestor(),
+					position = offsetParent.getDocumentPosition( doc ),
+					positionedAncestorPosition = positionedAncestor ? positionedAncestor.getDocumentPosition( doc ) : { x: 0, y: 0 },
+					rtl = this._.dir == 'rtl',
+					left = position.x + ( offsetX || 0 ) - positionedAncestorPosition.x,
+					top = position.y + ( offsetY || 0 ) - positionedAncestorPosition.y;
+
+				// Floating panels are off by (-1px, 0px) in RTL mode. (#3438)
+				if ( rtl && ( corner == 1 || corner == 4 ) )
+					left += offsetParent.$.offsetWidth;
+				else if ( !rtl && ( corner == 2 || corner == 3 ) )
+					left += offsetParent.$.offsetWidth - 1;
+
+				if ( corner == 3 || corner == 4 )
+					top += offsetParent.$.offsetHeight - 1;
+
+				// Memorize offsetParent by it's ID.
+				this._.panel._.offsetParentId = offsetParent.getId();
+
+				element.setStyles( {
+					top: top + 'px',
+					left: 0,
+					display: ''
+				} );
+
+				// Don't use display or visibility style because we need to
+				// calculate the rendering layout later and focus the element.
+				element.setOpacity( 0 );
+
+				// To allow the context menu to decrease back their width
+				element.getFirst().removeStyle( 'width' );
+
+				// Report to focus manager.
+				this._.editor.focusManager.add( focused );
+
+				// Configure the IFrame blur event. Do that only once.
+				if ( !this._.blurSet ) {
+
+					// With addEventListener compatible browsers, we must
+					// useCapture when registering the focus/blur events to
+					// guarantee they will be firing in all situations. (#3068, #3222 )
+					CKEDITOR.event.useCapture = true;
+
+					focused.on( 'blur', function( ev ) {
+
+						// As we are using capture to register the listener,
+						// the blur event may get fired even when focusing
+						// inside the window itself, so we must ensure the
+						// target is out of it.
+						if ( !this.allowBlur() || ev.data.getPhase() != CKEDITOR.EVENT_PHASE_AT_TARGET )
+							return;
+
+						if ( this.visible && !this._.activeChild ) {
+							// Panel close is caused by user's navigating away the focus, e.g. click outside the panel.
+							// DO NOT restore focus in this case.
+							delete this._.returnFocus;
+							this.hide();
+						}
+					}, this );
+
+					focused.on( 'focus', function() {
+						this._.focused = true;
+						this.hideChild();
+						this.allowBlur( true );
+					}, this );
+
+					CKEDITOR.event.useCapture = false;
+
+					this._.blurSet = 1;
+				}
+
+				panel.onEscape = CKEDITOR.tools.bind( function( keystroke ) {
+					if ( this.onEscape && this.onEscape( keystroke ) === false )
+						return false;
+				}, this );
+
+				CKEDITOR.tools.setTimeout( function() {
+					var panelLoad = CKEDITOR.tools.bind( function() {
+						var target = element;
+
+						// Reset panel width as the new content can be narrower
+						// than the old one. (#9355)
+						target.removeStyle( 'width' );
+
+						if ( block.autoSize ) {
+							var panelDoc = block.element.getDocument();
+							var width = ( CKEDITOR.env.webkit? block.element : panelDoc.getBody() )[ '$' ].scrollWidth;
+
+							// Account for extra height needed due to IE quirks box model bug:
+							// http://en.wikipedia.org/wiki/Internet_Explorer_box_model_bug
+							// (#3426)
+							if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && width > 0 )
+								width += ( target.$.offsetWidth || 0 ) - ( target.$.clientWidth || 0 ) + 3;
+
+							// Add some extra pixels to improve the appearance.
+							width += 10;
+
+							target.setStyle( 'width', width + 'px' );
+
+							var height = block.element.$.scrollHeight;
+
+							// Account for extra height needed due to IE quirks box model bug:
+							// http://en.wikipedia.org/wiki/Internet_Explorer_box_model_bug
+							// (#3426)
+							if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && height > 0 )
+								height += ( target.$.offsetHeight || 0 ) - ( target.$.clientHeight || 0 ) + 3;
+
+							target.setStyle( 'height', height + 'px' );
+
+							// Fix IE < 8 visibility.
+							panel._.currentBlock.element.setStyle( 'display', 'none' ).removeStyle( 'display' );
+						} else
+							target.removeStyle( 'height' );
+
+						// Flip panel layout horizontally in RTL with known width.
+						if ( rtl )
+							left -= element.$.offsetWidth;
+
+						// Pop the style now for measurement.
+						element.setStyle( 'left', left + 'px' );
+
+						/* panel layout smartly fit the viewport size. */
+						var panelElement = panel.element,
+							panelWindow = panelElement.getWindow(),
+							rect = element.$.getBoundingClientRect(),
+							viewportSize = panelWindow.getViewPaneSize();
+
+						// Compensation for browsers that dont support "width" and "height".
+						var rectWidth = rect.width || rect.right - rect.left,
+							rectHeight = rect.height || rect.bottom - rect.top;
+
+						// Check if default horizontal layout is impossible.
+						var spaceAfter = rtl ? rect.right : viewportSize.width - rect.left,
+							spaceBefore = rtl ? viewportSize.width - rect.right : rect.left;
+
+						if ( rtl ) {
+							if ( spaceAfter < rectWidth ) {
+								// Flip to show on right.
+								if ( spaceBefore > rectWidth )
+									left += rectWidth;
+								// Align to window left.
+								else if ( viewportSize.width > rectWidth )
+									left = left - rect.left;
+								// Align to window right, never cutting the panel at right.
+								else
+									left = left - rect.right + viewportSize.width;
+							}
+						} else if ( spaceAfter < rectWidth ) {
+							// Flip to show on left.
+							if ( spaceBefore > rectWidth )
+								left -= rectWidth;
+							// Align to window right.
+							else if ( viewportSize.width > rectWidth )
+								left = left - rect.right + viewportSize.width;
+							// Align to window left, never cutting the panel at left.
+							else
+								left = left - rect.left;
+						}
+
+
+						// Check if the default vertical layout is possible.
+						var spaceBelow = viewportSize.height - rect.top,
+							spaceAbove = rect.top;
+
+						if ( spaceBelow < rectHeight ) {
+							// Flip to show above.
+							if ( spaceAbove > rectHeight )
+								top -= rectHeight;
+							// Align to window bottom.
+							else if ( viewportSize.height > rectHeight )
+								top = top - rect.bottom + viewportSize.height;
+							// Align to top, never cutting the panel at top.
+							else
+								top = top - rect.top;
+						}
+
+						// If IE is in RTL, we have troubles with absolute
+						// position and horizontal scrolls. Here we have a
+						// series of hacks to workaround it. (#6146)
+						if ( CKEDITOR.env.ie ) {
+							var offsetParent = new CKEDITOR.dom.element( element.$.offsetParent ),
+								scrollParent = offsetParent;
+
+							// Quirks returns <body>, but standards returns <html>.
+							if ( scrollParent.getName() == 'html' )
+								scrollParent = scrollParent.getDocument().getBody();
+
+							if ( scrollParent.getComputedStyle( 'direction' ) == 'rtl' ) {
+								// For IE8, there is not much logic on this, but it works.
+								if ( CKEDITOR.env.ie8Compat )
+									left -= element.getDocument().getDocumentElement().$.scrollLeft * 2;
+								else
+									left -= ( offsetParent.$.scrollWidth - offsetParent.$.clientWidth );
+							}
+						}
+
+						// Trigger the onHide event of the previously active panel to prevent
+						// incorrect styles from being applied (#6170)
+						var innerElement = element.getFirst(),
+							activePanel;
+						if ( ( activePanel = innerElement.getCustomData( 'activePanel' ) ) )
+							activePanel.onHide && activePanel.onHide.call( this, 1 );
+						innerElement.setCustomData( 'activePanel', this );
+
+						element.setStyles( {
+							top: top + 'px',
+							left: left + 'px'
+						} );
+						element.setOpacity( 1 );
+
+						callback && callback();
+					}, this );
+
+					panel.isLoaded ? panelLoad() : panel.onLoad = panelLoad;
+
+					CKEDITOR.tools.setTimeout( function() {
+						var scrollTop = CKEDITOR.env.webkit && CKEDITOR.document.getWindow().getScrollPosition().y;
+
+						// Focus the panel frame first, so blur gets fired.
+						this.focus();
+
+						// Focus the block now.
+						block.element.focus();
+
+						// #10623, #10951 - restore the viewport's scroll position after focusing list element.
+						if ( CKEDITOR.env.webkit )
+							CKEDITOR.document.getBody().$.scrollTop = scrollTop;
+
+						// We need this get fired manually because of unfired focus() function.
+						this.allowBlur( true );
+						this._.editor.fire( 'panelShow', this );
+					}, 0, this );
+				}, CKEDITOR.env.air ? 200 : 0, this );
+				this.visible = 1;
+
+				if ( this.onShow )
+					this.onShow.call( this );
+			},
+
+			/**
+			 * Restores last focused element or simply focus panel window.
+			 */
+			focus: function() {
+				// Webkit requires to blur any previous focused page element, in
+				// order to properly fire the "focus" event.
+				if ( CKEDITOR.env.webkit ) {
+					var active = CKEDITOR.document.getActive();
+					!active.equals( this._.iframe ) && active.$.blur();
+				}
+
+				// Restore last focused element or simply focus panel window.
+				var focus = this._.lastFocused || this._.iframe.getFrameDocument().getWindow();
+				focus.focus();
+			},
+
+			/**
+			 * @todo
+			 */
+			blur: function() {
+				var doc = this._.iframe.getFrameDocument(),
+					active = doc.getActive();
+
+				active.is( 'a' ) && ( this._.lastFocused = active );
+			},
+
+			/**
+			 * Hides panel.
+			 *
+			 * @todo
+			 */
+			hide: function( returnFocus ) {
+				if ( this.visible && ( !this.onHide || this.onHide.call( this ) !== true ) ) {
+					this.hideChild();
+					// Blur previously focused element. (#6671)
+					CKEDITOR.env.gecko && this._.iframe.getFrameDocument().$.activeElement.blur();
+					this.element.setStyle( 'display', 'none' );
+					this.visible = 0;
+					this.element.getFirst().removeCustomData( 'activePanel' );
+
+					// Return focus properly. (#6247)
+					var focusReturn = returnFocus && this._.returnFocus;
+					if ( focusReturn ) {
+						// Webkit requires focus moved out panel iframe first.
+						if ( CKEDITOR.env.webkit && focusReturn.type )
+							focusReturn.getWindow().$.focus();
+
+						focusReturn.focus();
+					}
+
+					delete this._.lastFocused;
+
+					this._.editor.fire( 'panelHide', this );
+				}
+			},
+
+			/**
+			 * @todo
+			 */
+			allowBlur: function( allow ) // Prevent editor from hiding the panel. #3222.
+			{
+				var panel = this._.panel;
+				if ( allow != undefined )
+					panel.allowBlur = allow;
+
+				return panel.allowBlur;
+			},
+
+			/**
+			 * Shows specified panel as a child of one block of this one.
+			 *
+			 * @param {CKEDITOR.ui.floatPanel} panel
+			 * @param {String} blockName
+			 * @param {CKEDITOR.dom.element} offsetParent Positioned parent.
+			 * @param {Number} corner
+			 *
+			 * * For LTR (left to right) oriented editor:
+			 *      * `1` = top-left
+			 *      * `2` = top-right
+			 *      * `3` = bottom-right
+			 *      * `4` = bottom-left
+			 * * For RTL (right to left):
+			 *      * `1` = top-right
+			 *      * `2` = top-left
+			 *      * `3` = bottom-left
+			 *      * `4` = bottom-right
+			 *
+			 * @param {Number} [offsetX=0]
+			 * @param {Number} [offsetY=0]
+			 * @todo
+			 */
+			showAsChild: function( panel, blockName, offsetParent, corner, offsetX, offsetY ) {
+				// Skip reshowing of child which is already visible.
+				if ( this._.activeChild == panel && panel._.panel._.offsetParentId == offsetParent.getId() )
+					return;
+
+				this.hideChild();
+
+				panel.onHide = CKEDITOR.tools.bind( function() {
+					// Use a timeout, so we give time for this menu to get
+					// potentially focused.
+					CKEDITOR.tools.setTimeout( function() {
+						if ( !this._.focused )
+							this.hide();
+					}, 0, this );
+				}, this );
+
+				this._.activeChild = panel;
+				this._.focused = false;
+
+				panel.showBlock( blockName, offsetParent, corner, offsetX, offsetY );
+				this.blur();
+
+				/* #3767 IE: Second level menu may not have borders */
+				if ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) {
+					setTimeout( function() {
+						panel.element.getChild( 0 ).$.style.cssText += '';
+					}, 100 );
+				}
+			},
+
+			/**
+			 * @todo
+			 */
+			hideChild: function( restoreFocus ) {
+				var activeChild = this._.activeChild;
+
+				if ( activeChild ) {
+					delete activeChild.onHide;
+					delete this._.activeChild;
+					activeChild.hide();
+
+					// At this point focus should be moved back to parent panel.
+					restoreFocus && this.focus();
+				}
+			}
+		}
+	} );
+
+	CKEDITOR.on( 'instanceDestroyed', function() {
+		var isLastInstance = CKEDITOR.tools.isEmpty( CKEDITOR.instances );
+
+		for ( var i in panels ) {
+			var panel = panels[ i ];
+			// Safe to destroy it since there're no more instances.(#4241)
+			if ( isLastInstance )
+				panel.destroy();
+			// Panel might be used by other instances, just hide them.(#4552)
+			else
+				panel.element.hide();
+		}
+		// Remove the registration.
+		isLastInstance && ( panels = {} );
+
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/font/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/font/plugin.js
new file mode 100644
index 00000000..0cfde310
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/font/plugin.js
@@ -0,0 +1,230 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	function addCombo( editor, comboName, styleType, lang, entries, defaultLabel, styleDefinition, order ) {
+		var config = editor.config,
+			style = new CKEDITOR.style( styleDefinition );
+
+		// Gets the list of fonts from the settings.
+		var names = entries.split( ';' ),
+			values = [];
+
+		// Create style objects for all fonts.
+		var styles = {};
+		for ( var i = 0; i < names.length; i++ ) {
+			var parts = names[ i ];
+
+			if ( parts ) {
+				parts = parts.split( '/' );
+
+				var vars = {},
+					name = names[ i ] = parts[ 0 ];
+
+				vars[ styleType ] = values[ i ] = parts[ 1 ] || name;
+
+				styles[ name ] = new CKEDITOR.style( styleDefinition, vars );
+				styles[ name ]._.definition.name = name;
+			} else
+				names.splice( i--, 1 );
+		}
+
+		editor.ui.addRichCombo( comboName, {
+			label: lang.label,
+			title: lang.panelTitle,
+			toolbar: 'styles,' + order,
+			allowedContent: style,
+			requiredContent: style,
+
+			panel: {
+				css: [ CKEDITOR.skin.getPath( 'editor' ) ].concat( config.contentsCss ),
+				multiSelect: false,
+				attributes: { 'aria-label': lang.panelTitle }
+			},
+
+			init: function() {
+				this.startGroup( lang.panelTitle );
+
+				for ( var i = 0; i < names.length; i++ ) {
+					var name = names[ i ];
+
+					// Add the tag entry to the panel list.
+					this.add( name, styles[ name ].buildPreview(), name );
+				}
+			},
+
+			onClick: function( value ) {
+				editor.focus();
+				editor.fire( 'saveSnapshot' );
+
+				var style = styles[ value ];
+
+				editor[ this.getValue() == value ? 'removeStyle' : 'applyStyle' ]( style );
+				editor.fire( 'saveSnapshot' );
+			},
+
+			onRender: function() {
+				editor.on( 'selectionChange', function( ev ) {
+					var currentValue = this.getValue();
+
+					var elementPath = ev.data.path,
+						elements = elementPath.elements;
+
+					// For each element into the elements path.
+					for ( var i = 0, element; i < elements.length; i++ ) {
+						element = elements[ i ];
+
+						// Check if the element is removable by any of
+						// the styles.
+						for ( var value in styles ) {
+							if ( styles[ value ].checkElementMatch( element, true ) ) {
+								if ( value != currentValue )
+									this.setValue( value );
+								return;
+							}
+						}
+					}
+
+					// If no styles match, just empty it.
+					this.setValue( '', defaultLabel );
+				}, this );
+			},
+
+			refresh: function() {
+				if ( !editor.activeFilter.check( style ) )
+					this.setState( CKEDITOR.TRISTATE_DISABLED );
+			}
+		} );
+	}
+
+	CKEDITOR.plugins.add( 'font', {
+		requires: 'richcombo',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			var config = editor.config;
+
+			addCombo( editor, 'Font', 'family', editor.lang.font, config.font_names, config.font_defaultLabel, config.font_style, 30 );
+			addCombo( editor, 'FontSize', 'size', editor.lang.font.fontSize, config.fontSize_sizes, config.fontSize_defaultLabel, config.fontSize_style, 40 );
+		}
+	} );
+} )();
+
+/**
+ * The list of fonts names to be displayed in the Font combo in the toolbar.
+ * Entries are separated by semi-colons (`';'`), while it's possible to have more
+ * than one font for each entry, in the HTML way (separated by comma).
+ *
+ * A display name may be optionally defined by prefixing the entries with the
+ * name and the slash character. For example, `'Arial/Arial, Helvetica, sans-serif'`
+ * will be displayed as `'Arial'` in the list, but will be outputted as
+ * `'Arial, Helvetica, sans-serif'`.
+ *
+ *		config.font_names =
+ *			'Arial/Arial, Helvetica, sans-serif;' +
+ *			'Times New Roman/Times New Roman, Times, serif;' +
+ *			'Verdana';
+ *
+ *		config.font_names = 'Arial;Times New Roman;Verdana';
+ *
+ * @cfg {String} [font_names=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.font_names = 'Arial/Arial, Helvetica, sans-serif;' +
+	'Comic Sans MS/Comic Sans MS, cursive;' +
+	'Courier New/Courier New, Courier, monospace;' +
+	'Georgia/Georgia, serif;' +
+	'Lucida Sans Unicode/Lucida Sans Unicode, Lucida Grande, sans-serif;' +
+	'Tahoma/Tahoma, Geneva, sans-serif;' +
+	'Times New Roman/Times New Roman, Times, serif;' +
+	'Trebuchet MS/Trebuchet MS, Helvetica, sans-serif;' +
+	'Verdana/Verdana, Geneva, sans-serif';
+
+/**
+ * The text to be displayed in the Font combo is none of the available values
+ * matches the current cursor position or text selection.
+ *
+ *		// If the default site font is Arial, we may making it more explicit to the end user.
+ *		config.font_defaultLabel = 'Arial';
+ *
+ * @cfg {String} [font_defaultLabel='']
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.font_defaultLabel = '';
+
+/**
+ * The style definition to be used to apply the font in the text.
+ *
+ *		// This is actually the default value for it.
+ *		config.font_style = {
+ *			element:		'span',
+ *			styles:			{ 'font-family': '#(family)' },
+ *			overrides:		[ { element: 'font', attributes: { 'face': null } } ]
+ *     };
+ *
+ * @cfg {Object} [font_style=see example]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.font_style = {
+	element: 'span',
+	styles: { 'font-family': '#(family)' },
+	overrides: [ {
+		element: 'font', attributes: { 'face': null }
+	} ]
+};
+
+/**
+ * The list of fonts size to be displayed in the Font Size combo in the
+ * toolbar. Entries are separated by semi-colons (`';'`).
+ *
+ * Any kind of "CSS like" size can be used, like `'12px'`, `'2.3em'`, `'130%'`,
+ * `'larger'` or `'x-small'`.
+ *
+ * A display name may be optionally defined by prefixing the entries with the
+ * name and the slash character. For example, `'Bigger Font/14px'` will be
+ * displayed as `'Bigger Font'` in the list, but will be outputted as `'14px'`.
+ *
+ *		config.fontSize_sizes = '16/16px;24/24px;48/48px;';
+ *
+ *		config.fontSize_sizes = '12px;2.3em;130%;larger;x-small';
+ *
+ *		config.fontSize_sizes = '12 Pixels/12px;Big/2.3em;30 Percent More/130%;Bigger/larger;Very Small/x-small';
+ *
+ * @cfg {String} [fontSize_sizes=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.fontSize_sizes = '8/8px;9/9px;10/10px;11/11px;12/12px;14/14px;16/16px;18/18px;20/20px;22/22px;24/24px;26/26px;28/28px;36/36px;48/48px;72/72px';
+
+/**
+ * The text to be displayed in the Font Size combo is none of the available
+ * values matches the current cursor position or text selection.
+ *
+ *		// If the default site font size is 12px, we may making it more explicit to the end user.
+ *		config.fontSize_defaultLabel = '12px';
+ *
+ * @cfg {String} [fontSize_defaultLabel='']
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.fontSize_defaultLabel = '';
+
+/**
+ * The style definition to be used to apply the font size in the text.
+ *
+ *		// This is actually the default value for it.
+ *		config.fontSize_style = {
+ *			element:		'span',
+ *			styles:			{ 'font-size': '#(size)' },
+ *			overrides:		[ { element :'font', attributes: { 'size': null } } ]
+ *		};
+ *
+ * @cfg {Object} [fontSize_style=see example]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.fontSize_style = {
+	element: 'span',
+	styles: { 'font-size': '#(size)' },
+	overrides: [ {
+		element: 'font', attributes: { 'size': null }
+	} ]
+};
diff --git a/lam/templates/lib/extra/ckeditor/plugins/format/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/format/plugin.js
new file mode 100644
index 00000000..5d1377f4
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/format/plugin.js
@@ -0,0 +1,244 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'format', {
+	requires: 'richcombo',
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		if ( editor.blockless )
+			return;
+
+		var config = editor.config,
+			lang = editor.lang.format;
+
+		// Gets the list of tags from the settings.
+		var tags = config.format_tags.split( ';' );
+
+		// Create style objects for all defined styles.
+		var styles = {},
+			stylesCount = 0,
+			allowedContent = [];
+		for ( var i = 0; i < tags.length; i++ ) {
+			var tag = tags[ i ];
+			var style = new CKEDITOR.style( config[ 'format_' + tag ] );
+			if ( !editor.filter.customConfig || editor.filter.check( style ) ) {
+				stylesCount++;
+				styles[ tag ] = style;
+				styles[ tag ]._.enterMode = editor.config.enterMode;
+				allowedContent.push( style );
+			}
+		}
+
+		// Hide entire combo when all formats are rejected.
+		if ( stylesCount === 0 )
+			return;
+
+		editor.ui.addRichCombo( 'Format', {
+			label: lang.label,
+			title: lang.panelTitle,
+			toolbar: 'styles,20',
+			allowedContent: allowedContent,
+
+			panel: {
+				css: [ CKEDITOR.skin.getPath( 'editor' ) ].concat( config.contentsCss ),
+				multiSelect: false,
+				attributes: { 'aria-label': lang.panelTitle }
+			},
+
+			init: function() {
+				this.startGroup( lang.panelTitle );
+
+				for ( var tag in styles ) {
+					var label = lang[ 'tag_' + tag ];
+
+					// Add the tag entry to the panel list.
+					this.add( tag, styles[ tag ].buildPreview( label ), label );
+				}
+			},
+
+			onClick: function( value ) {
+				editor.focus();
+				editor.fire( 'saveSnapshot' );
+
+				var style = styles[ value ],
+					elementPath = editor.elementPath();
+
+				editor[ style.checkActive( elementPath ) ? 'removeStyle' : 'applyStyle' ]( style );
+
+				// Save the undo snapshot after all changes are affected. (#4899)
+				setTimeout( function() {
+					editor.fire( 'saveSnapshot' );
+				}, 0 );
+			},
+
+			onRender: function() {
+				editor.on( 'selectionChange', function( ev ) {
+					var currentTag = this.getValue(),
+						elementPath = ev.data.path;
+
+					this.refresh();
+
+					for ( var tag in styles ) {
+						if ( styles[ tag ].checkActive( elementPath ) ) {
+							if ( tag != currentTag )
+								this.setValue( tag, editor.lang.format[ 'tag_' + tag ] );
+							return;
+						}
+					}
+
+					// If no styles match, just empty it.
+					this.setValue( '' );
+
+				}, this );
+			},
+
+			onOpen: function() {
+				this.showAll();
+				for ( var name in styles ) {
+					var style = styles[ name ];
+
+					// Check if that style is enabled in activeFilter.
+					if ( !editor.activeFilter.check( style ) )
+						this.hideItem( name );
+
+				}
+			},
+
+			refresh: function() {
+				var elementPath = editor.elementPath();
+
+				if ( !elementPath )
+						return;
+
+				// Check if element path contains 'p' element.
+				if ( !elementPath.isContextFor( 'p' ) ) {
+					this.setState( CKEDITOR.TRISTATE_DISABLED );
+					return;
+				}
+
+				// Check if there is any available style.
+				for ( var name in styles ) {
+					if ( editor.activeFilter.check( styles[ name ] ) )
+						return;
+				}
+				this.setState( CKEDITOR.TRISTATE_DISABLED );
+			}
+		} );
+	}
+} );
+
+/**
+ * A list of semi colon separated style names (by default tags) representing
+ * the style definition for each entry to be displayed in the Format combo in
+ * the toolbar. Each entry must have its relative definition configuration in a
+ * setting named `'format_(tagName)'`. For example, the `'p'` entry has its
+ * definition taken from `config.format_p`.
+ *
+ *		config.format_tags = 'p;h2;h3;pre';
+ *
+ * @cfg {String} [format_tags='p;h1;h2;h3;h4;h5;h6;pre;address;div']
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_tags = 'p;h1;h2;h3;h4;h5;h6;pre;address;div';
+
+/**
+ * The style definition to be used to apply the `'Normal'` format.
+ *
+ *		config.format_p = { element: 'p', attributes: { 'class': 'normalPara' } };
+ *
+ * @cfg {Object} [format_p={ element: 'p' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_p = { element: 'p' };
+
+/**
+ * The style definition to be used to apply the `'Normal (DIV)'` format.
+ *
+ *		config.format_div = { element: 'div', attributes: { 'class': 'normalDiv' } };
+ *
+ * @cfg {Object} [format_div={ element: 'div' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_div = { element: 'div' };
+
+/**
+ * The style definition to be used to apply the `'Formatted'` format.
+ *
+ *		config.format_pre = { element: 'pre', attributes: { 'class': 'code' } };
+ *
+ * @cfg {Object} [format_pre={ element: 'pre' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_pre = { element: 'pre' };
+
+/**
+ * The style definition to be used to apply the `'Address'` format.
+ *
+ *		config.format_address = { element: 'address', attributes: { 'class': 'styledAddress' } };
+ *
+ * @cfg {Object} [format_address={ element: 'address' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_address = { element: 'address' };
+
+/**
+ * The style definition to be used to apply the `'Heading 1'` format.
+ *
+ *		config.format_h1 = { element: 'h1', attributes: { 'class': 'contentTitle1' } };
+ *
+ * @cfg {Object} [format_h1={ element: 'h1' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h1 = { element: 'h1' };
+
+/**
+ * The style definition to be used to apply the `'Heading 2'` format.
+ *
+ *		config.format_h2 = { element: 'h2', attributes: { 'class': 'contentTitle2' } };
+ *
+ * @cfg {Object} [format_h2={ element: 'h2' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h2 = { element: 'h2' };
+
+/**
+ * The style definition to be used to apply the `'Heading 3'` format.
+ *
+ *		config.format_h3 = { element: 'h3', attributes: { 'class': 'contentTitle3' } };
+ *
+ * @cfg {Object} [format_h3={ element: 'h3' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h3 = { element: 'h3' };
+
+/**
+ * The style definition to be used to apply the `'Heading 4'` format.
+ *
+ *		config.format_h4 = { element: 'h4', attributes: { 'class': 'contentTitle4' } };
+ *
+ * @cfg {Object} [format_h4={ element: 'h4' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h4 = { element: 'h4' };
+
+/**
+ * The style definition to be used to apply the `'Heading 5'` format.
+ *
+ *		config.format_h5 = { element: 'h5', attributes: { 'class': 'contentTitle5' } };
+ *
+ * @cfg {Object} [format_h5={ element: 'h5' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h5 = { element: 'h5' };
+
+/**
+ * The style definition to be used to apply the `'Heading 6'` format.
+ *
+ *		config.format_h6 = { element: 'h6', attributes: { 'class': 'contentTitle6' } };
+ *
+ * @cfg {Object} [format_h6={ element: 'h6' }]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.format_h6 = { element: 'h6' };
diff --git a/lam/templates/lib/extra/ckeditor/plugins/horizontalrule/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/horizontalrule/plugin.js
new file mode 100644
index 00000000..48b843e8
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/horizontalrule/plugin.js
@@ -0,0 +1,41 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Horizontal Rule plugin.
+ */
+
+( function() {
+	var horizontalruleCmd = {
+		canUndo: false, // The undo snapshot will be handled by 'insertElement'.
+		exec: function( editor ) {
+			var hr = editor.document.createElement( 'hr' );
+			editor.insertElement( hr );
+		},
+
+		allowedContent: 'hr',
+		requiredContent: 'hr'
+	};
+
+	var pluginName = 'horizontalrule';
+
+	// Register a plugin named "horizontalrule".
+	CKEDITOR.plugins.add( pluginName, {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'horizontalrule', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			if ( editor.blockless )
+				return;
+
+			editor.addCommand( pluginName, horizontalruleCmd );
+			editor.ui.addButton && editor.ui.addButton( 'HorizontalRule', {
+				label: editor.lang.horizontalrule.toolbar,
+				command: pluginName,
+				toolbar: 'insert,40'
+			} );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/htmlwriter/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/htmlwriter/plugin.js
new file mode 100644
index 00000000..cc2827f3
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/htmlwriter/plugin.js
@@ -0,0 +1,359 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'htmlwriter', {
+	init: function( editor ) {
+		var writer = new CKEDITOR.htmlWriter();
+
+		writer.forceSimpleAmpersand = editor.config.forceSimpleAmpersand;
+		writer.indentationChars = editor.config.dataIndentationChars || '\t';
+
+		// Overwrite default basicWriter initialized in hmtlDataProcessor constructor.
+		editor.dataProcessor.writer = writer;
+	}
+} );
+
+/**
+ * Class used to write HTML data.
+ *
+ *		var writer = new CKEDITOR.htmlWriter();
+ *		writer.openTag( 'p' );
+ *		writer.attribute( 'class', 'MyClass' );
+ *		writer.openTagClose( 'p' );
+ *		writer.text( 'Hello' );
+ *		writer.closeTag( 'p' );
+ *		alert( writer.getHtml() ); // '<p class="MyClass">Hello</p>'
+ *
+ * @class
+ * @extends CKEDITOR.htmlParser.basicWriter
+ */
+CKEDITOR.htmlWriter = CKEDITOR.tools.createClass( {
+	base: CKEDITOR.htmlParser.basicWriter,
+
+	/**
+	 * Creates a htmlWriter class instance.
+	 *
+	 * @constructor
+	 */
+	$: function() {
+		// Call the base contructor.
+		this.base();
+
+		/**
+		 * The characters to be used for each identation step.
+		 *
+		 *		// Use tab for indentation.
+		 *		editorInstance.dataProcessor.writer.indentationChars = '\t';
+		 */
+		this.indentationChars = '\t';
+
+		/**
+		 * The characters to be used to close "self-closing" elements, like `<br>` or `<img>`.
+		 *
+		 *		// Use HTML4 notation for self-closing elements.
+		 *		editorInstance.dataProcessor.writer.selfClosingEnd = '>';
+		 */
+		this.selfClosingEnd = ' />';
+
+		/**
+		 * The characters to be used for line breaks.
+		 *
+		 *		// Use CRLF for line breaks.
+		 *		editorInstance.dataProcessor.writer.lineBreakChars = '\r\n';
+		 */
+		this.lineBreakChars = '\n';
+
+		this.sortAttributes = 1;
+
+		this._.indent = 0;
+		this._.indentation = '';
+		// Indicate preformatted block context status. (#5789)
+		this._.inPre = 0;
+		this._.rules = {};
+
+		var dtd = CKEDITOR.dtd;
+
+		for ( var e in CKEDITOR.tools.extend( {}, dtd.$nonBodyContent, dtd.$block, dtd.$listItem, dtd.$tableContent ) ) {
+			this.setRules( e, {
+				indent: !dtd[ e ][ '#' ],
+				breakBeforeOpen: 1,
+				breakBeforeClose: !dtd[ e ][ '#' ],
+				breakAfterClose: 1,
+				needsSpace: ( e in dtd.$block ) && !( e in { li: 1, dt: 1, dd: 1 } )
+			} );
+		}
+
+		this.setRules( 'br', { breakAfterOpen: 1 } );
+
+		this.setRules( 'title', {
+			indent: 0,
+			breakAfterOpen: 0
+		} );
+
+		this.setRules( 'style', {
+			indent: 0,
+			breakBeforeClose: 1
+		} );
+
+		this.setRules( 'pre', {
+			breakAfterOpen: 1, // Keep line break after the opening tag
+			indent: 0 // Disable indentation on <pre>.
+		} );
+	},
+
+	proto: {
+		/**
+		 * Writes the tag opening part for a opener tag.
+		 *
+		 *		// Writes '<p'.
+		 *		writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 * @param {Object} attributes The attributes defined for this tag. The
+		 * attributes could be used to inspect the tag.
+		 */
+		openTag: function( tagName, attributes ) {
+			var rules = this._.rules[ tagName ];
+
+			if ( this._.afterCloser && rules && rules.needsSpace && this._.needsSpace )
+				this._.output.push( '\n' );
+
+			if ( this._.indent )
+				this.indentation();
+			// Do not break if indenting.
+			else if ( rules && rules.breakBeforeOpen ) {
+				this.lineBreak();
+				this.indentation();
+			}
+
+			this._.output.push( '<', tagName );
+
+			this._.afterCloser = 0;
+		},
+
+		/**
+		 * Writes the tag closing part for a opener tag.
+		 *
+		 *		// Writes '>'.
+		 *		writer.openTagClose( 'p', false );
+		 *
+		 *		// Writes ' />'.
+		 *		writer.openTagClose( 'br', true );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 * @param {Boolean} isSelfClose Indicates that this is a self-closing tag,
+		 * like `<br>` or `<img>`.
+		 */
+		openTagClose: function( tagName, isSelfClose ) {
+			var rules = this._.rules[ tagName ];
+
+			if ( isSelfClose ) {
+				this._.output.push( this.selfClosingEnd );
+
+				if ( rules && rules.breakAfterClose )
+					this._.needsSpace = rules.needsSpace;
+			} else {
+				this._.output.push( '>' );
+
+				if ( rules && rules.indent )
+					this._.indentation += this.indentationChars;
+			}
+
+			if ( rules && rules.breakAfterOpen )
+				this.lineBreak();
+			tagName == 'pre' && ( this._.inPre = 1 );
+		},
+
+		/**
+		 * Writes an attribute. This function should be called after opening the
+		 * tag with {@link #openTagClose}.
+		 *
+		 *		// Writes ' class="MyClass"'.
+		 *		writer.attribute( 'class', 'MyClass' );
+		 *
+		 * @param {String} attName The attribute name.
+		 * @param {String} attValue The attribute value.
+		 */
+		attribute: function( attName, attValue ) {
+
+			if ( typeof attValue == 'string' ) {
+				this.forceSimpleAmpersand && ( attValue = attValue.replace( /&amp;/g, '&' ) );
+				// Browsers don't always escape special character in attribute values. (#4683, #4719).
+				attValue = CKEDITOR.tools.htmlEncodeAttr( attValue );
+			}
+
+			this._.output.push( ' ', attName, '="', attValue, '"' );
+		},
+
+		/**
+		 * Writes a closer tag.
+		 *
+		 *		// Writes '</p>'.
+		 *		writer.closeTag( 'p' );
+		 *
+		 * @param {String} tagName The element name for this tag.
+		 */
+		closeTag: function( tagName ) {
+			var rules = this._.rules[ tagName ];
+
+			if ( rules && rules.indent )
+				this._.indentation = this._.indentation.substr( this.indentationChars.length );
+
+			if ( this._.indent )
+				this.indentation();
+			// Do not break if indenting.
+			else if ( rules && rules.breakBeforeClose ) {
+				this.lineBreak();
+				this.indentation();
+			}
+
+			this._.output.push( '</', tagName, '>' );
+			tagName == 'pre' && ( this._.inPre = 0 );
+
+			if ( rules && rules.breakAfterClose ) {
+				this.lineBreak();
+				this._.needsSpace = rules.needsSpace;
+			}
+
+			this._.afterCloser = 1;
+		},
+
+		/**
+		 * Writes text.
+		 *
+		 *		// Writes 'Hello Word'.
+		 *		writer.text( 'Hello Word' );
+		 *
+		 * @param {String} text The text value
+		 */
+		text: function( text ) {
+			if ( this._.indent ) {
+				this.indentation();
+				!this._.inPre && ( text = CKEDITOR.tools.ltrim( text ) );
+			}
+
+			this._.output.push( text );
+		},
+
+		/**
+		 * Writes a comment.
+		 *
+		 *		// Writes "<!-- My comment -->".
+		 *		writer.comment( ' My comment ' );
+		 *
+		 * @param {String} comment The comment text.
+		 */
+		comment: function( comment ) {
+			if ( this._.indent )
+				this.indentation();
+
+			this._.output.push( '<!--', comment, '-->' );
+		},
+
+		/**
+		 * Writes a line break. It uses the {@link #lineBreakChars} property for it.
+		 *
+		 *		// Writes '\n' (e.g.).
+		 *		writer.lineBreak();
+		 */
+		lineBreak: function() {
+			if ( !this._.inPre && this._.output.length > 0 )
+				this._.output.push( this.lineBreakChars );
+			this._.indent = 1;
+		},
+
+		/**
+		 * Writes the current indentation chars. It uses the {@link #indentationChars}
+		 * property, repeating it for the current indentation steps.
+		 *
+		 *		// Writes '\t' (e.g.).
+		 *		writer.indentation();
+		 */
+		indentation: function() {
+			if ( !this._.inPre && this._.indentation )
+				this._.output.push( this._.indentation );
+			this._.indent = 0;
+		},
+
+		/**
+		 * Empties the current output buffer. It also brings back the default
+		 * values of the writer flags.
+		 *
+		 *		writer.reset();
+		 */
+		reset: function() {
+			this._.output = [];
+			this._.indent = 0;
+			this._.indentation = '';
+			this._.afterCloser = 0;
+			this._.inPre = 0;
+		},
+
+		/**
+		 * Sets formatting rules for a give element. The possible rules are:
+		 *
+		 * * `indent`: indent the element contents.
+		 * * `breakBeforeOpen`: break line before the opener tag for this element.
+		 * * `breakAfterOpen`: break line after the opener tag for this element.
+		 * * `breakBeforeClose`: break line before the closer tag for this element.
+		 * * `breakAfterClose`: break line after the closer tag for this element.
+		 *
+		 * All rules default to `false`. Each call to the function overrides
+		 * already present rules, leaving the undefined untouched.
+		 *
+		 * By default, all elements available in the {@link CKEDITOR.dtd#$block},
+		 * {@link CKEDITOR.dtd#$listItem} and {@link CKEDITOR.dtd#$tableContent}
+		 * lists have all the above rules set to `true`. Additionaly, the `<br>`
+		 * element has the `breakAfterOpen` set to `true`.
+		 *
+		 *		// Break line before and after "img" tags.
+		 *		writer.setRules( 'img', {
+		 *			breakBeforeOpen: true
+		 *			breakAfterOpen: true
+		 *		} );
+		 *
+		 *		// Reset the rules for the "h1" tag.
+		 *		writer.setRules( 'h1', {} );
+		 *
+		 * @param {String} tagName The element name to which set the rules.
+		 * @param {Object} rules An object containing the element rules.
+		 */
+		setRules: function( tagName, rules ) {
+			var currentRules = this._.rules[ tagName ];
+
+			if ( currentRules )
+				CKEDITOR.tools.extend( currentRules, rules, true );
+			else
+				this._.rules[ tagName ] = rules;
+		}
+	}
+} );
+
+/**
+ * Whether to force using `'&'` instead of `'&amp;'` in elements attributes
+ * values, it's not recommended to change this setting for compliance with the
+ * W3C XHTML 1.0 standards ([C.12, XHTML 1.0](http://www.w3.org/TR/xhtml1/#C_12)).
+ *
+ *		// Use `'&'` instead of `'&amp;'`
+ *		CKEDITOR.config.forceSimpleAmpersand = true;
+ *
+ * @cfg {Boolean} [forceSimpleAmpersand=false]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The characters to be used for indenting the HTML produced by the editor.
+ * Using characters different than `' '` (space) and `'\t'` (tab) is definitely
+ * a bad idea as it'll mess the code.
+ *
+ *		// No indentation.
+ *		CKEDITOR.config.dataIndentationChars = '';
+ *
+ *		// Use two spaces for indentation.
+ *		CKEDITOR.config.dataIndentationChars = '  ';
+ *
+ * @cfg {String} [dataIndentationChars='\t']
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/iframe/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/iframe/plugin.js
new file mode 100644
index 00000000..f98ea0bf
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/iframe/plugin.js
@@ -0,0 +1,83 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'iframe', {
+		requires: 'dialog,fakeobjects',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'iframe', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		onLoad: function() {
+			CKEDITOR.addCss( 'img.cke_iframe' +
+				'{' +
+					'background-image: url(' + CKEDITOR.getUrl( this.path + 'images/placeholder.png' ) + ');' +
+					'background-position: center center;' +
+					'background-repeat: no-repeat;' +
+					'border: 1px solid #a9a9a9;' +
+					'width: 80px;' +
+					'height: 80px;' +
+				'}'
+				);
+		},
+		init: function( editor ) {
+			var pluginName = 'iframe',
+				lang = editor.lang.iframe,
+				allowed = 'iframe[align,longdesc,frameborder,height,name,scrolling,src,title,width]';
+
+			if ( editor.plugins.dialogadvtab )
+				allowed += ';iframe' + editor.plugins.dialogadvtab.allowedContent( { id: 1, classes: 1, styles: 1 } );
+
+			CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/iframe.js' );
+			editor.addCommand( pluginName, new CKEDITOR.dialogCommand( pluginName, {
+				allowedContent: allowed,
+				requiredContent: 'iframe'
+			} ) );
+
+			editor.ui.addButton && editor.ui.addButton( 'Iframe', {
+				label: lang.toolbar,
+				command: pluginName,
+				toolbar: 'insert,80'
+			} );
+
+			editor.on( 'doubleclick', function( evt ) {
+				var element = evt.data.element;
+				if ( element.is( 'img' ) && element.data( 'cke-real-element-type' ) == 'iframe' )
+					evt.data.dialog = 'iframe';
+			} );
+
+			if ( editor.addMenuItems ) {
+				editor.addMenuItems( {
+					iframe: {
+						label: lang.title,
+						command: 'iframe',
+						group: 'image'
+					}
+				} );
+			}
+
+			// If the "contextmenu" plugin is loaded, register the listeners.
+			if ( editor.contextMenu ) {
+				editor.contextMenu.addListener( function( element, selection ) {
+					if ( element && element.is( 'img' ) && element.data( 'cke-real-element-type' ) == 'iframe' )
+						return { iframe: CKEDITOR.TRISTATE_OFF };
+				} );
+			}
+		},
+		afterInit: function( editor ) {
+			var dataProcessor = editor.dataProcessor,
+				dataFilter = dataProcessor && dataProcessor.dataFilter;
+
+			if ( dataFilter ) {
+				dataFilter.addRules( {
+					elements: {
+						iframe: function( element ) {
+							return editor.createFakeParserElement( element, 'cke_iframe', 'iframe', true );
+						}
+					}
+				} );
+			}
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/image/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/image/plugin.js
new file mode 100644
index 00000000..1c826a20
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/image/plugin.js
@@ -0,0 +1,170 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Image plugin
+ */
+
+( function() {
+
+	CKEDITOR.plugins.add( 'image', {
+		requires: 'dialog',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'image', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			// Abort when Image2 is to be loaded since both plugins
+			// share the same button, command, etc. names (#11222).
+			if ( editor.plugins.image2 )
+				return;
+
+			var pluginName = 'image';
+
+			// Register the dialog.
+			CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/image.js' );
+
+			var allowed = 'img[alt,!src]{border-style,border-width,float,height,margin,margin-bottom,margin-left,margin-right,margin-top,width}',
+				required = 'img[alt,src]';
+
+			if ( CKEDITOR.dialog.isTabEnabled( editor, pluginName, 'advanced' ) )
+				allowed = 'img[alt,dir,id,lang,longdesc,!src,title]{*}(*)';
+
+			// Register the command.
+			editor.addCommand( pluginName, new CKEDITOR.dialogCommand( pluginName, {
+				allowedContent: allowed,
+				requiredContent: required,
+				contentTransformations: [
+					[ 'img{width}: sizeToStyle', 'img[width]: sizeToAttribute' ],
+					[ 'img{float}: alignmentToStyle', 'img[align]: alignmentToAttribute' ]
+				]
+			} ) );
+
+			// Register the toolbar button.
+			editor.ui.addButton && editor.ui.addButton( 'Image', {
+				label: editor.lang.common.image,
+				command: pluginName,
+				toolbar: 'insert,10'
+			} );
+
+			editor.on( 'doubleclick', function( evt ) {
+				var element = evt.data.element;
+
+				if ( element.is( 'img' ) && !element.data( 'cke-realelement' ) && !element.isReadOnly() )
+					evt.data.dialog = 'image';
+			} );
+
+			// If the "menu" plugin is loaded, register the menu items.
+			if ( editor.addMenuItems ) {
+				editor.addMenuItems( {
+					image: {
+						label: editor.lang.image.menu,
+						command: 'image',
+						group: 'image'
+					}
+				} );
+			}
+
+			// If the "contextmenu" plugin is loaded, register the listeners.
+			if ( editor.contextMenu ) {
+				editor.contextMenu.addListener( function( element, selection ) {
+					if ( getSelectedImage( editor, element ) )
+						return { image: CKEDITOR.TRISTATE_OFF };
+				} );
+			}
+		},
+		afterInit: function( editor ) {
+			// Abort when Image2 is to be loaded since both plugins
+			// share the same button, command, etc. names (#11222).
+			if ( editor.plugins.image2 )
+				return;
+
+			// Customize the behavior of the alignment commands. (#7430)
+			setupAlignCommand( 'left' );
+			setupAlignCommand( 'right' );
+			setupAlignCommand( 'center' );
+			setupAlignCommand( 'block' );
+
+			function setupAlignCommand( value ) {
+				var command = editor.getCommand( 'justify' + value );
+				if ( command ) {
+					if ( value == 'left' || value == 'right' ) {
+						command.on( 'exec', function( evt ) {
+							var img = getSelectedImage( editor ),
+								align;
+							if ( img ) {
+								align = getImageAlignment( img );
+								if ( align == value ) {
+									img.removeStyle( 'float' );
+
+									// Remove "align" attribute when necessary.
+									if ( value == getImageAlignment( img ) )
+										img.removeAttribute( 'align' );
+								} else
+									img.setStyle( 'float', value );
+
+								evt.cancel();
+							}
+						} );
+					}
+
+					command.on( 'refresh', function( evt ) {
+						var img = getSelectedImage( editor ),
+							align;
+						if ( img ) {
+							align = getImageAlignment( img );
+
+							this.setState(
+							( align == value ) ? CKEDITOR.TRISTATE_ON : ( value == 'right' || value == 'left' ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+
+							evt.cancel();
+						}
+					} );
+				}
+			}
+		}
+	} );
+
+	function getSelectedImage( editor, element ) {
+		if ( !element ) {
+			var sel = editor.getSelection();
+			element = sel.getSelectedElement();
+		}
+
+		if ( element && element.is( 'img' ) && !element.data( 'cke-realelement' ) && !element.isReadOnly() )
+			return element;
+	}
+
+	function getImageAlignment( element ) {
+		var align = element.getStyle( 'float' );
+
+		if ( align == 'inherit' || align == 'none' )
+			align = 0;
+
+		if ( !align )
+			align = element.getAttribute( 'align' );
+
+		return align;
+	}
+
+} )();
+
+/**
+ * Whether to remove links when emptying the link URL field in the image dialog.
+ *
+ *		config.image_removeLinkByEmptyURL = false;
+ *
+ * @cfg {Boolean} [image_removeLinkByEmptyURL=true]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.image_removeLinkByEmptyURL = true;
+
+/**
+ * Padding text to set off the image in preview area.
+ *
+ *		config.image_previewText = CKEDITOR.tools.repeat( '___ ', 100 );
+ *
+ * @cfg {String} [image_previewText='Lorem ipsum dolor...' (placeholder text)]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/indent/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/indent/plugin.js
new file mode 100644
index 00000000..180d4ceb
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/indent/plugin.js
@@ -0,0 +1,461 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Increase and Decrease Indent commands.
+ */
+
+( function() {
+	'use strict';
+
+	var TRISTATE_DISABLED = CKEDITOR.TRISTATE_DISABLED,
+		TRISTATE_OFF = CKEDITOR.TRISTATE_OFF;
+
+	CKEDITOR.plugins.add( 'indent', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'indent,indent-rtl,outdent,outdent-rtl', // %REMOVE_LINE_CORE%
+
+		init: function( editor ) {
+			var genericDefinition = CKEDITOR.plugins.indent.genericDefinition;
+
+			// Register generic commands.
+			setupGenericListeners( editor, editor.addCommand( 'indent', new genericDefinition( true ) ) );
+			setupGenericListeners( editor, editor.addCommand( 'outdent', new genericDefinition() ) );
+
+			// Create and register toolbar button if possible.
+			if ( editor.ui.addButton ) {
+				editor.ui.addButton( 'Indent', {
+					label: editor.lang.indent.indent,
+					command: 'indent',
+					directional: true,
+					toolbar: 'indent,20'
+				} );
+
+				editor.ui.addButton( 'Outdent', {
+					label: editor.lang.indent.outdent,
+					command: 'outdent',
+					directional: true,
+					toolbar: 'indent,10'
+				} );
+			}
+
+			// Register dirChanged listener.
+			editor.on( 'dirChanged', function( evt ) {
+				var range = editor.createRange(),
+					dataNode = evt.data.node;
+
+				range.setStartBefore( dataNode );
+				range.setEndAfter( dataNode );
+
+				var walker = new CKEDITOR.dom.walker( range ),
+					node;
+
+				while ( ( node = walker.next() ) ) {
+					if ( node.type == CKEDITOR.NODE_ELEMENT ) {
+						// A child with the defined dir is to be ignored.
+						if ( !node.equals( dataNode ) && node.getDirection() ) {
+							range.setStartAfter( node );
+							walker = new CKEDITOR.dom.walker( range );
+							continue;
+						}
+
+						// Switch alignment classes.
+						var classes = editor.config.indentClasses;
+						if ( classes ) {
+							var suffix = ( evt.data.dir == 'ltr' ) ? [ '_rtl', '' ] : [ '', '_rtl' ];
+							for ( var i = 0; i < classes.length; i++ ) {
+								if ( node.hasClass( classes[ i ] + suffix[ 0 ] ) ) {
+									node.removeClass( classes[ i ] + suffix[ 0 ] );
+									node.addClass( classes[ i ] + suffix[ 1 ] );
+								}
+							}
+						}
+
+						// Switch the margins.
+						var marginLeft = node.getStyle( 'margin-right' ),
+							marginRight = node.getStyle( 'margin-left' );
+
+						marginLeft ? node.setStyle( 'margin-left', marginLeft ) : node.removeStyle( 'margin-left' );
+						marginRight ? node.setStyle( 'margin-right', marginRight ) : node.removeStyle( 'margin-right' );
+					}
+				}
+			} );
+		}
+	} );
+
+	/**
+	 * Global command class definitions and global helpers.
+	 *
+	 * @class
+	 * @singleton
+	 */
+	CKEDITOR.plugins.indent = {
+		/**
+		 * A base class for a generic command definition, responsible mainly for creating
+		 * Increase Indent and Decrease Indent toolbar buttons as well as for refreshing
+		 * UI states.
+		 *
+		 * Commands of this class do not perform any indentation by themselves. They
+		 * delegate this job to content-specific indentation commands (i.e. indentlist).
+		 *
+		 * @class CKEDITOR.plugins.indent.genericDefinition
+		 * @extends CKEDITOR.commandDefinition
+		 * @param {CKEDITOR.editor} editor The editor instance this command will be
+		 * applied to.
+		 * @param {String} name The name of the command.
+		 * @param {Boolean} [isIndent] Defines the command as indenting or outdenting.
+		 */
+		genericDefinition: function( isIndent ) {
+			/**
+			 * Determines whether the command belongs to the indentation family.
+			 * Otherwise it is assumed to be an outdenting command.
+			 *
+			 * @readonly
+			 * @property {Boolean} [=false]
+			 */
+			this.isIndent = !!isIndent;
+
+			// Mimic naive startDisabled behavior for outdent.
+			this.startDisabled = !this.isIndent;
+		},
+
+		/**
+		 * A base class for specific indentation command definitions responsible for
+		 * handling a pre-defined set of elements i.e. indentlist for lists or
+		 * indentblock for text block elements.
+		 *
+		 * Commands of this class perform indentation operations and modify the DOM structure.
+		 * They listen for events fired by {@link CKEDITOR.plugins.indent.genericDefinition}
+		 * and execute defined actions.
+		 *
+		 * **NOTE**: This is not an {@link CKEDITOR.command editor command}.
+		 * Context-specific commands are internal, for indentation system only.
+		 *
+		 * @class CKEDITOR.plugins.indent.specificDefinition
+		 * @param {CKEDITOR.editor} editor The editor instance this command will be
+		 * applied to.
+		 * @param {String} name The name of the command.
+		 * @param {Boolean} [isIndent] Defines the command as indenting or outdenting.
+		 */
+		specificDefinition: function( editor, name, isIndent ) {
+			this.name = name;
+			this.editor = editor;
+
+			/**
+			 * An object of jobs handled by the command. Each job consists
+			 * of two functions: `refresh` and `exec` as well as the execution priority.
+			 *
+			 *	* The `refresh` function determines whether a job is doable for
+			 *	  a particular context. These functions are executed in the
+			 *	  order of priorities, one by one, for all plugins that registered
+			 *	  jobs. As jobs are related to generic commands, refreshing
+			 *	  occurs when the global command is firing the `refresh` event.
+			 *
+			 *	  **Note**: This function must return either {@link CKEDITOR#TRISTATE_DISABLED}
+			 *	  or {@link CKEDITOR#TRISTATE_OFF}.
+			 *
+			 *	* The `exec` function modifies the DOM if possible. Just like
+			 *	  `refresh`, `exec` functions are executed in the order of priorities
+			 *	  while the generic command is executed. This function is not executed
+			 *	  if `refresh` for this job returned {@link CKEDITOR#TRISTATE_DISABLED}.
+			 *
+			 *	  **Note**: This function must return a Boolean value, indicating whether it
+			 *	  was successful. If a job was successful, then no other jobs are being executed.
+			 *
+			 * Sample definition:
+			 *
+			 *		command.jobs = {
+			 *			// Priority = 20.
+			 *			'20': {
+			 *				refresh( editor, path ) {
+			 *					if ( condition )
+			 *						return CKEDITOR.TRISTATE_OFF;
+			 *					else
+			 *						return CKEDITOR.TRISTATE_DISABLED;
+			 *				},
+			 *				exec( editor ) {
+			 *					// DOM modified! This was OK.
+			 *					return true;
+			 *				}
+			 *			},
+			 *			// Priority = 60. This job is done later.
+			 *			'60': {
+			 *				// Another job.
+			 *			}
+			 *		};
+			 *
+			 * For additional information, please check comments for
+			 * the `setupGenericListeners` function.
+			 *
+			 * @readonly
+			 * @property {Object} [={}]
+			 */
+			this.jobs = {};
+
+			/**
+			 * Determines whether the editor that the command belongs to has
+			 * {@link CKEDITOR.config#enterMode config.enterMode} set to {@link CKEDITOR#ENTER_BR}.
+			 *
+			 * @readonly
+			 * @see CKEDITOR.config#enterMode
+			 * @property {Boolean} [=false]
+			 */
+			this.enterBr = editor.config.enterMode == CKEDITOR.ENTER_BR;
+
+			/**
+			 * Determines whether the command belongs to the indentation family.
+			 * Otherwise it is assumed to be an outdenting command.
+			 *
+			 * @readonly
+			 * @property {Boolean} [=false]
+			 */
+			this.isIndent = !!isIndent;
+
+			/**
+			 * The name of the global command related to this one.
+			 *
+			 * @readonly
+			 */
+			this.relatedGlobal = isIndent ? 'indent' : 'outdent';
+
+			/**
+			 * A keystroke associated with this command (*Tab* or *Shift+Tab*).
+			 *
+			 * @readonly
+			 */
+			this.indentKey = isIndent ? 9 : CKEDITOR.SHIFT + 9;
+
+			/**
+			 * Stores created markers for the command so they can eventually be
+			 * purged after the `exec` function is run.
+			 */
+			this.database = {};
+		},
+
+		/**
+		 * Registers content-specific commands as a part of the indentation system
+		 * directed by generic commands. Once a command is registered,
+		 * it listens for events of a related generic command.
+		 *
+		 *		CKEDITOR.plugins.indent.registerCommands( editor, {
+		 *			'indentlist': new indentListCommand( editor, 'indentlist' ),
+		 *			'outdentlist': new indentListCommand( editor, 'outdentlist' )
+		 *		} );
+		 *
+		 * Content-specific commands listen for the generic command's `exec` and
+		 * try to execute their own jobs, one after another. If some execution is
+		 * successful, `evt.data.done` is set so no more jobs (commands) are involved.
+		 *
+		 * Content-specific commands also listen for the generic command's `refresh`
+		 * and fill the `evt.data.states` object with states of jobs. A generic command
+		 * uses this data to determine its own state and to update the UI.
+		 *
+		 * @member CKEDITOR.plugins.indent
+		 * @param {CKEDITOR.editor} editor The editor instance this command is
+		 * applied to.
+		 * @param {Object} commands An object of {@link CKEDITOR.command}.
+		 */
+		registerCommands: function( editor, commands ) {
+			editor.on( 'pluginsLoaded', function() {
+				for ( var name in commands ) {
+					( function( editor, command ) {
+						var relatedGlobal = editor.getCommand( command.relatedGlobal );
+
+						for ( var priority in command.jobs ) {
+							// Observe generic exec event and execute command when necessary.
+							// If the command was successfully handled by the command and
+							// DOM has been modified, stop event propagation so no other plugin
+							// will bother. Job is done.
+							relatedGlobal.on( 'exec', function( evt ) {
+								if ( evt.data.done )
+									return;
+
+								// Make sure that anything this command will do is invisible
+								// for undoManager. What undoManager only can see and
+								// remember is the execution of the global command (relatedGlobal).
+								editor.fire( 'lockSnapshot' );
+
+								if ( command.execJob( editor, priority ) )
+									evt.data.done = true;
+
+								editor.fire( 'unlockSnapshot' );
+
+								// Clean up the markers.
+								CKEDITOR.dom.element.clearAllMarkers( command.database );
+							}, this, null, priority );
+
+							// Observe generic refresh event and force command refresh.
+							// Once refreshed, save command state in event data
+							// so generic command plugin can update its own state and UI.
+							relatedGlobal.on( 'refresh', function( evt ) {
+								if ( !evt.data.states )
+									evt.data.states = {};
+
+								evt.data.states[ command.name + '@' + priority ] =
+									command.refreshJob( editor, priority, evt.data.path );
+							}, this, null, priority );
+						}
+
+						// Since specific indent commands have no UI elements,
+						// they need to be manually registered as a editor feature.
+						editor.addFeature( command );
+					} )( this, commands[ name ] );
+				}
+			} );
+		}
+	};
+
+	CKEDITOR.plugins.indent.genericDefinition.prototype = {
+		context: 'p',
+
+		exec: function() {}
+	};
+
+	CKEDITOR.plugins.indent.specificDefinition.prototype = {
+		/**
+		 * Executes the content-specific procedure if the context is correct.
+		 * It calls the `exec` function of a job of the given `priority`
+		 * that modifies the DOM.
+		 *
+		 * @param {CKEDITOR.editor} editor The editor instance this command
+		 * will be applied to.
+		 * @param {Number} priority The priority of the job to be executed.
+		 * @returns {Boolean} Indicates whether the job was successful.
+		 */
+		execJob: function( editor, priority ) {
+			var job = this.jobs[ priority ];
+
+			if ( job.state != TRISTATE_DISABLED )
+				return job.exec.call( this, editor );
+		},
+
+		/**
+		 * Calls the `refresh` function of a job of the given `priority`.
+		 * The function returns the state of the job which can be either
+		 * {@link CKEDITOR#TRISTATE_DISABLED} or {@link CKEDITOR#TRISTATE_OFF}.
+		 *
+		 * @param {CKEDITOR.editor} editor The editor instance this command
+		 * will be applied to.
+		 * @param {Number} priority The priority of the job to be executed.
+		 * @returns {Number} The state of the job.
+		 */
+		refreshJob: function( editor, priority, path ) {
+			var job = this.jobs[ priority ];
+
+			if ( !editor.activeFilter.checkFeature( this ) )
+				job.state = TRISTATE_DISABLED;
+			else
+				job.state = job.refresh.call( this, editor, path );
+
+			return job.state;
+		},
+
+		/**
+		 * Checks if the element path contains the element handled
+		 * by this indentation command.
+		 *
+		 * @param {CKEDITOR.dom.elementPath} node A path to be checked.
+		 * @returns {CKEDITOR.dom.element}
+		 */
+		getContext: function( path ) {
+			return path.contains( this.context );
+		}
+	};
+
+	/**
+	 * Attaches event listeners for this generic command. Since the indentation
+	 * system is event-oriented, generic commands communicate with
+	 * content-specific commands using the `exec` and `refresh` events.
+	 *
+	 * Listener priorities are crucial. Different indentation phases
+	 * are executed with different priorities.
+	 *
+	 * For the `exec` event:
+	 *
+	 *	* 0: Selection and bookmarks are saved by the generic command.
+	 *	* 1-99: Content-specific commands try to indent the code by executing
+	 *	  their own jobs ({@link CKEDITOR.plugins.indent.specificDefinition#jobs}).
+	 *	* 100: Bookmarks are re-selected by the generic command.
+	 *
+	 * The visual interpretation looks as follows:
+	 *
+	 *		  +------------------+
+	 *		  | Exec event fired |
+	 *		  +------ + ---------+
+	 *		          |
+	 *		        0 -<----------+ Selection and bookmarks saved.
+	 *		          |
+	 *		          |
+	 *		       25 -<---+ Exec 1st job of plugin#1 (return false, continuing...).
+	 *		          |
+	 *		          |
+	 *		       50 -<---+ Exec 1st job of plugin#2 (return false, continuing...).
+	 *		          |
+	 *		          |
+	 *		       75 -<---+ Exec 2nd job of plugin#1 (only if plugin#2 failed).
+	 *		          |
+	 *		          |
+	 *		      100 -<-----------+ Re-select bookmarks, clean-up.
+	 *		          |
+	 *		+-------- v ----------+
+	 *		| Exec event finished |
+	 *		+---------------------+
+	 *
+	 * For the `refresh` event:
+	 *
+	 *	* <100: Content-specific commands refresh their job states according
+	 *	  to the given path. Jobs save their states in the `evt.data.states` object
+	 *	  passed along with the event. This can be either {@link CKEDITOR#TRISTATE_DISABLED}
+	 *	  or {@link CKEDITOR#TRISTATE_OFF}.
+	 *	* 100: Command state is determined according to what states
+	 *	  have been returned by content-specific jobs (`evt.data.states`).
+	 *	  UI elements are updated at this stage.
+	 *
+	 *	  **Note**: If there is at least one job with the {@link CKEDITOR#TRISTATE_OFF} state,
+	 *	  then the generic command state is also {@link CKEDITOR#TRISTATE_OFF}. Otherwise,
+	 *	  the command state is {@link CKEDITOR#TRISTATE_DISABLED}.
+	 *
+	 * @param {CKEDITOR.command} command The command to be set up.
+	 * @private
+	 */
+	function setupGenericListeners( editor, command ) {
+		var selection, bookmarks;
+
+		// Set the command state according to content-specific
+		// command states.
+		command.on( 'refresh', function( evt ) {
+			// If no state comes with event data, disable command.
+			var states = [ TRISTATE_DISABLED ];
+
+			for ( var s in evt.data.states )
+				states.push( evt.data.states[ s ] );
+
+			this.setState( CKEDITOR.tools.search( states, TRISTATE_OFF ) ?
+					TRISTATE_OFF
+				:
+					TRISTATE_DISABLED );
+		}, command, null, 100 );
+
+		// Initialization. Save bookmarks and mark event as not handled
+		// by any plugin (command) yet.
+		command.on( 'exec', function( evt ) {
+			selection = editor.getSelection();
+			bookmarks = selection.createBookmarks( 1 );
+
+			// Mark execution as not handled yet.
+			if ( !evt.data )
+				evt.data = {};
+
+			evt.data.done = false;
+		}, command, null, 0 );
+
+		// Housekeeping. Make sure selectionChange will be called.
+		// Also re-select previously saved bookmarks.
+		command.on( 'exec', function( evt ) {
+			editor.forceNextSelectionCheck();
+			selection.selectBookmarks( bookmarks );
+		}, command, null, 100 );
+	}
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/indentlist/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/indentlist/plugin.js
new file mode 100644
index 00000000..d6338ab4
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/indentlist/plugin.js
@@ -0,0 +1,298 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Handles the indentation of lists.
+ */
+
+( function() {
+	'use strict';
+
+	var isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
+		isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true ),
+		TRISTATE_DISABLED = CKEDITOR.TRISTATE_DISABLED,
+		TRISTATE_OFF = CKEDITOR.TRISTATE_OFF;
+
+	CKEDITOR.plugins.add( 'indentlist', {
+		requires: 'indent',
+		init: function( editor ) {
+			var globalHelpers = CKEDITOR.plugins.indent,
+				editable = editor;
+
+			// Register commands.
+			globalHelpers.registerCommands( editor, {
+				indentlist: new commandDefinition( editor, 'indentlist', true ),
+				outdentlist: new commandDefinition( editor, 'outdentlist' )
+			} );
+
+			function commandDefinition( editor, name ) {
+				globalHelpers.specificDefinition.apply( this, arguments );
+
+				// Require ul OR ol list.
+				this.requiredContent = [ 'ul', 'ol' ];
+
+				// Indent and outdent lists with TAB/SHIFT+TAB key. Indenting can
+				// be done for any list item that isn't the first child of the parent.
+				editor.on( 'key', function( evt ) {
+					if ( editor.mode != 'wysiwyg' )
+						return;
+
+					if ( evt.data.keyCode == this.indentKey ) {
+						var list = this.getContext( editor.elementPath() );
+
+						if ( list ) {
+							// Don't indent if in first list item of the parent.
+							// Outdent, however, can always be done to collapse
+							// the list into a paragraph (div).
+							if ( this.isIndent && firstItemInPath.call( this, editor.elementPath(), list ) )
+								return;
+
+							// Exec related global indentation command. Global
+							// commands take care of bookmarks and selection,
+							// so it's much easier to use them instead of
+							// content-specific commands.
+							editor.execCommand( this.relatedGlobal );
+
+							// Cancel the key event so editor doesn't lose focus.
+							evt.cancel();
+						}
+					}
+				}, this );
+
+				// There are two different jobs for this plugin:
+				//
+				//	* Indent job (priority=10), before indentblock.
+				//
+				//	  This job is before indentblock because, if this plugin is
+				//	  loaded it has higher priority over indentblock. It means that,
+				//	  if possible, nesting is performed, and then block manipulation,
+				//	  if necessary.
+				//
+				//	* Outdent job (priority=30), after outdentblock.
+				//
+				//	  This job got to be after outdentblock because in some cases
+				//	  (margin, config#indentClass on list) outdent must be done on
+				//	  block-level.
+
+				this.jobs[ this.isIndent ? 10 : 30 ] = {
+					refresh: this.isIndent ?
+							function( editor, path ) {
+								var list = this.getContext( path ),
+									inFirstListItem = firstItemInPath.call( this, path, list );
+
+								if ( !list || !this.isIndent || inFirstListItem )
+									return TRISTATE_DISABLED;
+
+								return TRISTATE_OFF;
+							}
+						:
+							function( editor, path ) {
+								var list = this.getContext( path );
+
+								if ( !list || this.isIndent )
+									return TRISTATE_DISABLED;
+
+								return TRISTATE_OFF;
+							},
+
+					exec: CKEDITOR.tools.bind( indentList, this )
+				};
+			}
+
+			CKEDITOR.tools.extend( commandDefinition.prototype, globalHelpers.specificDefinition.prototype, {
+				// Elements that, if in an elementpath, will be handled by this
+				// command. They restrict the scope of the plugin.
+				context: { ol: 1, ul: 1 }
+			} );
+		}
+	} );
+
+	function indentList( editor ) {
+		var that = this,
+			database = this.database,
+			context = this.context;
+
+		function indent( listNode ) {
+			// Our starting and ending points of the range might be inside some blocks under a list item...
+			// So before playing with the iterator, we need to expand the block to include the list items.
+			var startContainer = range.startContainer,
+				endContainer = range.endContainer;
+			while ( startContainer && !startContainer.getParent().equals( listNode ) )
+				startContainer = startContainer.getParent();
+			while ( endContainer && !endContainer.getParent().equals( listNode ) )
+				endContainer = endContainer.getParent();
+
+			if ( !startContainer || !endContainer )
+				return false;
+
+			// Now we can iterate over the individual items on the same tree depth.
+			var block = startContainer,
+				itemsToMove = [],
+				stopFlag = false;
+
+			while ( !stopFlag ) {
+				if ( block.equals( endContainer ) )
+					stopFlag = true;
+
+				itemsToMove.push( block );
+				block = block.getNext();
+			}
+
+			if ( itemsToMove.length < 1 )
+				return false;
+
+			// Do indent or outdent operations on the array model of the list, not the
+			// list's DOM tree itself. The array model demands that it knows as much as
+			// possible about the surrounding lists, we need to feed it the further
+			// ancestor node that is still a list.
+			var listParents = listNode.getParents( true );
+			for ( var i = 0; i < listParents.length; i++ ) {
+				if ( listParents[ i ].getName && context[ listParents[ i ].getName() ] ) {
+					listNode = listParents[ i ];
+					break;
+				}
+			}
+
+			var indentOffset = that.isIndent ? 1 : -1,
+				startItem = itemsToMove[ 0 ],
+				lastItem = itemsToMove[ itemsToMove.length - 1 ],
+
+				// Convert the list DOM tree into a one dimensional array.
+				listArray = CKEDITOR.plugins.list.listToArray( listNode, database ),
+
+				// Apply indenting or outdenting on the array.
+				baseIndent = listArray[ lastItem.getCustomData( 'listarray_index' ) ].indent;
+
+			for ( i = startItem.getCustomData( 'listarray_index' ); i <= lastItem.getCustomData( 'listarray_index' ); i++ ) {
+				listArray[ i ].indent += indentOffset;
+				// Make sure the newly created sublist get a brand-new element of the same type. (#5372)
+				if ( indentOffset > 0 ) {
+					var listRoot = listArray[ i ].parent;
+					listArray[ i ].parent = new CKEDITOR.dom.element( listRoot.getName(), listRoot.getDocument() );
+				}
+			}
+
+			for ( i = lastItem.getCustomData( 'listarray_index' ) + 1; i < listArray.length && listArray[ i ].indent > baseIndent; i++ )
+				listArray[ i ].indent += indentOffset;
+
+			// Convert the array back to a DOM forest (yes we might have a few subtrees now).
+			// And replace the old list with the new forest.
+			var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode, listNode.getDirection() );
+
+			// Avoid nested <li> after outdent even they're visually same,
+			// recording them for later refactoring.(#3982)
+			if ( !that.isIndent ) {
+				var parentLiElement;
+				if ( ( parentLiElement = listNode.getParent() ) && parentLiElement.is( 'li' ) ) {
+					var children = newList.listNode.getChildren(),
+						pendingLis = [],
+						count = children.count(),
+						child;
+
+					for ( i = count - 1; i >= 0; i-- ) {
+						if ( ( child = children.getItem( i ) ) && child.is && child.is( 'li' ) )
+							pendingLis.push( child );
+					}
+				}
+			}
+
+			if ( newList )
+				newList.listNode.replace( listNode );
+
+			// Move the nested <li> to be appeared after the parent.
+			if ( pendingLis && pendingLis.length ) {
+				for ( i = 0; i < pendingLis.length; i++ ) {
+					var li = pendingLis[ i ],
+						followingList = li;
+
+					// Nest preceding <ul>/<ol> inside current <li> if any.
+					while ( ( followingList = followingList.getNext() ) && followingList.is && followingList.getName() in context ) {
+						// IE requires a filler NBSP for nested list inside empty list item,
+						// otherwise the list item will be inaccessiable. (#4476)
+						if ( CKEDITOR.env.needsNbspFiller && !li.getFirst( neitherWhitespacesNorBookmark ) )
+							li.append( range.document.createText( '\u00a0' ) );
+
+						li.append( followingList );
+					}
+
+					li.insertAfter( parentLiElement );
+				}
+			}
+
+			if ( newList )
+				editor.fire( 'contentDomInvalidated' );
+
+			return true;
+		}
+
+		var selection = editor.getSelection(),
+			ranges = selection && selection.getRanges(),
+			iterator = ranges.createIterator(),
+			range;
+
+		while ( ( range = iterator.getNextRange() ) ) {
+			var rangeRoot = range.getCommonAncestor(),
+				nearestListBlock = rangeRoot;
+
+			while ( nearestListBlock && !( nearestListBlock.type == CKEDITOR.NODE_ELEMENT && context[ nearestListBlock.getName() ] ) )
+				nearestListBlock = nearestListBlock.getParent();
+
+			// Avoid having selection boundaries out of the list.
+			// <ul><li>[...</li></ul><p>...]</p> => <ul><li>[...]</li></ul><p>...</p>
+			if ( !nearestListBlock ) {
+				if ( ( nearestListBlock = range.startPath().contains( context ) ) )
+					range.setEndAt( nearestListBlock, CKEDITOR.POSITION_BEFORE_END );
+			}
+
+			// Avoid having selection enclose the entire list. (#6138)
+			// [<ul><li>...</li></ul>] =><ul><li>[...]</li></ul>
+			if ( !nearestListBlock ) {
+				var selectedNode = range.getEnclosedNode();
+				if ( selectedNode && selectedNode.type == CKEDITOR.NODE_ELEMENT && selectedNode.getName() in context ) {
+					range.setStartAt( selectedNode, CKEDITOR.POSITION_AFTER_START );
+					range.setEndAt( selectedNode, CKEDITOR.POSITION_BEFORE_END );
+					nearestListBlock = selectedNode;
+				}
+			}
+
+			// Avoid selection anchors under list root.
+			// <ul>[<li>...</li>]</ul> =>	<ul><li>[...]</li></ul>
+			if ( nearestListBlock && range.startContainer.type == CKEDITOR.NODE_ELEMENT && range.startContainer.getName() in context ) {
+				var walker = new CKEDITOR.dom.walker( range );
+				walker.evaluator = listItem;
+				range.startContainer = walker.next();
+			}
+
+			if ( nearestListBlock && range.endContainer.type == CKEDITOR.NODE_ELEMENT && range.endContainer.getName() in context ) {
+				walker = new CKEDITOR.dom.walker( range );
+				walker.evaluator = listItem;
+				range.endContainer = walker.previous();
+			}
+
+			if ( nearestListBlock )
+				return indent( nearestListBlock );
+		}
+		return 0;
+	}
+
+	// Check whether a first child of a list is in the path.
+	// The list can be extracted from path or given explicitly
+	// e.g. for better performance if cached.
+	function firstItemInPath( path, list ) {
+		if ( !list )
+			list = path.contains( this.context );
+
+		return list && path.block && path.block.equals( list.getFirst( listItem ) );
+	}
+
+	// Determines whether a node is a list <li> element.
+	function listItem( node ) {
+		return node.type == CKEDITOR.NODE_ELEMENT && node.is( 'li' );
+	}
+
+	function neitherWhitespacesNorBookmark( node ) {
+		return isNotWhitespaces( node ) && isNotBookmark( node );
+	}
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/justify/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/justify/plugin.js
new file mode 100644
index 00000000..6626c915
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/justify/plugin.js
@@ -0,0 +1,241 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Justify commands.
+ */
+
+( function() {
+	function getAlignment( element, useComputedState ) {
+		useComputedState = useComputedState === undefined || useComputedState;
+
+		var align;
+		if ( useComputedState )
+			align = element.getComputedStyle( 'text-align' );
+		else {
+			while ( !element.hasAttribute || !( element.hasAttribute( 'align' ) || element.getStyle( 'text-align' ) ) ) {
+				var parent = element.getParent();
+				if ( !parent )
+					break;
+				element = parent;
+			}
+			align = element.getStyle( 'text-align' ) || element.getAttribute( 'align' ) || '';
+		}
+
+		// Sometimes computed values doesn't tell.
+		align && ( align = align.replace( /(?:-(?:moz|webkit)-)?(?:start|auto)/i, '' ) );
+
+		!align && useComputedState && ( align = element.getComputedStyle( 'direction' ) == 'rtl' ? 'right' : 'left' );
+
+		return align;
+	}
+
+	function justifyCommand( editor, name, value ) {
+		this.editor = editor;
+		this.name = name;
+		this.value = value;
+		this.context = 'p';
+
+		var classes = editor.config.justifyClasses,
+			blockTag = editor.config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div';
+
+		if ( classes ) {
+			switch ( value ) {
+				case 'left':
+					this.cssClassName = classes[ 0 ];
+					break;
+				case 'center':
+					this.cssClassName = classes[ 1 ];
+					break;
+				case 'right':
+					this.cssClassName = classes[ 2 ];
+					break;
+				case 'justify':
+					this.cssClassName = classes[ 3 ];
+					break;
+			}
+
+			this.cssClassRegex = new RegExp( '(?:^|\\s+)(?:' + classes.join( '|' ) + ')(?=$|\\s)' );
+			this.requiredContent = blockTag + '(' + this.cssClassName + ')';
+		}
+		else
+			this.requiredContent = blockTag + '{text-align}';
+
+		this.allowedContent = {
+			'caption div h1 h2 h3 h4 h5 h6 p pre td th li': {
+				// Do not add elements, but only text-align style if element is validated by other rule.
+				propertiesOnly: true,
+				styles: this.cssClassName ? null : 'text-align',
+				classes: this.cssClassName || null
+			}
+		};
+
+		// In enter mode BR we need to allow here for div, because when non other
+		// feature allows div justify is the only plugin that uses it.
+		if ( editor.config.enterMode == CKEDITOR.ENTER_BR )
+			this.allowedContent.div = true;
+	}
+
+	function onDirChanged( e ) {
+		var editor = e.editor;
+
+		var range = editor.createRange();
+		range.setStartBefore( e.data.node );
+		range.setEndAfter( e.data.node );
+
+		var walker = new CKEDITOR.dom.walker( range ),
+			node;
+
+		while ( ( node = walker.next() ) ) {
+			if ( node.type == CKEDITOR.NODE_ELEMENT ) {
+				// A child with the defined dir is to be ignored.
+				if ( !node.equals( e.data.node ) && node.getDirection() ) {
+					range.setStartAfter( node );
+					walker = new CKEDITOR.dom.walker( range );
+					continue;
+				}
+
+				// Switch the alignment.
+				var classes = editor.config.justifyClasses;
+				if ( classes ) {
+					// The left align class.
+					if ( node.hasClass( classes[ 0 ] ) ) {
+						node.removeClass( classes[ 0 ] );
+						node.addClass( classes[ 2 ] );
+					}
+					// The right align class.
+					else if ( node.hasClass( classes[ 2 ] ) ) {
+						node.removeClass( classes[ 2 ] );
+						node.addClass( classes[ 0 ] );
+					}
+				}
+
+				// Always switch CSS margins.
+				var style = 'text-align';
+				var align = node.getStyle( style );
+
+				if ( align == 'left' )
+					node.setStyle( style, 'right' );
+				else if ( align == 'right' )
+					node.setStyle( style, 'left' );
+			}
+		}
+	}
+
+	justifyCommand.prototype = {
+		exec: function( editor ) {
+			var selection = editor.getSelection(),
+				enterMode = editor.config.enterMode;
+
+			if ( !selection )
+				return;
+
+			var bookmarks = selection.createBookmarks(),
+				ranges = selection.getRanges();
+
+			var cssClassName = this.cssClassName,
+				iterator, block;
+
+			var useComputedState = editor.config.useComputedState;
+			useComputedState = useComputedState === undefined || useComputedState;
+
+			for ( var i = ranges.length - 1; i >= 0; i-- ) {
+				iterator = ranges[ i ].createIterator();
+				iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
+
+				while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) ) {
+					if ( block.isReadOnly() )
+						continue;
+
+					block.removeAttribute( 'align' );
+					block.removeStyle( 'text-align' );
+
+					// Remove any of the alignment classes from the className.
+					var className = cssClassName && ( block.$.className = CKEDITOR.tools.ltrim( block.$.className.replace( this.cssClassRegex, '' ) ) );
+
+					var apply = ( this.state == CKEDITOR.TRISTATE_OFF ) && ( !useComputedState || ( getAlignment( block, true ) != this.value ) );
+
+					if ( cssClassName ) {
+						// Append the desired class name.
+						if ( apply )
+							block.addClass( cssClassName );
+						else if ( !className )
+							block.removeAttribute( 'class' );
+					} else if ( apply )
+						block.setStyle( 'text-align', this.value );
+				}
+
+			}
+
+			editor.focus();
+			editor.forceNextSelectionCheck();
+			selection.selectBookmarks( bookmarks );
+		},
+
+		refresh: function( editor, path ) {
+			var firstBlock = path.block || path.blockLimit;
+
+			this.setState( firstBlock.getName() != 'body' && getAlignment( firstBlock, this.editor.config.useComputedState ) == this.value ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+		}
+	};
+
+	CKEDITOR.plugins.add( 'justify', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'justifyblock,justifycenter,justifyleft,justifyright', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			if ( editor.blockless )
+				return;
+
+			var left = new justifyCommand( editor, 'justifyleft', 'left' ),
+				center = new justifyCommand( editor, 'justifycenter', 'center' ),
+				right = new justifyCommand( editor, 'justifyright', 'right' ),
+				justify = new justifyCommand( editor, 'justifyblock', 'justify' );
+
+			editor.addCommand( 'justifyleft', left );
+			editor.addCommand( 'justifycenter', center );
+			editor.addCommand( 'justifyright', right );
+			editor.addCommand( 'justifyblock', justify );
+
+			if ( editor.ui.addButton ) {
+				editor.ui.addButton( 'JustifyLeft', {
+					label: editor.lang.justify.left,
+					command: 'justifyleft',
+					toolbar: 'align,10'
+				} );
+				editor.ui.addButton( 'JustifyCenter', {
+					label: editor.lang.justify.center,
+					command: 'justifycenter',
+					toolbar: 'align,20'
+				} );
+				editor.ui.addButton( 'JustifyRight', {
+					label: editor.lang.justify.right,
+					command: 'justifyright',
+					toolbar: 'align,30'
+				} );
+				editor.ui.addButton( 'JustifyBlock', {
+					label: editor.lang.justify.block,
+					command: 'justifyblock',
+					toolbar: 'align,40'
+				} );
+			}
+
+			editor.on( 'dirChanged', onDirChanged );
+		}
+	} );
+} )();
+
+/**
+ * List of classes to use for aligning the contents. If it's `null`, no classes will be used
+ * and instead the corresponding CSS values will be used.
+ *
+ * The array should contain 4 members, in the following order: left, center, right, justify.
+ *
+ *		// Use the classes 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify'
+ *		config.justifyClasses = [ 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify' ];
+ *
+ * @cfg {Array} [justifyClasses=null]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/link/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/link/plugin.js
new file mode 100644
index 00000000..cdcb9878
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/link/plugin.js
@@ -0,0 +1,422 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'link', {
+	requires: 'dialog,fakeobjects',
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	icons: 'anchor,anchor-rtl,link,unlink', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	onLoad: function() {
+		// Add the CSS styles for anchor placeholders.
+		var iconPath = CKEDITOR.getUrl( this.path + 'images' + ( CKEDITOR.env.hidpi ? '/hidpi' : '' ) + '/anchor.png' ),
+			baseStyle = 'background:url(' + iconPath + ') no-repeat %1 center;border:1px dotted #00f;background-size:16px;';
+
+		var template = '.%2 a.cke_anchor,' +
+			'.%2 a.cke_anchor_empty' +
+			',.cke_editable.%2 a[name]' +
+			',.cke_editable.%2 a[data-cke-saved-name]' +
+			'{' +
+				baseStyle +
+				'padding-%1:18px;' +
+				// Show the arrow cursor for the anchor image (FF at least).
+				'cursor:auto;' +
+			'}' +
+			( CKEDITOR.plugins.link.synAnchorSelector ? ( 'a.cke_anchor_empty' +
+			'{' +
+				// Make empty anchor selectable on IE.
+				'display:inline-block;' +
+				// IE11 doesn't display empty inline-block elements.
+				( CKEDITOR.env.ie && CKEDITOR.env.version > 10 ? 'min-height:16px;vertical-align:middle' : '' ) +
+			'}'
+			) : '' ) +
+			'.%2 img.cke_anchor' +
+			'{' +
+				baseStyle +
+				'width:16px;' +
+				'min-height:15px;' +
+				// The default line-height on IE.
+				'height:1.15em;' +
+				// Opera works better with "middle" (even if not perfect)
+				'vertical-align:' + ( CKEDITOR.env.opera ? 'middle' : 'text-bottom' ) + ';' +
+			'}';
+
+		// Styles with contents direction awareness.
+		function cssWithDir( dir ) {
+			return template.replace( /%1/g, dir == 'rtl' ? 'right' : 'left' ).replace( /%2/g, 'cke_contents_' + dir );
+		}
+
+		CKEDITOR.addCss( cssWithDir( 'ltr' ) + cssWithDir( 'rtl' ) );
+	},
+
+	init: function( editor ) {
+		var allowed = 'a[!href]',
+			required = 'a[href]';
+
+		if ( CKEDITOR.dialog.isTabEnabled( editor, 'link', 'advanced' ) )
+			allowed = allowed.replace( ']', ',accesskey,charset,dir,id,lang,name,rel,tabindex,title,type]{*}(*)' );
+		if ( CKEDITOR.dialog.isTabEnabled( editor, 'link', 'target' ) )
+			allowed = allowed.replace( ']', ',target,onclick]' );
+
+		// Add the link and unlink buttons.
+		editor.addCommand( 'link', new CKEDITOR.dialogCommand( 'link', {
+			allowedContent: allowed,
+			requiredContent: required
+		} ) );
+		editor.addCommand( 'anchor', new CKEDITOR.dialogCommand( 'anchor', {
+			allowedContent: 'a[!name,id]',
+			requiredContent: 'a[name]'
+		} ) );
+		editor.addCommand( 'unlink', new CKEDITOR.unlinkCommand() );
+		editor.addCommand( 'removeAnchor', new CKEDITOR.removeAnchorCommand() );
+
+		editor.setKeystroke( CKEDITOR.CTRL + 76 /*L*/, 'link' );
+
+		if ( editor.ui.addButton ) {
+			editor.ui.addButton( 'Link', {
+				label: editor.lang.link.toolbar,
+				command: 'link',
+				toolbar: 'links,10'
+			} );
+			editor.ui.addButton( 'Unlink', {
+				label: editor.lang.link.unlink,
+				command: 'unlink',
+				toolbar: 'links,20'
+			} );
+			editor.ui.addButton( 'Anchor', {
+				label: editor.lang.link.anchor.toolbar,
+				command: 'anchor',
+				toolbar: 'links,30'
+			} );
+		}
+
+		CKEDITOR.dialog.add( 'link', this.path + 'dialogs/link.js' );
+		CKEDITOR.dialog.add( 'anchor', this.path + 'dialogs/anchor.js' );
+
+		editor.on( 'doubleclick', function( evt ) {
+			var element = CKEDITOR.plugins.link.getSelectedLink( editor ) || evt.data.element;
+
+			if ( !element.isReadOnly() ) {
+				if ( element.is( 'a' ) ) {
+					evt.data.dialog = ( element.getAttribute( 'name' ) && ( !element.getAttribute( 'href' ) || !element.getChildCount() ) ) ? 'anchor' : 'link';
+					editor.getSelection().selectElement( element );
+				} else if ( CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element ) )
+					evt.data.dialog = 'anchor';
+			}
+		} );
+
+		// If the "menu" plugin is loaded, register the menu items.
+		if ( editor.addMenuItems ) {
+			editor.addMenuItems( {
+				anchor: {
+					label: editor.lang.link.anchor.menu,
+					command: 'anchor',
+					group: 'anchor',
+					order: 1
+				},
+
+				removeAnchor: {
+					label: editor.lang.link.anchor.remove,
+					command: 'removeAnchor',
+					group: 'anchor',
+					order: 5
+				},
+
+				link: {
+					label: editor.lang.link.menu,
+					command: 'link',
+					group: 'link',
+					order: 1
+				},
+
+				unlink: {
+					label: editor.lang.link.unlink,
+					command: 'unlink',
+					group: 'link',
+					order: 5
+				}
+			} );
+		}
+
+		// If the "contextmenu" plugin is loaded, register the listeners.
+		if ( editor.contextMenu ) {
+			editor.contextMenu.addListener( function( element, selection ) {
+				if ( !element || element.isReadOnly() )
+					return null;
+
+				var anchor = CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element );
+
+				if ( !anchor && !( anchor = CKEDITOR.plugins.link.getSelectedLink( editor ) ) )
+					return null;
+
+				var menu = {};
+
+				if ( anchor.getAttribute( 'href' ) && anchor.getChildCount() )
+					menu = { link: CKEDITOR.TRISTATE_OFF, unlink: CKEDITOR.TRISTATE_OFF };
+
+				if ( anchor && anchor.hasAttribute( 'name' ) )
+					menu.anchor = menu.removeAnchor = CKEDITOR.TRISTATE_OFF;
+
+				return menu;
+			} );
+		}
+	},
+
+	afterInit: function( editor ) {
+		// Register a filter to displaying placeholders after mode change.
+
+		var dataProcessor = editor.dataProcessor,
+			dataFilter = dataProcessor && dataProcessor.dataFilter,
+			htmlFilter = dataProcessor && dataProcessor.htmlFilter,
+			pathFilters = editor._.elementsPath && editor._.elementsPath.filters;
+
+		if ( dataFilter ) {
+			dataFilter.addRules( {
+				elements: {
+					a: function( element ) {
+						var attributes = element.attributes;
+						if ( !attributes.name )
+							return null;
+
+						var isEmpty = !element.children.length;
+
+						if ( CKEDITOR.plugins.link.synAnchorSelector ) {
+							// IE needs a specific class name to be applied
+							// to the anchors, for appropriate styling.
+							var ieClass = isEmpty ? 'cke_anchor_empty' : 'cke_anchor';
+							var cls = attributes[ 'class' ];
+							if ( attributes.name && ( !cls || cls.indexOf( ieClass ) < 0 ) )
+								attributes[ 'class' ] = ( cls || '' ) + ' ' + ieClass;
+
+							if ( isEmpty && CKEDITOR.plugins.link.emptyAnchorFix ) {
+								attributes.contenteditable = 'false';
+								attributes[ 'data-cke-editable' ] = 1;
+							}
+						} else if ( CKEDITOR.plugins.link.fakeAnchor && isEmpty )
+							return editor.createFakeParserElement( element, 'cke_anchor', 'anchor' );
+
+						return null;
+					}
+				}
+			} );
+		}
+
+		if ( CKEDITOR.plugins.link.emptyAnchorFix && htmlFilter ) {
+			htmlFilter.addRules( {
+				elements: {
+					a: function( element ) {
+						delete element.attributes.contenteditable;
+					}
+				}
+			} );
+		}
+
+		if ( pathFilters ) {
+			pathFilters.push( function( element, name ) {
+				if ( name == 'a' ) {
+					if ( CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element ) || ( element.getAttribute( 'name' ) && ( !element.getAttribute( 'href' ) || !element.getChildCount() ) ) )
+						return 'anchor';
+
+				}
+			} );
+		}
+	}
+} );
+
+/**
+ * Set of Link plugin helpers.
+ *
+ * @class
+ * @singleton
+ */
+CKEDITOR.plugins.link = {
+	/**
+	 * Get the surrounding link element of the current selection.
+	 *
+	 *		CKEDITOR.plugins.link.getSelectedLink( editor );
+	 *
+	 *		// The following selections will all return the link element.
+	 *
+	 *		<a href="#">li^nk</a>
+	 *		<a href="#">[link]</a>
+	 *		text[<a href="#">link]</a>
+	 *		<a href="#">li[nk</a>]
+	 *		[<b><a href="#">li]nk</a></b>]
+	 *		[<a href="#"><b>li]nk</b></a>
+	 *
+	 * @since 3.2.1
+	 * @param {CKEDITOR.editor} editor
+	 */
+	getSelectedLink: function( editor ) {
+		var selection = editor.getSelection();
+		var selectedElement = selection.getSelectedElement();
+		if ( selectedElement && selectedElement.is( 'a' ) )
+			return selectedElement;
+
+		var range = selection.getRanges()[ 0 ];
+
+		if ( range ) {
+			range.shrink( CKEDITOR.SHRINK_TEXT );
+			return editor.elementPath( range.getCommonAncestor() ).contains( 'a', 1 );
+		}
+		return null;
+	},
+
+	/**
+	 * Collects anchors available in the editor (i.e. used by the Link plugin).
+	 * Note that the scope of search is different for inline (the "global" document) and
+	 * classic (`iframe`-based) editors (the "inner" document).
+	 *
+	 * @since 4.3.3
+	 * @param {CKEDITOR.editor} editor
+	 * @returns {CKEDITOR.dom.element[]} An array of anchor elements.
+	 */
+	getEditorAnchors: function( editor ) {
+		var editable = editor.editable(),
+
+			// The scope of search for anchors is the entire document for inline editors
+			// and editor's editable for classic editor/divarea (#11359).
+			scope = ( editable.isInline() && !editor.plugins.divarea ) ? editor.document : editable,
+
+			links = scope.getElementsByTag( 'a' ),
+			anchors = [],
+			i = 0,
+			item;
+
+		// Retrieve all anchors within the scope.
+		while ( ( item = links.getItem( i++ ) ) ) {
+			if ( item.data( 'cke-saved-name' ) || item.hasAttribute( 'name' ) ) {
+				anchors.push( {
+					name: item.data( 'cke-saved-name' ) || item.getAttribute( 'name' ),
+					id: item.getAttribute( 'id' )
+				} );
+			}
+		}
+
+		// Retrieve all "fake anchors" within the scope.
+		if ( this.fakeAnchor ) {
+			var imgs = scope.getElementsByTag( 'img' );
+
+			i = 0;
+
+			while ( ( item = imgs.getItem( i++ ) ) ) {
+				if ( ( item = this.tryRestoreFakeAnchor( editor, item ) ) ) {
+					anchors.push( {
+						name: item.getAttribute( 'name' ),
+						id: item.getAttribute( 'id' )
+					} );
+				}
+			}
+		}
+
+		return anchors;
+	},
+
+	/**
+	 * Opera and WebKit do not make it possible to select empty anchors. Fake
+	 * elements must be used for them.
+	 *
+	 * @readonly
+	 * @property {Boolean}
+	 */
+	fakeAnchor: CKEDITOR.env.opera || CKEDITOR.env.webkit,
+
+	/**
+	 * For browsers that do not support CSS3 `a[name]:empty()`. Note that IE9 is included because of #7783.
+	 *
+	 * @readonly
+	 * @property {Boolean}
+	 */
+	synAnchorSelector: CKEDITOR.env.ie,
+
+	/**
+	 * For browsers that have editing issues with an empty anchor.
+	 *
+	 * @readonly
+	 * @property {Boolean}
+	 */
+	emptyAnchorFix: CKEDITOR.env.ie && CKEDITOR.env.version < 8,
+
+	/**
+	 * Returns an element representing a real anchor restored from a fake anchor.
+	 *
+	 * @param {CKEDITOR.editor} editor
+	 * @param {CKEDITOR.dom.element} element
+	 * @returns {CKEDITOR.dom.element} Restored anchor element or nothing if the
+	 * passed element was not a fake anchor.
+	 */
+	tryRestoreFakeAnchor: function( editor, element ) {
+		if ( element && element.data( 'cke-real-element-type' ) && element.data( 'cke-real-element-type' ) == 'anchor' ) {
+			var link = editor.restoreRealElement( element );
+			if ( link.data( 'cke-saved-name' ) )
+				return link;
+		}
+	}
+};
+
+// TODO Much probably there's no need to expose these as public objects.
+
+CKEDITOR.unlinkCommand = function() {};
+CKEDITOR.unlinkCommand.prototype = {
+	exec: function( editor ) {
+		var style = new CKEDITOR.style( { element: 'a', type: CKEDITOR.STYLE_INLINE, alwaysRemoveElement: 1 } );
+		editor.removeStyle( style );
+	},
+
+	refresh: function( editor, path ) {
+		// Despite our initial hope, document.queryCommandEnabled() does not work
+		// for this in Firefox. So we must detect the state by element paths.
+
+		var element = path.lastElement && path.lastElement.getAscendant( 'a', true );
+
+		if ( element && element.getName() == 'a' && element.getAttribute( 'href' ) && element.getChildCount() )
+			this.setState( CKEDITOR.TRISTATE_OFF );
+		else
+			this.setState( CKEDITOR.TRISTATE_DISABLED );
+	},
+
+	contextSensitive: 1,
+	startDisabled: 1,
+	requiredContent: 'a[href]'
+};
+
+CKEDITOR.removeAnchorCommand = function() {};
+CKEDITOR.removeAnchorCommand.prototype = {
+	exec: function( editor ) {
+		var sel = editor.getSelection(),
+			bms = sel.createBookmarks(),
+			anchor;
+		if ( sel && ( anchor = sel.getSelectedElement() ) && ( CKEDITOR.plugins.link.fakeAnchor && !anchor.getChildCount() ? CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, anchor ) : anchor.is( 'a' ) ) )
+			anchor.remove( 1 );
+		else {
+			if ( ( anchor = CKEDITOR.plugins.link.getSelectedLink( editor ) ) ) {
+				if ( anchor.hasAttribute( 'href' ) ) {
+					anchor.removeAttributes( { name: 1, 'data-cke-saved-name': 1 } );
+					anchor.removeClass( 'cke_anchor' );
+				} else
+					anchor.remove( 1 );
+			}
+		}
+		sel.selectBookmarks( bms );
+	},
+	requiredContent: 'a[name]'
+};
+
+CKEDITOR.tools.extend( CKEDITOR.config, {
+	/**
+	 * Whether to show the Advanced tab in the Link dialog window.
+	 *
+	 * @cfg {Boolean} [linkShowAdvancedTab=true]
+	 * @member CKEDITOR.config
+	 */
+	linkShowAdvancedTab: true,
+
+	/**
+	 * Whether to show the Target tab in the Link dialog window.
+	 *
+	 * @cfg {Boolean} [linkShowTargetTab=true]
+	 * @member CKEDITOR.config
+	 */
+	linkShowTargetTab: true
+} );
diff --git a/lam/templates/lib/extra/ckeditor/plugins/list/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/list/plugin.js
new file mode 100644
index 00000000..3ddb2ca8
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/list/plugin.js
@@ -0,0 +1,1031 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Insert and remove numbered and bulleted lists.
+ */
+
+( function() {
+	var listNodeNames = { ol: 1, ul: 1 },
+		emptyTextRegex = /^[\n\r\t ]*$/;
+
+	var whitespaces = CKEDITOR.dom.walker.whitespaces(),
+		bookmarks = CKEDITOR.dom.walker.bookmark(),
+		nonEmpty = function( node ) {
+			return !( whitespaces( node ) || bookmarks( node ) );
+		},
+		blockBogus = CKEDITOR.dom.walker.bogus();
+
+	function cleanUpDirection( element ) {
+		var dir, parent, parentDir;
+		if ( ( dir = element.getDirection() ) ) {
+			parent = element.getParent();
+			while ( parent && !( parentDir = parent.getDirection() ) )
+				parent = parent.getParent();
+
+			if ( dir == parentDir )
+				element.removeAttribute( 'dir' );
+		}
+	}
+
+	// Inheirt inline styles from another element.
+	function inheirtInlineStyles( parent, el ) {
+		var style = parent.getAttribute( 'style' );
+
+		// Put parent styles before child styles.
+		style && el.setAttribute( 'style', style.replace( /([^;])$/, '$1;' ) + ( el.getAttribute( 'style' ) || '' ) );
+	}
+
+	CKEDITOR.plugins.list = {
+		/**
+		 * Convert a DOM list tree into a data structure that is easier to
+		 * manipulate. This operation should be non-intrusive in the sense that it
+		 * does not change the DOM tree, with the exception that it may add some
+		 * markers to the list item nodes when database is specified.
+		 *
+		 * @member CKEDITOR.plugins.list
+		 * @todo params
+		 */
+		listToArray: function( listNode, database, baseArray, baseIndentLevel, grandparentNode ) {
+			if ( !listNodeNames[ listNode.getName() ] )
+				return [];
+
+			if ( !baseIndentLevel )
+				baseIndentLevel = 0;
+			if ( !baseArray )
+				baseArray = [];
+
+			// Iterate over all list items to and look for inner lists.
+			for ( var i = 0, count = listNode.getChildCount(); i < count; i++ ) {
+				var listItem = listNode.getChild( i );
+
+				// Fixing malformed nested lists by moving it into a previous list item. (#6236)
+				if ( listItem.type == CKEDITOR.NODE_ELEMENT && listItem.getName() in CKEDITOR.dtd.$list )
+					CKEDITOR.plugins.list.listToArray( listItem, database, baseArray, baseIndentLevel + 1 );
+
+				// It may be a text node or some funny stuff.
+				if ( listItem.$.nodeName.toLowerCase() != 'li' )
+					continue;
+
+				var itemObj = { 'parent': listNode, indent: baseIndentLevel, element: listItem, contents: [] };
+				if ( !grandparentNode ) {
+					itemObj.grandparent = listNode.getParent();
+					if ( itemObj.grandparent && itemObj.grandparent.$.nodeName.toLowerCase() == 'li' )
+						itemObj.grandparent = itemObj.grandparent.getParent();
+				} else
+					itemObj.grandparent = grandparentNode;
+
+				if ( database )
+					CKEDITOR.dom.element.setMarker( database, listItem, 'listarray_index', baseArray.length );
+				baseArray.push( itemObj );
+
+				for ( var j = 0, itemChildCount = listItem.getChildCount(), child; j < itemChildCount; j++ ) {
+					child = listItem.getChild( j );
+					if ( child.type == CKEDITOR.NODE_ELEMENT && listNodeNames[ child.getName() ] )
+					// Note the recursion here, it pushes inner list items with
+					// +1 indentation in the correct order.
+					CKEDITOR.plugins.list.listToArray( child, database, baseArray, baseIndentLevel + 1, itemObj.grandparent );
+					else
+						itemObj.contents.push( child );
+				}
+			}
+			return baseArray;
+		},
+
+		/**
+		 * Convert our internal representation of a list back to a DOM forest.
+		 *
+		 * @member CKEDITOR.plugins.list
+		 * @todo params
+		 */
+		arrayToList: function( listArray, database, baseIndex, paragraphMode, dir ) {
+			if ( !baseIndex )
+				baseIndex = 0;
+			if ( !listArray || listArray.length < baseIndex + 1 )
+				return null;
+			var i,
+				doc = listArray[ baseIndex ].parent.getDocument(),
+				retval = new CKEDITOR.dom.documentFragment( doc ),
+				rootNode = null,
+				currentIndex = baseIndex,
+				indentLevel = Math.max( listArray[ baseIndex ].indent, 0 ),
+				currentListItem = null,
+				orgDir, block,
+				paragraphName = ( paragraphMode == CKEDITOR.ENTER_P ? 'p' : 'div' );
+			while ( 1 ) {
+				var item = listArray[ currentIndex ],
+					itemGrandParent = item.grandparent;
+
+				orgDir = item.element.getDirection( 1 );
+
+				if ( item.indent == indentLevel ) {
+					if ( !rootNode || listArray[ currentIndex ].parent.getName() != rootNode.getName() ) {
+						rootNode = listArray[ currentIndex ].parent.clone( false, 1 );
+						dir && rootNode.setAttribute( 'dir', dir );
+						retval.append( rootNode );
+					}
+					currentListItem = rootNode.append( item.element.clone( 0, 1 ) );
+
+					if ( orgDir != rootNode.getDirection( 1 ) )
+						currentListItem.setAttribute( 'dir', orgDir );
+
+					for ( i = 0; i < item.contents.length; i++ )
+						currentListItem.append( item.contents[ i ].clone( 1, 1 ) );
+					currentIndex++;
+				} else if ( item.indent == Math.max( indentLevel, 0 ) + 1 ) {
+					// Maintain original direction (#6861).
+					var currDir = listArray[ currentIndex - 1 ].element.getDirection( 1 ),
+						listData = CKEDITOR.plugins.list.arrayToList( listArray, null, currentIndex, paragraphMode, currDir != orgDir ? orgDir : null );
+
+					// If the next block is an <li> with another list tree as the first
+					// child, we'll need to append a filler (<br>/NBSP) or the list item
+					// wouldn't be editable. (#6724)
+					if ( !currentListItem.getChildCount() && CKEDITOR.env.needsNbspFiller && !( doc.$.documentMode > 7 ) )
+						currentListItem.append( doc.createText( '\xa0' ) );
+					currentListItem.append( listData.listNode );
+					currentIndex = listData.nextIndex;
+				} else if ( item.indent == -1 && !baseIndex && itemGrandParent ) {
+					if ( listNodeNames[ itemGrandParent.getName() ] ) {
+						currentListItem = item.element.clone( false, true );
+						if ( orgDir != itemGrandParent.getDirection( 1 ) )
+							currentListItem.setAttribute( 'dir', orgDir );
+					} else
+						currentListItem = new CKEDITOR.dom.documentFragment( doc );
+
+					// Migrate all children to the new container,
+					// apply the proper text direction.
+					var dirLoose = itemGrandParent.getDirection( 1 ) != orgDir,
+						li = item.element,
+						className = li.getAttribute( 'class' ),
+						style = li.getAttribute( 'style' );
+
+					var needsBlock = currentListItem.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT && ( paragraphMode != CKEDITOR.ENTER_BR || dirLoose || style || className );
+
+					var child,
+						count = item.contents.length,
+						cachedBookmark;
+
+					for ( i = 0; i < count; i++ ) {
+						child = item.contents[ i ];
+
+						// Append bookmark if we can, or cache it and append it when we'll know
+						// what to do with it. Generally - we want to keep it next to its original neighbour.
+						// Exception: if bookmark is the only child it hasn't got any neighbour, so handle it normally
+						// (wrap with block if needed).
+						if ( bookmarks( child ) && count > 1 ) {
+							// If we don't need block, it's simple - append bookmark directly to the current list item.
+							if ( !needsBlock )
+								currentListItem.append( child.clone( 1, 1 ) );
+							else
+								cachedBookmark = child.clone( 1, 1 );
+						}
+						// Block content goes directly to the current list item, without wrapping.
+						else if ( child.type == CKEDITOR.NODE_ELEMENT && child.isBlockBoundary() ) {
+							// Apply direction on content blocks.
+							if ( dirLoose && !child.getDirection() )
+								child.setAttribute( 'dir', orgDir );
+
+							inheirtInlineStyles( li, child );
+
+							className && child.addClass( className );
+
+							// Close the block which we started for inline content.
+							block = null;
+							// Append bookmark directly before current child.
+							if ( cachedBookmark ) {
+								currentListItem.append( cachedBookmark );
+								cachedBookmark = null;
+							}
+							// Append this block element to the list item.
+							currentListItem.append( child.clone( 1, 1 ) );
+						}
+						// Some inline content was found - wrap it with block and append that
+						// block to the current list item or append it to the block previously created.
+						else if ( needsBlock ) {
+							// Establish new block to hold text direction and styles.
+							if ( !block ) {
+								block = doc.createElement( paragraphName );
+								currentListItem.append( block );
+								dirLoose && block.setAttribute( 'dir', orgDir );
+							}
+
+							// Copy over styles to new block;
+							style && block.setAttribute( 'style', style );
+							className && block.setAttribute( 'class', className );
+
+							// Append bookmark directly before current child.
+							if ( cachedBookmark ) {
+								block.append( cachedBookmark );
+								cachedBookmark = null;
+							}
+							block.append( child.clone( 1, 1 ) );
+						}
+						// E.g. BR mode - inline content appended directly to the list item.
+						else
+							currentListItem.append( child.clone( 1, 1 ) );
+					}
+
+					// No content after bookmark - append it to the block if we had one
+					// or directly to the current list item if we finished directly in the current list item.
+					if ( cachedBookmark ) {
+						( block || currentListItem ).append( cachedBookmark );
+						cachedBookmark = null;
+					}
+
+					if ( currentListItem.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT && currentIndex != listArray.length - 1 ) {
+						var last;
+
+						// Remove bogus <br> if this browser uses them.
+						if ( CKEDITOR.env.needsBrFiller ) {
+							last = currentListItem.getLast();
+							if ( last && last.type == CKEDITOR.NODE_ELEMENT && last.is( 'br' ) )
+								last.remove();
+						}
+
+						// If the last element is not a block, append <br> to separate merged list items.
+						last = currentListItem.getLast( nonEmpty );
+						if ( !( last && last.type == CKEDITOR.NODE_ELEMENT && last.is( CKEDITOR.dtd.$block ) ) )
+							currentListItem.append( doc.createElement( 'br' ) );
+					}
+
+					var currentListItemName = currentListItem.$.nodeName.toLowerCase();
+					if ( currentListItemName == 'div' || currentListItemName == 'p' )
+						currentListItem.appendBogus();
+					retval.append( currentListItem );
+					rootNode = null;
+					currentIndex++;
+				} else
+					return null;
+
+				block = null;
+
+				if ( listArray.length <= currentIndex || Math.max( listArray[ currentIndex ].indent, 0 ) < indentLevel )
+					break;
+			}
+
+			if ( database ) {
+				var currentNode = retval.getFirst(),
+					listRoot = listArray[ 0 ].parent;
+
+				while ( currentNode ) {
+					if ( currentNode.type == CKEDITOR.NODE_ELEMENT ) {
+						// Clear marker attributes for the new list tree made of cloned nodes, if any.
+						CKEDITOR.dom.element.clearMarkers( database, currentNode );
+
+						// Clear redundant direction attribute specified on list items.
+						if ( currentNode.getName() in CKEDITOR.dtd.$listItem )
+							cleanUpDirection( currentNode );
+					}
+
+					currentNode = currentNode.getNextSourceNode();
+				}
+			}
+
+			return { listNode: retval, nextIndex: currentIndex };
+		}
+	};
+
+	function changeListType( editor, groupObj, database, listsCreated ) {
+		// This case is easy...
+		// 1. Convert the whole list into a one-dimensional array.
+		// 2. Change the list type by modifying the array.
+		// 3. Recreate the whole list by converting the array to a list.
+		// 4. Replace the original list with the recreated list.
+		var listArray = CKEDITOR.plugins.list.listToArray( groupObj.root, database ),
+			selectedListItems = [];
+
+		for ( var i = 0; i < groupObj.contents.length; i++ ) {
+			var itemNode = groupObj.contents[ i ];
+			itemNode = itemNode.getAscendant( 'li', true );
+			if ( !itemNode || itemNode.getCustomData( 'list_item_processed' ) )
+				continue;
+			selectedListItems.push( itemNode );
+			CKEDITOR.dom.element.setMarker( database, itemNode, 'list_item_processed', true );
+		}
+
+		var root = groupObj.root,
+			doc = root.getDocument(),
+			listNode, newListNode;
+
+		for ( i = 0; i < selectedListItems.length; i++ ) {
+			var listIndex = selectedListItems[ i ].getCustomData( 'listarray_index' );
+			listNode = listArray[ listIndex ].parent;
+
+			// Switch to new list node for this particular item.
+			if ( !listNode.is( this.type ) ) {
+				newListNode = doc.createElement( this.type );
+				// Copy all attributes, except from 'start' and 'type'.
+				listNode.copyAttributes( newListNode, { start: 1, type: 1 } );
+				// The list-style-type property should be ignored.
+				newListNode.removeStyle( 'list-style-type' );
+				listArray[ listIndex ].parent = newListNode;
+			}
+		}
+
+		var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode );
+		var child,
+			length = newList.listNode.getChildCount();
+		for ( i = 0; i < length && ( child = newList.listNode.getChild( i ) ); i++ ) {
+			if ( child.getName() == this.type )
+				listsCreated.push( child );
+		}
+		newList.listNode.replace( groupObj.root );
+
+		editor.fire( 'contentDomInvalidated' );
+	}
+
+	function createList( editor, groupObj, listsCreated ) {
+		var contents = groupObj.contents,
+			doc = groupObj.root.getDocument(),
+			listContents = [];
+
+		// It is possible to have the contents returned by DomRangeIterator to be the same as the root.
+		// e.g. when we're running into table cells.
+		// In such a case, enclose the childNodes of contents[0] into a <div>.
+		if ( contents.length == 1 && contents[ 0 ].equals( groupObj.root ) ) {
+			var divBlock = doc.createElement( 'div' );
+			contents[ 0 ].moveChildren && contents[ 0 ].moveChildren( divBlock );
+			contents[ 0 ].append( divBlock );
+			contents[ 0 ] = divBlock;
+		}
+
+		// Calculate the common parent node of all content blocks.
+		var commonParent = groupObj.contents[ 0 ].getParent();
+		for ( var i = 0; i < contents.length; i++ )
+			commonParent = commonParent.getCommonAncestor( contents[ i ].getParent() );
+
+		var useComputedState = editor.config.useComputedState,
+			listDir, explicitDirection;
+
+		useComputedState = useComputedState === undefined || useComputedState;
+
+		// We want to insert things that are in the same tree level only, so calculate the contents again
+		// by expanding the selected blocks to the same tree level.
+		for ( i = 0; i < contents.length; i++ ) {
+			var contentNode = contents[ i ],
+				parentNode;
+			while ( ( parentNode = contentNode.getParent() ) ) {
+				if ( parentNode.equals( commonParent ) ) {
+					listContents.push( contentNode );
+
+					// Determine the lists's direction.
+					if ( !explicitDirection && contentNode.getDirection() )
+						explicitDirection = 1;
+
+					var itemDir = contentNode.getDirection( useComputedState );
+
+					if ( listDir !== null ) {
+						// If at least one LI have a different direction than current listDir, we can't have listDir.
+						if ( listDir && listDir != itemDir )
+							listDir = null;
+						else
+							listDir = itemDir;
+					}
+
+					break;
+				}
+				contentNode = parentNode;
+			}
+		}
+
+		if ( listContents.length < 1 )
+			return;
+
+		// Insert the list to the DOM tree.
+		var insertAnchor = listContents[ listContents.length - 1 ].getNext(),
+			listNode = doc.createElement( this.type );
+
+		listsCreated.push( listNode );
+
+		var contentBlock, listItem;
+
+		while ( listContents.length ) {
+			contentBlock = listContents.shift();
+			listItem = doc.createElement( 'li' );
+
+			// If current block should be preserved, append it to list item instead of
+			// transforming it to <li> element.
+			if ( shouldPreserveBlock( contentBlock ) )
+				contentBlock.appendTo( listItem );
+			else {
+				contentBlock.copyAttributes( listItem );
+				// Remove direction attribute after it was merged into list root. (#7657)
+				if ( listDir && contentBlock.getDirection() ) {
+					listItem.removeStyle( 'direction' );
+					listItem.removeAttribute( 'dir' );
+				}
+				contentBlock.moveChildren( listItem );
+				contentBlock.remove();
+			}
+
+			listItem.appendTo( listNode );
+		}
+
+		// Apply list root dir only if it has been explicitly declared.
+		if ( listDir && explicitDirection )
+			listNode.setAttribute( 'dir', listDir );
+
+		if ( insertAnchor )
+			listNode.insertBefore( insertAnchor );
+		else
+			listNode.appendTo( commonParent );
+	}
+
+	function removeList( editor, groupObj, database ) {
+		// This is very much like the change list type operation.
+		// Except that we're changing the selected items' indent to -1 in the list array.
+		var listArray = CKEDITOR.plugins.list.listToArray( groupObj.root, database ),
+			selectedListItems = [];
+
+		for ( var i = 0; i < groupObj.contents.length; i++ ) {
+			var itemNode = groupObj.contents[ i ];
+			itemNode = itemNode.getAscendant( 'li', true );
+			if ( !itemNode || itemNode.getCustomData( 'list_item_processed' ) )
+				continue;
+			selectedListItems.push( itemNode );
+			CKEDITOR.dom.element.setMarker( database, itemNode, 'list_item_processed', true );
+		}
+
+		var lastListIndex = null;
+		for ( i = 0; i < selectedListItems.length; i++ ) {
+			var listIndex = selectedListItems[ i ].getCustomData( 'listarray_index' );
+			listArray[ listIndex ].indent = -1;
+			lastListIndex = listIndex;
+		}
+
+		// After cutting parts of the list out with indent=-1, we still have to maintain the array list
+		// model's nextItem.indent <= currentItem.indent + 1 invariant. Otherwise the array model of the
+		// list cannot be converted back to a real DOM list.
+		for ( i = lastListIndex + 1; i < listArray.length; i++ ) {
+			if ( listArray[ i ].indent > listArray[ i - 1 ].indent + 1 ) {
+				var indentOffset = listArray[ i - 1 ].indent + 1 - listArray[ i ].indent;
+				var oldIndent = listArray[ i ].indent;
+				while ( listArray[ i ] && listArray[ i ].indent >= oldIndent ) {
+					listArray[ i ].indent += indentOffset;
+					i++;
+				}
+				i--;
+			}
+		}
+
+		var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode, groupObj.root.getAttribute( 'dir' ) );
+
+		// Compensate <br> before/after the list node if the surrounds are non-blocks.(#3836)
+		var docFragment = newList.listNode,
+			boundaryNode, siblingNode;
+
+		function compensateBrs( isStart ) {
+			if ( ( boundaryNode = docFragment[ isStart ? 'getFirst' : 'getLast' ]() ) && !( boundaryNode.is && boundaryNode.isBlockBoundary() ) && ( siblingNode = groupObj.root[ isStart ? 'getPrevious' : 'getNext' ]
+			( CKEDITOR.dom.walker.invisible( true ) ) ) && !( siblingNode.is && siblingNode.isBlockBoundary( { br: 1 } ) ) )
+				editor.document.createElement( 'br' )[ isStart ? 'insertBefore' : 'insertAfter' ]( boundaryNode );
+		}
+		compensateBrs( true );
+		compensateBrs();
+
+		docFragment.replace( groupObj.root );
+
+		editor.fire( 'contentDomInvalidated' );
+	}
+
+	var headerTagRegex = /^h[1-6]$/;
+
+	// Checks wheather this block should be element preserved (not transformed to <li>) when creating list.
+	function shouldPreserveBlock( block ) {
+		return (
+			// #5335
+			block.is( 'pre' ) ||
+			// #5271 - this is a header.
+			headerTagRegex.test( block.getName() ) ||
+			// 11083 - this is a non-editable element.
+			block.getAttribute( 'contenteditable' ) == 'false'
+		);
+	}
+
+	function listCommand( name, type ) {
+		this.name = name;
+		this.type = type;
+		this.context = type;
+		this.allowedContent = type + ' li';
+		this.requiredContent = type;
+	}
+
+	var elementType = CKEDITOR.dom.walker.nodeType( CKEDITOR.NODE_ELEMENT );
+
+	// Merge child nodes with direction preserved. (#7448)
+	function mergeChildren( from, into, refNode, forward ) {
+		var child, itemDir;
+		while ( ( child = from[ forward ? 'getLast' : 'getFirst' ]( elementType ) ) ) {
+			if ( ( itemDir = child.getDirection( 1 ) ) !== into.getDirection( 1 ) )
+				child.setAttribute( 'dir', itemDir );
+
+			child.remove();
+
+			refNode ? child[ forward ? 'insertBefore' : 'insertAfter' ]( refNode ) : into.append( child, forward );
+		}
+	}
+
+	listCommand.prototype = {
+		exec: function( editor ) {
+			// Run state check first of all.
+			this.refresh( editor, editor.elementPath() );
+
+			var doc = editor.document,
+				config = editor.config,
+				selection = editor.getSelection(),
+				ranges = selection && selection.getRanges();
+
+			// Midas lists rule #1 says we can create a list even in an empty document.
+			// But DOM iterator wouldn't run if the document is really empty.
+			// So create a paragraph if the document is empty and we're going to create a list.
+			if ( this.state == CKEDITOR.TRISTATE_OFF ) {
+				var editable = editor.editable();
+				if ( !editable.getFirst( nonEmpty ) ) {
+					config.enterMode == CKEDITOR.ENTER_BR ? editable.appendBogus() : ranges[ 0 ].fixBlock( 1, config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' );
+
+					selection.selectRanges( ranges );
+				}
+				// Maybe a single range there enclosing the whole list,
+				// turn on the list state manually(#4129).
+				else {
+					var range = ranges.length == 1 && ranges[ 0 ],
+						enclosedNode = range && range.getEnclosedNode();
+					if ( enclosedNode && enclosedNode.is && this.type == enclosedNode.getName() )
+						this.setState( CKEDITOR.TRISTATE_ON );
+				}
+			}
+
+			var bookmarks = selection.createBookmarks( true );
+
+			// Group the blocks up because there are many cases where multiple lists have to be created,
+			// or multiple lists have to be cancelled.
+			var listGroups = [],
+				database = {},
+				rangeIterator = ranges.createIterator(),
+				index = 0;
+
+			while ( ( range = rangeIterator.getNextRange() ) && ++index ) {
+				var boundaryNodes = range.getBoundaryNodes(),
+					startNode = boundaryNodes.startNode,
+					endNode = boundaryNodes.endNode;
+
+				if ( startNode.type == CKEDITOR.NODE_ELEMENT && startNode.getName() == 'td' )
+					range.setStartAt( boundaryNodes.startNode, CKEDITOR.POSITION_AFTER_START );
+
+				if ( endNode.type == CKEDITOR.NODE_ELEMENT && endNode.getName() == 'td' )
+					range.setEndAt( boundaryNodes.endNode, CKEDITOR.POSITION_BEFORE_END );
+
+				var iterator = range.createIterator(),
+					block;
+
+				iterator.forceBrBreak = ( this.state == CKEDITOR.TRISTATE_OFF );
+
+				while ( ( block = iterator.getNextParagraph() ) ) {
+					// Avoid duplicate blocks get processed across ranges.
+					if ( block.getCustomData( 'list_block' ) )
+						continue;
+					else
+						CKEDITOR.dom.element.setMarker( database, block, 'list_block', 1 );
+
+					var path = editor.elementPath( block ),
+						pathElements = path.elements,
+						pathElementsCount = pathElements.length,
+						listNode = null,
+						processedFlag = 0,
+						blockLimit = path.blockLimit,
+						element;
+
+					// First, try to group by a list ancestor.
+					for ( var i = pathElementsCount - 1; i >= 0 && ( element = pathElements[ i ] ); i-- ) {
+						if ( listNodeNames[ element.getName() ] && blockLimit.contains( element ) ) // Don't leak outside block limit (#3940).
+						{
+							// If we've encountered a list inside a block limit
+							// The last group object of the block limit element should
+							// no longer be valid. Since paragraphs after the list
+							// should belong to a different group of paragraphs before
+							// the list. (Bug #1309)
+							blockLimit.removeCustomData( 'list_group_object_' + index );
+
+							var groupObj = element.getCustomData( 'list_group_object' );
+							if ( groupObj )
+								groupObj.contents.push( block );
+							else {
+								groupObj = { root: element, contents: [ block ] };
+								listGroups.push( groupObj );
+								CKEDITOR.dom.element.setMarker( database, element, 'list_group_object', groupObj );
+							}
+							processedFlag = 1;
+							break;
+						}
+					}
+
+					if ( processedFlag )
+						continue;
+
+					// No list ancestor? Group by block limit, but don't mix contents from different ranges.
+					var root = blockLimit;
+					if ( root.getCustomData( 'list_group_object_' + index ) )
+						root.getCustomData( 'list_group_object_' + index ).contents.push( block );
+					else {
+						groupObj = { root: root, contents: [ block ] };
+						CKEDITOR.dom.element.setMarker( database, root, 'list_group_object_' + index, groupObj );
+						listGroups.push( groupObj );
+					}
+				}
+			}
+
+			// Now we have two kinds of list groups, groups rooted at a list, and groups rooted at a block limit element.
+			// We either have to build lists or remove lists, for removing a list does not makes sense when we are looking
+			// at the group that's not rooted at lists. So we have three cases to handle.
+			var listsCreated = [];
+			while ( listGroups.length > 0 ) {
+				groupObj = listGroups.shift();
+				if ( this.state == CKEDITOR.TRISTATE_OFF ) {
+					if ( listNodeNames[ groupObj.root.getName() ] )
+						changeListType.call( this, editor, groupObj, database, listsCreated );
+					else
+						createList.call( this, editor, groupObj, listsCreated );
+				} else if ( this.state == CKEDITOR.TRISTATE_ON && listNodeNames[ groupObj.root.getName() ] )
+					removeList.call( this, editor, groupObj, database );
+			}
+
+			// For all new lists created, merge into adjacent, same type lists.
+			for ( i = 0; i < listsCreated.length; i++ )
+				mergeListSiblings( listsCreated[ i ] );
+
+			// Clean up, restore selection and update toolbar button states.
+			CKEDITOR.dom.element.clearAllMarkers( database );
+			selection.selectBookmarks( bookmarks );
+			editor.focus();
+		},
+
+		refresh: function( editor, path ) {
+			var list = path.contains( listNodeNames, 1 ),
+				limit = path.blockLimit || path.root;
+
+			// 1. Only a single type of list activate.
+			// 2. Do not show list outside of block limit.
+			if ( list && limit.contains( list ) )
+				this.setState( list.is( this.type ) ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+			else
+				this.setState( CKEDITOR.TRISTATE_OFF );
+		}
+	};
+
+	var dtd = CKEDITOR.dtd;
+	var tailNbspRegex = /[\t\r\n ]*(?:&nbsp;|\xa0)$/;
+
+		// Merge list adjacent, of same type lists.
+	function mergeListSiblings( listNode )
+	{
+		var mergeSibling;
+		( mergeSibling = function( rtl )
+		{
+			var sibling = listNode[ rtl ? 'getPrevious' : 'getNext' ]( nonEmpty );
+			if ( sibling &&
+			     sibling.type == CKEDITOR.NODE_ELEMENT &&
+			     sibling.is( listNode.getName() ) )
+			{
+				// Move children order by merge direction.(#3820)
+				mergeChildren( listNode, sibling, null, !rtl );
+
+				listNode.remove();
+				listNode = sibling;
+			}
+		} )();
+		mergeSibling( 1 );
+	}
+
+	function indexOfFirstChildElement( element, tagNameList ) {
+		var child,
+			children = element.children,
+			length = children.length;
+
+		for ( var i = 0; i < length; i++ ) {
+			child = children[ i ];
+			if ( child.name && ( child.name in tagNameList ) )
+				return i;
+		}
+
+		return length;
+	}
+
+	// Check if node is block element that recieves text.
+	function isTextBlock( node ) {
+		return node.type == CKEDITOR.NODE_ELEMENT && ( node.getName() in CKEDITOR.dtd.$block || node.getName() in CKEDITOR.dtd.$listItem ) && CKEDITOR.dtd[ node.getName() ][ '#' ];
+	}
+
+	// Join visually two block lines.
+	function joinNextLineToCursor( editor, cursor, nextCursor ) {
+		editor.fire( 'saveSnapshot' );
+
+		// Merge with previous block's content.
+		nextCursor.enlarge( CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS );
+		var frag = nextCursor.extractContents();
+
+		cursor.trim( false, true );
+		var bm = cursor.createBookmark();
+
+		// Kill original bogus;
+		var currentPath = new CKEDITOR.dom.elementPath( cursor.startContainer ),
+				pathBlock = currentPath.block,
+				currentBlock = currentPath.lastElement.getAscendant( 'li', 1 ) || pathBlock,
+				nextPath = new CKEDITOR.dom.elementPath( nextCursor.startContainer ),
+				nextLi = nextPath.contains( CKEDITOR.dtd.$listItem ),
+				nextList = nextPath.contains( CKEDITOR.dtd.$list ),
+				last;
+
+		// Remove bogus node the current block/pseudo block.
+		if ( pathBlock ) {
+			var bogus = pathBlock.getBogus();
+			bogus && bogus.remove();
+		}
+		else if ( nextList ) {
+			last = nextList.getPrevious( nonEmpty );
+			if ( last && blockBogus( last ) )
+				last.remove();
+		}
+
+		// Kill the tail br in extracted.
+		last = frag.getLast();
+		if ( last && last.type == CKEDITOR.NODE_ELEMENT && last.is( 'br' ) )
+			last.remove();
+
+		// Insert fragment at the range position.
+		var nextNode = cursor.startContainer.getChild( cursor.startOffset );
+		if ( nextNode )
+			frag.insertBefore( nextNode );
+		else
+			cursor.startContainer.append( frag );
+
+		// Move the sub list nested in the next list item.
+		if ( nextLi ) {
+			var sublist = getSubList( nextLi );
+			if ( sublist ) {
+				// If next line is in the sub list of the current list item.
+				if ( currentBlock.contains( nextLi ) ) {
+					mergeChildren( sublist, nextLi.getParent(), nextLi );
+					sublist.remove();
+				}
+				// Migrate the sub list to current list item.
+				else
+					currentBlock.append( sublist );
+			}
+		}
+
+		var nextBlock, parent;
+		// Remove any remaining zombies path blocks at the end after line merged.
+		while ( nextCursor.checkStartOfBlock() && nextCursor.checkEndOfBlock() ) {
+			nextPath = nextCursor.startPath();
+			nextBlock = nextPath.block;
+
+			// Abort when nothing to be removed (#10890).
+			if ( !nextBlock )
+				break;
+
+			// Check if also to remove empty list.
+			if ( nextBlock.is( 'li' ) ) {
+				parent = nextBlock.getParent();
+				if ( nextBlock.equals( parent.getLast( nonEmpty ) ) && nextBlock.equals( parent.getFirst( nonEmpty ) ) )
+					nextBlock = parent;
+			}
+
+			nextCursor.moveToPosition( nextBlock, CKEDITOR.POSITION_BEFORE_START );
+			nextBlock.remove();
+		}
+
+		// Check if need to further merge with the list resides after the merged block. (#9080)
+		var walkerRng = nextCursor.clone(), editable = editor.editable();
+		walkerRng.setEndAt( editable, CKEDITOR.POSITION_BEFORE_END );
+		var walker = new CKEDITOR.dom.walker( walkerRng );
+		walker.evaluator = function( node ) { return nonEmpty( node ) && !blockBogus( node ); };
+		var next = walker.next();
+		if ( next && next.type == CKEDITOR.NODE_ELEMENT && next.getName() in CKEDITOR.dtd.$list )
+			mergeListSiblings( next );
+
+		cursor.moveToBookmark( bm );
+
+		// Make fresh selection.
+		cursor.select();
+
+		editor.fire( 'saveSnapshot' );
+	}
+
+	function getSubList( li ) {
+		var last = li.getLast( nonEmpty );
+		return last && last.type == CKEDITOR.NODE_ELEMENT && last.getName() in listNodeNames ? last : null;
+	}
+
+	CKEDITOR.plugins.add( 'list', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'bulletedlist,bulletedlist-rtl,numberedlist,numberedlist-rtl', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		requires: 'indentlist',
+		init: function( editor ) {
+			if ( editor.blockless )
+				return;
+
+			// Register commands.
+			editor.addCommand( 'numberedlist', new listCommand( 'numberedlist', 'ol' ) );
+			editor.addCommand( 'bulletedlist', new listCommand( 'bulletedlist', 'ul' ) );
+
+			// Register the toolbar button.
+			if ( editor.ui.addButton ) {
+				editor.ui.addButton( 'NumberedList', {
+					label: editor.lang.list.numberedlist,
+					command: 'numberedlist',
+					directional: true,
+					toolbar: 'list,10'
+				} );
+				editor.ui.addButton( 'BulletedList', {
+					label: editor.lang.list.bulletedlist,
+					command: 'bulletedlist',
+					directional: true,
+					toolbar: 'list,20'
+				} );
+			}
+
+			// Handled backspace/del key to join list items. (#8248,#9080)
+			editor.on( 'key', function( evt ) {
+				var key = evt.data.keyCode;
+
+				// DEl/BACKSPACE
+				if ( editor.mode == 'wysiwyg' && key in { 8: 1, 46: 1 } ) {
+					var sel = editor.getSelection(),
+						range = sel.getRanges()[ 0 ],
+						path = range && range.startPath();
+
+					if ( !range || !range.collapsed )
+						return;
+
+					var isBackspace = key == 8;
+					var editable = editor.editable();
+					var walker = new CKEDITOR.dom.walker( range.clone() );
+					walker.evaluator = function( node ) {
+						return nonEmpty( node ) && !blockBogus( node );
+					};
+					// Backspace/Del behavior at the start/end of table is handled in core.
+					walker.guard = function( node, isOut ) {
+						return !( isOut && node.type == CKEDITOR.NODE_ELEMENT && node.is( 'table' ) );
+					};
+
+					var cursor = range.clone();
+
+					if ( isBackspace ) {
+						var previous, joinWith;
+
+						// Join a sub list's first line, with the previous visual line in parent.
+						if ( ( previous = path.contains( listNodeNames ) ) &&
+						     range.checkBoundaryOfElement( previous, CKEDITOR.START ) &&
+						     ( previous = previous.getParent() ) && previous.is( 'li' ) &&
+						     ( previous = getSubList( previous ) ) ) {
+							joinWith = previous;
+							previous = previous.getPrevious( nonEmpty );
+							// Place cursor before the nested list.
+							cursor.moveToPosition(
+								previous && blockBogus( previous ) ? previous : joinWith,
+								CKEDITOR.POSITION_BEFORE_START );
+						}
+						// Join any line following a list, with the last visual line of the list.
+						else {
+							walker.range.setStartAt( editable, CKEDITOR.POSITION_AFTER_START );
+							walker.range.setEnd( range.startContainer, range.startOffset );
+
+							previous = walker.previous();
+
+							if ( previous && previous.type == CKEDITOR.NODE_ELEMENT &&
+							     ( previous.getName() in listNodeNames ||
+							       previous.is( 'li' ) ) ) {
+								if ( !previous.is( 'li' ) ) {
+									walker.range.selectNodeContents( previous );
+									walker.reset();
+									walker.evaluator = isTextBlock;
+									previous = walker.previous();
+								}
+
+								joinWith = previous;
+								// Place cursor at the end of previous block.
+								cursor.moveToElementEditEnd( joinWith );
+							}
+						}
+
+						if ( joinWith ) {
+							joinNextLineToCursor( editor, cursor, range );
+							evt.cancel();
+						}
+						else {
+							var list = path.contains( listNodeNames );
+							// Backspace pressed at the start of list outdents the first list item. (#9129)
+							if ( list && range.checkBoundaryOfElement( list, CKEDITOR.START ) ) {
+								li = list.getFirst( nonEmpty );
+
+								if ( range.checkBoundaryOfElement( li, CKEDITOR.START ) ) {
+									previous = list.getPrevious( nonEmpty );
+
+									// Only if the list item contains a sub list, do nothing but
+									// simply move cursor backward one character.
+									if ( getSubList( li ) ) {
+										if ( previous ) {
+											range.moveToElementEditEnd( previous );
+											range.select();
+										}
+
+										evt.cancel();
+									}
+									else {
+										editor.execCommand( 'outdent' );
+										evt.cancel();
+									}
+								}
+							}
+						}
+
+					} else {
+
+						var next, nextLine, li = path.contains( 'li' );
+
+						if ( li ) {
+							walker.range.setEndAt( editable, CKEDITOR.POSITION_BEFORE_END );
+
+							var last = li.getLast( nonEmpty );
+							var block = last && isTextBlock( last ) ? last : li;
+
+							// Indicate cursor at the visual end of an list item.
+							var isAtEnd = 0;
+
+							next = walker.next();
+
+							// When list item contains a sub list.
+							if ( next && next.type == CKEDITOR.NODE_ELEMENT &&
+								 next.getName() in listNodeNames &&
+								 next.equals( last ) )
+							{
+								isAtEnd = 1;
+
+								// Move to the first item in sub list.
+								next = walker.next();
+							}
+							// Right at the end of list item.
+							else if ( range.checkBoundaryOfElement( block, CKEDITOR.END ) )
+								isAtEnd = 1;
+
+
+							if ( isAtEnd && next ) {
+								// Put cursor range there.
+								nextLine = range.clone();
+								nextLine.moveToElementEditStart( next );
+
+								joinNextLineToCursor( editor, cursor, nextLine );
+								evt.cancel();
+							}
+						}
+						else
+						{
+							// Handle Del key pressed before the list.
+							walker.range.setEndAt( editable, CKEDITOR.POSITION_BEFORE_END );
+							next = walker.next();
+
+							if ( next && next.type == CKEDITOR.NODE_ELEMENT &&
+							     next.is( listNodeNames ) ) {
+								// The start <li>
+								next = next.getFirst( nonEmpty );
+
+								// Simply remove the current empty block, move cursor to the
+								// subsequent list.
+								if ( path.block &&
+								     range.checkStartOfBlock() &&
+								     range.checkEndOfBlock() ) {
+									path.block.remove();
+									range.moveToElementEditStart( next );
+									range.select();
+									evt.cancel();
+								}
+								// Preventing the default (merge behavior), but simply move
+								// the cursor one character forward if subsequent list item
+								// contains sub list.
+								else if ( getSubList( next )  ) {
+									range.moveToElementEditStart( next );
+									range.select();
+									evt.cancel();
+								}
+								// Merge the first list item with the current line.
+								else {
+									nextLine = range.clone();
+									nextLine.moveToElementEditStart( next );
+									joinNextLineToCursor( editor, cursor, nextLine );
+									evt.cancel();
+								}
+							}
+						}
+
+					}
+
+					// The backspace/del could potentially put cursor at a bad position,
+					// being it handled or not, check immediately the selection to have it fixed.
+					setTimeout( function() { editor.selectionChange( 1 ); } );
+				}
+			} );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/listblock/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/listblock/plugin.js
new file mode 100644
index 00000000..9c398493
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/listblock/plugin.js
@@ -0,0 +1,240 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'listblock', {
+	requires: 'panel',
+
+	onLoad: function() {
+		var list = CKEDITOR.addTemplate( 'panel-list', '<ul role="presentation" class="cke_panel_list">{items}</ul>' ),
+			listItem = CKEDITOR.addTemplate( 'panel-list-item', '<li id="{id}" class="cke_panel_listItem" role=presentation>' +
+				'<a id="{id}_option" _cke_focus=1 hidefocus=true' +
+					' title="{title}"' +
+					' href="javascript:void(\'{val}\')" ' +
+					' {onclick}="CKEDITOR.tools.callFunction({clickFn},\'{val}\'); return false;"' + // #188
+						' role="option">' +
+					'{text}' +
+				'</a>' +
+				'</li>' ),
+			listGroup = CKEDITOR.addTemplate( 'panel-list-group', '<h1 id="{id}" class="cke_panel_grouptitle" role="presentation" >{label}</h1>' ),
+			reSingleQuote = /\'/g,
+			escapeSingleQuotes = function( str ) {
+				return str.replace( reSingleQuote, '\\\'' );
+			};
+
+		CKEDITOR.ui.panel.prototype.addListBlock = function( name, definition ) {
+			return this.addBlock( name, new CKEDITOR.ui.listBlock( this.getHolderElement(), definition ) );
+		};
+
+		CKEDITOR.ui.listBlock = CKEDITOR.tools.createClass( {
+			base: CKEDITOR.ui.panel.block,
+
+			$: function( blockHolder, blockDefinition ) {
+				blockDefinition = blockDefinition || {};
+
+				var attribs = blockDefinition.attributes || ( blockDefinition.attributes = {} );
+				( this.multiSelect = !!blockDefinition.multiSelect ) && ( attribs[ 'aria-multiselectable' ] = true );
+				// Provide default role of 'listbox'.
+				!attribs.role && ( attribs.role = 'listbox' );
+
+				// Call the base contructor.
+				this.base.apply( this, arguments );
+
+				// Set the proper a11y attributes.
+				this.element.setAttribute( 'role', attribs.role );
+
+				var keys = this.keys;
+				keys[ 40 ] = 'next'; // ARROW-DOWN
+				keys[ 9 ] = 'next'; // TAB
+				keys[ 38 ] = 'prev'; // ARROW-UP
+				keys[ CKEDITOR.SHIFT + 9 ] = 'prev'; // SHIFT + TAB
+				keys[ 32 ] = CKEDITOR.env.ie ? 'mouseup' : 'click'; // SPACE
+				CKEDITOR.env.ie && ( keys[ 13 ] = 'mouseup' ); // Manage ENTER, since onclick is blocked in IE (#8041).
+
+				this._.pendingHtml = [];
+				this._.pendingList = [];
+				this._.items = {};
+				this._.groups = {};
+			},
+
+			_: {
+				close: function() {
+					if ( this._.started ) {
+						var output = list.output( { items: this._.pendingList.join( '' ) } );
+						this._.pendingList = [];
+						this._.pendingHtml.push( output );
+						delete this._.started;
+					}
+				},
+
+				getClick: function() {
+					if ( !this._.click ) {
+						this._.click = CKEDITOR.tools.addFunction( function( value ) {
+							var marked = this.toggle( value );
+							if ( this.onClick )
+								this.onClick( value, marked );
+						}, this );
+					}
+					return this._.click;
+				}
+			},
+
+			proto: {
+				add: function( value, html, title ) {
+					var id = CKEDITOR.tools.getNextId();
+
+					if ( !this._.started ) {
+						this._.started = 1;
+						this._.size = this._.size || 0;
+					}
+
+					this._.items[ value ] = id;
+
+					var data = {
+						id: id,
+						val: escapeSingleQuotes( CKEDITOR.tools.htmlEncodeAttr( value ) ),
+						onclick: CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick',
+						clickFn: this._.getClick(),
+						title: CKEDITOR.tools.htmlEncodeAttr( title || value ),
+						text: html || value
+					};
+
+					this._.pendingList.push( listItem.output( data ) );
+				},
+
+				startGroup: function( title ) {
+					this._.close();
+
+					var id = CKEDITOR.tools.getNextId();
+
+					this._.groups[ title ] = id;
+
+					this._.pendingHtml.push( listGroup.output( { id: id, label: title } ) );
+				},
+
+				commit: function() {
+					this._.close();
+					this.element.appendHtml( this._.pendingHtml.join( '' ) );
+					delete this._.size;
+
+					this._.pendingHtml = [];
+				},
+
+				toggle: function( value ) {
+					var isMarked = this.isMarked( value );
+
+					if ( isMarked )
+						this.unmark( value );
+					else
+						this.mark( value );
+
+					return !isMarked;
+				},
+
+				hideGroup: function( groupTitle ) {
+					var group = this.element.getDocument().getById( this._.groups[ groupTitle ] ),
+						list = group && group.getNext();
+
+					if ( group ) {
+						group.setStyle( 'display', 'none' );
+
+						if ( list && list.getName() == 'ul' )
+							list.setStyle( 'display', 'none' );
+					}
+				},
+
+				hideItem: function( value ) {
+					this.element.getDocument().getById( this._.items[ value ] ).setStyle( 'display', 'none' );
+				},
+
+				showAll: function() {
+					var items = this._.items,
+						groups = this._.groups,
+						doc = this.element.getDocument();
+
+					for ( var value in items ) {
+						doc.getById( items[ value ] ).setStyle( 'display', '' );
+					}
+
+					for ( var title in groups ) {
+						var group = doc.getById( groups[ title ] ),
+							list = group.getNext();
+
+						group.setStyle( 'display', '' );
+
+						if ( list && list.getName() == 'ul' )
+							list.setStyle( 'display', '' );
+					}
+				},
+
+				mark: function( value ) {
+					if ( !this.multiSelect )
+						this.unmarkAll();
+
+					var itemId = this._.items[ value ],
+						item = this.element.getDocument().getById( itemId );
+					item.addClass( 'cke_selected' );
+
+					this.element.getDocument().getById( itemId + '_option' ).setAttribute( 'aria-selected', true );
+					this.onMark && this.onMark( item );
+				},
+
+				unmark: function( value ) {
+					var doc = this.element.getDocument(),
+						itemId = this._.items[ value ],
+						item = doc.getById( itemId );
+
+					item.removeClass( 'cke_selected' );
+					doc.getById( itemId + '_option' ).removeAttribute( 'aria-selected' );
+
+					this.onUnmark && this.onUnmark( item );
+				},
+
+				unmarkAll: function() {
+					var items = this._.items,
+						doc = this.element.getDocument();
+
+					for ( var value in items ) {
+						var itemId = items[ value ];
+
+						doc.getById( itemId ).removeClass( 'cke_selected' );
+						doc.getById( itemId + '_option' ).removeAttribute( 'aria-selected' );
+					}
+
+					this.onUnmark && this.onUnmark();
+				},
+
+				isMarked: function( value ) {
+					return this.element.getDocument().getById( this._.items[ value ] ).hasClass( 'cke_selected' );
+				},
+
+				focus: function( value ) {
+					this._.focusIndex = -1;
+
+					var links = this.element.getElementsByTag( 'a' ),
+						link,
+						selected,
+						i = -1;
+
+					if ( value ) {
+						selected = this.element.getDocument().getById( this._.items[ value ] ).getFirst();
+
+						while ( ( link = links.getItem( ++i ) ) ) {
+							if ( link.equals( selected ) ) {
+								this._.focusIndex = i;
+								break;
+							}
+						}
+					}
+					else
+						this.element.focus();
+
+					selected && setTimeout( function() {
+						selected.focus();
+					}, 0 );
+				}
+			}
+		} );
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/plugins/magicline/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/magicline/plugin.js
new file mode 100644
index 00000000..e4c6a944
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/magicline/plugin.js
@@ -0,0 +1,1838 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Allows accessing difficult focus spaces.
+ */
+
+'use strict';
+
+( function() {
+	CKEDITOR.plugins.add( 'magicline', {
+		lang: 'ar,bg,ca,cs,cy,de,el,en,en-gb,eo,es,et,eu,fa,fi,fr,fr-ca,gl,he,hr,hu,id,it,ja,km,ko,ku,lv,nb,nl,no,pl,pt,pt-br,ru,si,sk,sl,sq,sv,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		init: initPlugin
+	} );
+
+	// Activates the box inside of an editor.
+	function initPlugin( editor ) {
+		// Configurables
+		var config = editor.config,
+			triggerOffset = config.magicline_triggerOffset || 30,
+			enterMode = config.enterMode,
+			that = {
+				// Global stuff is being initialized here.
+				editor: editor,
+				enterMode: enterMode,
+				triggerOffset: triggerOffset,
+				holdDistance: 0 | triggerOffset * ( config.magicline_holdDistance || 0.5 ),
+				boxColor: config.magicline_color || '#ff0000',
+				rtl: config.contentsLangDirection == 'rtl',
+				tabuList: [ 'data-cke-hidden-sel' ].concat( config.magicline_tabuList || [] ),
+				triggers: config.magicline_everywhere ? DTD_BLOCK : { table: 1, hr: 1, div: 1, ul: 1, ol: 1, dl: 1, form: 1, blockquote: 1 }
+			},
+			scrollTimeout, checkMouseTimeoutPending, checkMouseTimeout, checkMouseTimer;
+
+		// %REMOVE_START%
+		// Internal DEBUG uses tools located in the topmost window.
+
+		// (#9701) Due to security limitations some browsers may throw
+		// errors when accessing window.top object. Do it safely first then.
+		try {
+			that.debug = window.top.DEBUG;
+		}
+		catch ( e ) {}
+
+		that.debug = that.debug || {
+			groupEnd: function() {},
+			groupStart: function() {},
+			log: function() {},
+			logElements: function() {},
+			logElementsEnd: function() {},
+			logEnd: function() {},
+			mousePos: function() {},
+			showHidden: function() {},
+			showTrigger: function() {},
+			startTimer: function() {},
+			stopTimer: function() {}
+		};
+		// %REMOVE_END%
+
+		// Simple irrelevant elements filter.
+		that.isRelevant = function( node ) {
+			return isHtml( node ) 			// 	-> Node must be an existing HTML element.
+				&& !isLine( that, node ) 	// 	-> Node can be neither the box nor its child.
+				&& !isFlowBreaker( node ); 	// 	-> Node can be neither floated nor positioned nor aligned.
+		};
+
+		editor.on( 'contentDom', addListeners, this );
+
+		function addListeners() {
+			var editable = editor.editable(),
+				doc = editor.document,
+				win = editor.window,
+				listener;
+
+			// Global stuff is being initialized here.
+			extend( that, {
+				editable: editable,
+				inInlineMode: editable.isInline(),
+				doc: doc,
+				win: win,
+				hotNode: null
+			}, true );
+
+			// This is the boundary of the editor. For inline the boundary is editable itself.
+			// For classic (`iframe`-based) editor, the HTML element is a real boundary.
+			that.boundary = that.inInlineMode ? that.editable : that.doc.getDocumentElement();
+
+			// Enabling the box inside of inline editable is pointless.
+			// There's no need to access spaces inside paragraphs, links, spans, etc.
+			if ( editable.is( dtd.$inline ) )
+				return;
+
+			// Handle in-line editing by setting appropriate position.
+			// If current position is static, make it relative and clear top/left coordinates.
+			if ( that.inInlineMode && !isPositioned( editable ) ) {
+				editable.setStyles( {
+					position: 'relative',
+					top: null,
+					left: null
+				} );
+			}
+			// Enable the box. Let it produce children elements, initialize
+			// event handlers and own methods.
+			initLine.call( this, that );
+
+			// Get view dimensions and scroll positions.
+			// At this stage (before any checkMouse call) it is used mostly
+			// by tests. Nevertheless it a crucial thing.
+			updateWindowSize( that );
+
+			// Remove the box before an undo image is created.
+			// This is important. If we didn't do that, the *undo thing* would revert the box into an editor.
+			// Thanks to that, undo doesn't even know about the existence of the box.
+			editable.attachListener( editor, 'beforeUndoImage', function() {
+				that.line.detach();
+			} );
+
+			// Removes the box HTML from editor data string if getData is called.
+			// Thanks to that, an editor never yields data polluted by the box.
+			// Listen with very high priority, so line will be removed before other
+			// listeners will see it.
+			editable.attachListener( editor, 'beforeGetData', function() {
+				// If the box is in editable, remove it.
+				if ( that.line.wrap.getParent() ) {
+					that.line.detach();
+
+					// Restore line in the last listener for 'getData'.
+					editor.once( 'getData', function() {
+						that.line.attach();
+					}, null, null, 1000 );
+				}
+			}, null, null, 0 );
+
+			// Hide the box on mouseout if mouse leaves document.
+			editable.attachListener( that.inInlineMode ? doc : doc.getWindow().getFrame(), 'mouseout', function( event ) {
+				if ( editor.mode != 'wysiwyg' )
+					return;
+
+				// Check for inline-mode editor. If so, check mouse position
+				// and remove the box if mouse outside of an editor.
+				if ( that.inInlineMode ) {
+					var mouse = {
+						x: event.data.$.clientX,
+						y: event.data.$.clientY
+					};
+
+					updateWindowSize( that );
+					updateEditableSize( that, true );
+
+					var size = that.view.editable,
+						scroll = that.view.scroll;
+
+					// If outside of an editor...
+					if ( !inBetween( mouse.x, size.left - scroll.x, size.right - scroll.x ) || !inBetween( mouse.y, size.top - scroll.y, size.bottom - scroll.y ) ) {
+						clearTimeout( checkMouseTimer );
+						checkMouseTimer = null;
+						that.line.detach();
+					}
+				}
+
+				else {
+					clearTimeout( checkMouseTimer );
+					checkMouseTimer = null;
+					that.line.detach();
+				}
+			} );
+
+			// This one deactivates hidden mode of an editor which
+			// prevents the box from being shown.
+			editable.attachListener( editable, 'keyup', function( event ) {
+				that.hiddenMode = 0;
+				that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+			} );
+
+			editable.attachListener( editable, 'keydown', function( event ) {
+				if ( editor.mode != 'wysiwyg' )
+					return;
+
+				var keyStroke = event.data.getKeystroke(),
+					selection = editor.getSelection(),
+					selected = selection.getStartElement();
+
+				switch ( keyStroke ) {
+					// Shift pressed
+					case 2228240: // IE
+					case 16:
+						that.hiddenMode = 1;
+						that.line.detach();
+				}
+
+				that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+			} );
+
+			// This method ensures that checkMouse aren't executed
+			// in parallel and no more frequently than specified in timeout function.
+			// In classic (`iframe`-based) editor, document is used as a trigger, to provide magicline
+			// functionality when mouse is below the body (short content, short body).
+			editable.attachListener( that.inInlineMode ? editable : doc, 'mousemove', function( event ) {
+				checkMouseTimeoutPending = true;
+
+				if ( editor.mode != 'wysiwyg' || editor.readOnly || checkMouseTimer )
+					return;
+
+				// IE<9 requires this event-driven object to be created
+				// outside of the setTimeout statement.
+				// Otherwise it loses the event object with its properties.
+				var mouse = {
+					x: event.data.$.clientX,
+					y: event.data.$.clientY
+				};
+
+				checkMouseTimer = setTimeout( function() {
+					checkMouse( mouse );
+				}, 30 ); // balances performance and accessibility
+			} );
+
+			// This one removes box on scroll event.
+			// It is to avoid box displacement.
+			editable.attachListener( win, 'scroll', function( event ) {
+				if ( editor.mode != 'wysiwyg' )
+					return;
+
+				that.line.detach();
+
+				// To figure this out just look at the mouseup
+				// event handler below.
+				if ( env.webkit ) {
+					that.hiddenMode = 1;
+
+					clearTimeout( scrollTimeout );
+					scrollTimeout = setTimeout( function() {
+						// Don't leave hidden mode until mouse remains pressed and
+						// scroll is being used, i.e. when dragging something.
+						if ( !that.mouseDown )
+							that.hiddenMode = 0;
+						that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+					}, 50 );
+
+					that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+				}
+			} );
+
+			// Those event handlers remove the box on mousedown
+			// and don't reveal it until the mouse is released.
+			// It is to prevent box insertion e.g. while scrolling
+			// (w/ scrollbar), selecting and so on.
+			editable.attachListener( env_ie8 ? doc : win, 'mousedown', function( event ) {
+				if ( editor.mode != 'wysiwyg' )
+					return;
+
+				that.line.detach();
+				that.hiddenMode = 1;
+				that.mouseDown = 1;
+
+				that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+			} );
+
+			// Google Chrome doesn't trigger this on the scrollbar (since 2009...)
+			// so it is totally useless to check for scroll finish
+			// see: http://code.google.com/p/chromium/issues/detail?id=14204
+			editable.attachListener( env_ie8 ? doc : win, 'mouseup', function( event ) {
+				that.hiddenMode = 0;
+				that.mouseDown = 0;
+				that.debug.showHidden( that.hiddenMode ); // %REMOVE_LINE%
+			} );
+
+			// Editor commands for accessing difficult focus spaces.
+			editor.addCommand( 'accessPreviousSpace', accessFocusSpaceCmd( that ) );
+			editor.addCommand( 'accessNextSpace', accessFocusSpaceCmd( that, true ) );
+
+			editor.setKeystroke( [
+				[ config.magicline_keystrokePrevious, 'accessPreviousSpace' ],
+				[ config.magicline_keystrokeNext, 'accessNextSpace' ]
+			] );
+
+			// Revert magicline hot node on undo/redo.
+			editor.on( 'loadSnapshot', function( event ) {
+				var elements, element, i;
+
+				for ( var t in { p: 1, br: 1, div: 1 } ) {
+					// document.find is not available in QM (#11149).
+					elements = editor.document.getElementsByTag( t );
+
+					for ( i = elements.count(); i--; ) {
+						if ( ( element = elements.getItem( i ) ).data( 'cke-magicline-hot' ) ) {
+							// Restore hotNode
+							that.hotNode = element;
+							// Restore last access direction
+							that.lastCmdDirection = element.data( 'cke-magicline-dir' ) === 'true' ? true : false;
+
+							return;
+						}
+					}
+				}
+			} );
+
+			// This method handles mousemove mouse for box toggling.
+			// It uses mouse position to determine underlying element, then
+			// it tries to use different trigger type in order to place the box
+			// in correct place. The following procedure is executed periodically.
+			function checkMouse( mouse ) {
+				that.debug.groupStart( 'CheckMouse' ); // %REMOVE_LINE%
+				that.debug.startTimer(); // %REMOVE_LINE%
+
+				that.mouse = mouse;
+				that.trigger = null;
+
+				checkMouseTimer = null;
+				updateWindowSize( that );
+
+				if ( checkMouseTimeoutPending 								//	-> There must be an event pending.
+					&& !that.hiddenMode 									// 	-> Can't be in hidden mode.
+					&& editor.focusManager.hasFocus 						// 	-> Editor must have focus.
+					&& !that.line.mouseNear() 								// 	-> Mouse pointer can't be close to the box.
+					&& ( that.element = elementFromMouse( that, true ) ) ) 	// 	-> There must be valid element.
+				{
+					// If trigger exists, and trigger is correct -> show the box.
+					// Don't show the line if trigger is a descendant of some tabu-list element.
+					if ( ( that.trigger = triggerEditable( that ) || triggerEdge( that ) || triggerExpand( that ) ) &&
+						!isInTabu( that, that.trigger.upper || that.trigger.lower ) ) {
+						that.line.attach().place();
+					}
+
+					// Otherwise remove the box
+					else {
+						that.trigger = null;
+						that.line.detach();
+					}
+
+					that.debug.showTrigger( that.trigger ); // %REMOVE_LINE%
+					that.debug.mousePos( mouse.y, that.element ); // %REMOVE_LINE%
+
+					checkMouseTimeoutPending = false;
+				}
+
+				that.debug.stopTimer(); // %REMOVE_LINE%
+				that.debug.groupEnd(); // %REMOVE_LINE%
+			}
+
+			// This one allows testing and debugging. It reveals some
+			// inner methods to the world.
+			this.backdoor = {
+				accessFocusSpace: accessFocusSpace,
+				boxTrigger: boxTrigger,
+				isLine: isLine,
+				getAscendantTrigger: getAscendantTrigger,
+				getNonEmptyNeighbour: getNonEmptyNeighbour,
+				getSize: getSize,
+				that: that,
+				triggerEdge: triggerEdge,
+				triggerEditable: triggerEditable,
+				triggerExpand: triggerExpand
+			};
+		}
+	}
+
+	// Some shorthands for common methods to save bytes
+	var extend = CKEDITOR.tools.extend,
+		newElement = CKEDITOR.dom.element,
+		newElementFromHtml = newElement.createFromHtml,
+		env = CKEDITOR.env,
+		env_ie8 = CKEDITOR.env.ie && CKEDITOR.env.version < 9,
+		dtd = CKEDITOR.dtd,
+
+		// Global object associating enter modes with elements.
+		enterElements = {},
+
+		// Constant values, types and so on.
+		EDGE_TOP = 128,
+		EDGE_BOTTOM = 64,
+		EDGE_MIDDLE = 32,
+		TYPE_EDGE = 16,
+		TYPE_EXPAND = 8,
+		LOOK_TOP = 4,
+		LOOK_BOTTOM = 2,
+		LOOK_NORMAL = 1,
+		WHITE_SPACE = '\u00A0',
+		DTD_LISTITEM = dtd.$listItem,
+		DTD_TABLECONTENT = dtd.$tableContent,
+		DTD_NONACCESSIBLE = extend( {}, dtd.$nonEditable, dtd.$empty ),
+		DTD_BLOCK = dtd.$block,
+
+		// Minimum time that must elapse between two update*Size calls.
+		// It prevents constant getComuptedStyle calls and improves performance.
+		CACHE_TIME = 100,
+
+		// Shared CSS stuff for box elements
+		CSS_COMMON = 'width:0px;height:0px;padding:0px;margin:0px;display:block;' + 'z-index:9999;color:#fff;position:absolute;font-size: 0px;line-height:0px;',
+		CSS_TRIANGLE = CSS_COMMON + 'border-color:transparent;display:block;border-style:solid;',
+		TRIANGLE_HTML = '<span>' + WHITE_SPACE + '</span>';
+
+	enterElements[ CKEDITOR.ENTER_BR ] = 'br';
+	enterElements[ CKEDITOR.ENTER_P ] = 'p';
+	enterElements[ CKEDITOR.ENTER_DIV ] = 'div';
+
+	function areSiblings( that, upper, lower ) {
+		return isHtml( upper ) && isHtml( lower ) && lower.equals( upper.getNext( function( node ) {
+			return !( isEmptyTextNode( node ) || isComment( node ) || isFlowBreaker( node ) );
+		} ) );
+	}
+
+	// boxTrigger is an abstract type which describes
+	// the relationship between elements that may result
+	// in showing the box.
+	//
+	// The following type is used by numerous methods
+	// to share information about the hypothetical box placement
+	// and look by referring to boxTrigger properties.
+	function boxTrigger( triggerSetup ) {
+		this.upper = triggerSetup[ 0 ];
+		this.lower = triggerSetup[ 1 ];
+		this.set.apply( this, triggerSetup.slice( 2 ) );
+	}
+
+	boxTrigger.prototype = {
+		set: function( edge, type, look ) {
+			this.properties = edge + type + ( look || LOOK_NORMAL );
+			return this;
+		},
+
+		is: function( property ) {
+			return ( this.properties & property ) == property;
+		}
+	};
+
+	var elementFromMouse = ( function() {
+		function elementFromPoint( doc, mouse ) {
+			return new CKEDITOR.dom.element( doc.$.elementFromPoint( mouse.x, mouse.y ) );
+		}
+
+		return function( that, ignoreBox, forceMouse ) {
+			if ( !that.mouse )
+				return null;
+
+			var doc = that.doc,
+				lineWrap = that.line.wrap,
+				mouse = forceMouse || that.mouse,
+				element = elementFromPoint( doc, mouse );
+
+			// If ignoreBox is set and element is the box, it means that we
+			// need to hide the box for a while, repeat elementFromPoint
+			// and show it again.
+			if ( ignoreBox && isLine( that, element ) ) {
+				lineWrap.hide();
+				element = elementFromPoint( doc, mouse );
+				lineWrap.show();
+			}
+
+			// Return nothing if:
+			//	\-> Element is not HTML.
+			if ( !( element && element.type == CKEDITOR.NODE_ELEMENT && element.$ ) )
+				return null;
+
+			// Also return nothing if:
+			//	\-> We're IE<9 and element is out of the top-level element (editable for inline and HTML for classic (`iframe`-based)).
+			//		This is due to the bug which allows IE<9 firing mouse events on element
+			//		with contenteditable=true while doing selection out (far, away) of the element.
+			//		Thus we must always be sure that we stay in editable or HTML.
+			if ( env.ie && env.version < 9 ) {
+				if ( !( that.boundary.equals( element ) || that.boundary.contains( element ) ) )
+					return null;
+			}
+
+			return element;
+		};
+	} )();
+
+	// Gets the closest parent node that belongs to triggers group.
+	function getAscendantTrigger( that ) {
+		var node = that.element,
+			trigger;
+
+		if ( node && isHtml( node ) ) {
+			trigger = node.getAscendant( that.triggers, true );
+
+			// If trigger is an element, neither editable nor editable's ascendant.
+			if ( trigger && that.editable.contains( trigger ) ) {
+				// Check for closest editable limit.
+				var limit = getClosestEditableLimit( trigger, true );
+
+				// Trigger in nested editable area.
+				if ( limit.getAttribute( 'contenteditable' ) == 'true' )
+					return trigger;
+				// Trigger in non-editable area.
+				else if ( limit.is( that.triggers ) )
+					return limit;
+				else
+					return null;
+
+				return trigger;
+			} else
+				return null;
+		}
+
+		return null;
+	}
+
+	function getMidpoint( that, upper, lower ) {
+		updateSize( that, upper );
+		updateSize( that, lower );
+
+		var upperSizeBottom = upper.size.bottom,
+			lowerSizeTop = lower.size.top;
+
+		return upperSizeBottom && lowerSizeTop ? 0 | ( upperSizeBottom + lowerSizeTop ) / 2 : upperSizeBottom || lowerSizeTop;
+	}
+
+	// Get nearest node (either text or HTML), but:
+	//	\->	Omit all empty text nodes (containing white characters only).
+	//	\-> Omit BR elements
+	//	\-> Omit flow breakers.
+	function getNonEmptyNeighbour( that, node, goBack ) {
+		node = node[ goBack ? 'getPrevious' : 'getNext' ]( function( node ) {
+			return ( isTextNode( node ) && !isEmptyTextNode( node ) ) ||
+				( isHtml( node ) && !isFlowBreaker( node ) && !isLine( that, node ) );
+		} );
+
+		return node;
+	}
+
+	function inBetween( val, lower, upper ) {
+		return val > lower && val < upper;
+	}
+
+	// Returns the closest ancestor that has contenteditable attribute.
+	// Such ancestor is the limit of (non-)editable DOM branch that element
+	// belongs to. This method omits editor editable.
+	function getClosestEditableLimit( element, includeSelf ) {
+		if ( element.data( 'cke-editable' ) )
+			return null;
+
+		if ( !includeSelf )
+			element = element.getParent();
+
+		while ( element ) {
+			if ( element.data( 'cke-editable' ) )
+				return null;
+
+			if ( element.hasAttribute( 'contenteditable' ) )
+				return element;
+
+			element = element.getParent();
+		}
+
+		return null;
+	}
+
+	// Access space line consists of a few elements (spans):
+	// 	\-> Line wrapper.
+	// 	\-> Line.
+	// 	\-> Line triangles: left triangle (LT), right triangle (RT).
+	// 	\-> Button handler (BTN).
+	//
+	//	+--------------------------------------------------- line.wrap (span) -----+
+	//	| +---------------------------------------------------- line (span) -----+ |
+	//	| | +- LT \                                           +- BTN -+  / RT -+ | |
+	//	| | |      \                                          |     | | /      | | |
+	//	| | |      /                                          |  <__| | \      | | |
+	//	| | +-----/                                           +-------+  \-----+ | |
+	//	| +----------------------------------------------------------------------+ |
+	//  +--------------------------------------------------------------------------+
+	//
+	function initLine( that ) {
+		var doc = that.doc,
+			// This the main box element that holds triangles and the insertion button
+			line = newElementFromHtml( '<span contenteditable="false" style="' + CSS_COMMON + 'position:absolute;border-top:1px dashed ' + that.boxColor + '"></span>', doc ),
+			iconPath = this.path + 'images/' + ( env.hidpi ? 'hidpi/' : '' ) + 'icon.png';
+
+		extend( line, {
+
+			attach: function() {
+				// Only if not already attached
+				if ( !this.wrap.getParent() )
+					this.wrap.appendTo( that.editable, true );
+
+				return this;
+			},
+
+			// Looks are as follows: [ LOOK_TOP, LOOK_BOTTOM, LOOK_NORMAL ].
+			lineChildren: [
+				extend(
+					newElementFromHtml( '<span title="' + that.editor.lang.magicline.title +
+						'" contenteditable="false">&#8629;</span>', doc ), {
+					base: CSS_COMMON + 'height:17px;width:17px;' + ( that.rtl ? 'left' : 'right' ) + ':17px;'
+						+ 'background:url(' + iconPath + ') center no-repeat ' + that.boxColor + ';cursor:pointer;'
+						+ ( env.hc ? 'font-size: 15px;line-height:14px;border:1px solid #fff;text-align:center;' : '' )
+						+ ( env.hidpi ? 'background-size: 9px 10px;' : '' ),
+					looks: [
+						'top:-8px;' + CKEDITOR.tools.cssVendorPrefix( 'border-radius', '2px', 1 ),
+						'top:-17px;' + CKEDITOR.tools.cssVendorPrefix( 'border-radius', '2px 2px 0px 0px', 1 ),
+						'top:-1px;' + CKEDITOR.tools.cssVendorPrefix( 'border-radius', '0px 0px 2px 2px', 1 )
+					]
+				} ),
+				extend( newElementFromHtml( TRIANGLE_HTML, doc ), {
+					base: CSS_TRIANGLE + 'left:0px;border-left-color:' + that.boxColor + ';',
+					looks: [
+						'border-width:8px 0 8px 8px;top:-8px',
+						'border-width:8px 0 0 8px;top:-8px',
+						'border-width:0 0 8px 8px;top:0px'
+					]
+				} ),
+				extend( newElementFromHtml( TRIANGLE_HTML, doc ), {
+					base: CSS_TRIANGLE + 'right:0px;border-right-color:' + that.boxColor + ';',
+					looks: [
+						'border-width:8px 8px 8px 0;top:-8px',
+						'border-width:8px 8px 0 0;top:-8px',
+						'border-width:0 8px 8px 0;top:0px'
+					]
+				} )
+			],
+
+			detach: function() {
+				// Detach only if already attached.
+				if ( this.wrap.getParent() )
+					this.wrap.remove();
+
+				return this;
+			},
+
+			// Checks whether mouseY is around an element by comparing boundaries and considering
+			// an offset distance.
+			mouseNear: function() {
+				that.debug.groupStart( 'mouseNear' ); // %REMOVE_LINE%
+
+				updateSize( that, this );
+				var offset = that.holdDistance,
+					size = this.size;
+
+				// Determine neighborhood by element dimensions and offsets.
+				if ( size && inBetween( that.mouse.y, size.top - offset, size.bottom + offset ) && inBetween( that.mouse.x, size.left - offset, size.right + offset ) ) {
+					that.debug.logEnd( 'Mouse is near.' ); // %REMOVE_LINE%
+					return true;
+				}
+
+				that.debug.logEnd( 'Mouse isn\'t near.' ); // %REMOVE_LINE%
+				return false;
+			},
+
+			// Adjusts position of the box according to the trigger properties.
+			// If also affects look of the box depending on the type of the trigger.
+			place: function() {
+				var view = that.view,
+					editable = that.editable,
+					trigger = that.trigger,
+					upper = trigger.upper,
+					lower = trigger.lower,
+					any = upper || lower,
+					parent = any.getParent(),
+					styleSet = {};
+
+				// Save recent trigger for further insertion.
+				// It is necessary due to the fact, that that.trigger may
+				// contain different boxTrigger at the moment of insertion
+				// or may be even null.
+				this.trigger = trigger;
+
+				upper && updateSize( that, upper, true );
+				lower && updateSize( that, lower, true );
+				updateSize( that, parent, true );
+
+				// Yeah, that's gonna be useful in inline-mode case.
+				if ( that.inInlineMode )
+					updateEditableSize( that, true );
+
+				// Set X coordinate (left, right, width).
+				if ( parent.equals( editable ) ) {
+					styleSet.left = view.scroll.x;
+					styleSet.right = -view.scroll.x;
+					styleSet.width = '';
+				} else {
+					styleSet.left = any.size.left - any.size.margin.left + view.scroll.x - ( that.inInlineMode ? view.editable.left + view.editable.border.left : 0 );
+					styleSet.width = any.size.outerWidth + any.size.margin.left + any.size.margin.right + view.scroll.x;
+					styleSet.right = '';
+				}
+
+				// Set Y coordinate (top) for trigger consisting of two elements.
+				if ( upper && lower ) {
+					// No margins at all or they're equal. Place box right between.
+					if ( upper.size.margin.bottom === lower.size.margin.top )
+						styleSet.top = 0 | ( upper.size.bottom + upper.size.margin.bottom / 2 );
+					else {
+						// Upper margin < lower margin. Place at lower margin.
+						if ( upper.size.margin.bottom < lower.size.margin.top )
+							styleSet.top = upper.size.bottom + upper.size.margin.bottom;
+						// Upper margin > lower margin. Place at upper margin - lower margin.
+						else
+							styleSet.top = upper.size.bottom + upper.size.margin.bottom - lower.size.margin.top;
+					}
+				}
+				// Set Y coordinate (top) for single-edge trigger.
+				else if ( !upper )
+					styleSet.top = lower.size.top - lower.size.margin.top;
+				else if ( !lower )
+					styleSet.top = upper.size.bottom + upper.size.margin.bottom;
+
+				// Set box button modes if close to the viewport horizontal edge
+				// or look forced by the trigger.
+				if ( trigger.is( LOOK_TOP ) || inBetween( styleSet.top, view.scroll.y - 15, view.scroll.y + 5 ) ) {
+					styleSet.top = that.inInlineMode ? 0 : view.scroll.y;
+					this.look( LOOK_TOP );
+				} else if ( trigger.is( LOOK_BOTTOM ) || inBetween( styleSet.top, view.pane.bottom - 5, view.pane.bottom + 15 ) ) {
+					styleSet.top = that.inInlineMode ?
+							view.editable.height + view.editable.padding.top + view.editable.padding.bottom
+						:
+							view.pane.bottom - 1;
+
+					this.look( LOOK_BOTTOM );
+				} else {
+					if ( that.inInlineMode )
+						styleSet.top -= view.editable.top + view.editable.border.top;
+
+					this.look( LOOK_NORMAL );
+				}
+
+				if ( that.inInlineMode ) {
+					// 1px bug here...
+					styleSet.top--;
+
+					// Consider the editable to be an element with overflow:scroll
+					// and non-zero scrollTop/scrollLeft value.
+					// For example: divarea editable. (#9383)
+					styleSet.top += view.editable.scroll.top;
+					styleSet.left += view.editable.scroll.left;
+				}
+
+				// Append `px` prefixes.
+				for ( var style in styleSet )
+					styleSet[ style ] = CKEDITOR.tools.cssLength( styleSet[ style ] );
+
+				this.setStyles( styleSet );
+			},
+
+			// Changes look of the box according to current needs.
+			// Three different styles are available: [ LOOK_TOP, LOOK_BOTTOM, LOOK_NORMAL ].
+			look: function( look ) {
+				if ( this.oldLook == look )
+					return;
+
+				for ( var i = this.lineChildren.length, child; i--; )
+					( child = this.lineChildren[ i ] ).setAttribute( 'style', child.base + child.looks[ 0 | look / 2 ] );
+
+				this.oldLook = look;
+			},
+
+			wrap: new newElement( 'span', that.doc )
+
+		} );
+
+		// Insert children into the box.
+		for ( var i = line.lineChildren.length; i--; )
+			line.lineChildren[ i ].appendTo( line );
+
+		// Set default look of the box.
+		line.look( LOOK_NORMAL );
+
+		// Using that wrapper prevents IE (8,9) from resizing editable area at the moment
+		// of box insertion. This works thanks to the fact, that positioned box is wrapped by
+		// an inline element. So much tricky.
+		line.appendTo( line.wrap );
+
+		// Make the box unselectable.
+		line.unselectable();
+
+		// Handle accessSpace node insertion.
+		line.lineChildren[ 0 ].on( 'mouseup', function( event ) {
+			line.detach();
+
+			accessFocusSpace( that, function( accessNode ) {
+				// Use old trigger that was saved by 'place' method. Look: line.place
+				var trigger = that.line.trigger;
+
+				accessNode[ trigger.is( EDGE_TOP ) ? 'insertBefore' : 'insertAfter' ]
+					( trigger.is( EDGE_TOP ) ? trigger.lower : trigger.upper );
+			}, true );
+
+			that.editor.focus();
+
+			if ( !env.ie && that.enterMode != CKEDITOR.ENTER_BR )
+				that.hotNode.scrollIntoView();
+
+			event.data.preventDefault( true );
+		} );
+
+		// Prevents IE9 from displaying the resize box and disables drag'n'drop functionality.
+		line.on( 'mousedown', function( event ) {
+			event.data.preventDefault( true );
+		} );
+
+		that.line = line;
+	}
+
+	// This function allows accessing any focus space according to the insert function:
+	// 	* For enterMode ENTER_P it creates P element filled with dummy white-space.
+	// 	* For enterMode ENTER_DIV it creates DIV element filled with dummy white-space.
+	// 	* For enterMode ENTER_BR it creates BR element or &nbsp; in IE.
+	//
+	// The node is being inserted according to insertFunction. Finally the method
+	// selects the non-breaking space making the node ready for typing.
+	function accessFocusSpace( that, insertFunction, doSave ) {
+		var range = new CKEDITOR.dom.range( that.doc ),
+			editor = that.editor,
+			accessNode;
+
+		// IE requires text node of &nbsp; in ENTER_BR mode.
+		if ( env.ie && that.enterMode == CKEDITOR.ENTER_BR )
+			accessNode = that.doc.createText( WHITE_SPACE );
+
+		// In other cases a regular element is used.
+		else {
+			// Use the enterMode of editable's limit or editor's
+			// enter mode if not in nested editable.
+			var limit = getClosestEditableLimit( that.element, true ),
+
+				// This is an enter mode for the context. We cannot use
+				// editor.activeEnterMode because the focused nested editable will
+				// have a different enterMode as editor but magicline will be inserted
+				// directly into editor's editable.
+				enterMode = limit && limit.data( 'cke-enter-mode' ) || that.enterMode;
+
+			accessNode = new newElement( enterElements[ enterMode ], that.doc );
+
+			if ( !accessNode.is( 'br' ) ) {
+				var dummy = that.doc.createText( WHITE_SPACE );
+				dummy.appendTo( accessNode );
+			}
+		}
+
+		doSave && editor.fire( 'saveSnapshot' );
+
+		insertFunction( accessNode );
+		//dummy.appendTo( accessNode );
+		range.moveToPosition( accessNode, CKEDITOR.POSITION_AFTER_START );
+		editor.getSelection().selectRanges( [ range ] );
+		that.hotNode = accessNode;
+
+		doSave && editor.fire( 'saveSnapshot' );
+	}
+
+	// Access focus space on demand by taking an element under the caret as a reference.
+	// The space is accessed provided the element under the caret is trigger AND:
+	//
+	//  1. First/last-child of its parent:
+	//		+----------------------- Parent element -+
+	//		| +------------------------------ DIV -+ |	<-- Access before
+	//		| | Foo^                               | |
+	//		| |                                    | |
+	//		| +------------------------------------+ |	<-- Access after
+	//		+----------------------------------------+
+	//
+	//                       OR
+	//
+	//  2. It has a direct sibling element, which is also a trigger:
+	//		+-------------------------------- DIV#1 -+
+	//		| Foo^                                   |
+	//		|                                        |
+	//		+----------------------------------------+
+	//                                                	<-- Access here
+	//		+-------------------------------- DIV#2 -+
+	//		| Bar                                    |
+	//		|                                        |
+	//		+----------------------------------------+
+	//
+	//                       OR
+	//
+	//  3. It has a direct sibling, which is a trigger and has a valid neighbour trigger,
+	//     but belongs to dtd.$.empty/nonEditable:
+	//		+------------------------------------ P -+
+	//		| Foo^                                   |
+	//		|                                        |
+	//		+----------------------------------------+
+	//		+----------------------------------- HR -+
+	//                                                	<-- Access here
+	//		+-------------------------------- DIV#2 -+
+	//		| Bar                                    |
+	//		|                                        |
+	//		+----------------------------------------+
+	//
+	function accessFocusSpaceCmd( that, insertAfter ) {
+		return {
+			canUndo: true,
+			modes: { wysiwyg: 1 },
+			exec: ( function() {
+
+				// Inserts line (accessNode) at the position by taking target node as a reference.
+				function doAccess( target ) {
+					// Remove old hotNode under certain circumstances.
+					var hotNodeChar = ( env.ie && env.version < 9 ? ' ' : WHITE_SPACE ),
+						removeOld = that.hotNode &&							// Old hotNode must exist.
+							that.hotNode.getText() == hotNodeChar &&		// Old hotNode hasn't been changed.
+							that.element.equals( that.hotNode ) &&			// Caret is inside old hotNode.
+							that.lastCmdDirection === !!insertAfter;		// Command is executed in the same direction.
+
+					accessFocusSpace( that, function( accessNode ) {
+						if ( removeOld && that.hotNode )
+							that.hotNode.remove();
+
+						accessNode[ insertAfter ? 'insertAfter' : 'insertBefore' ]( target );
+
+						// Make this element distinguishable. Also remember the direction
+						// it's been inserted into document.
+						accessNode.setAttributes( {
+							'data-cke-magicline-hot': 1,
+							'data-cke-magicline-dir': !!insertAfter
+						} );
+
+						// Save last direction of the command (is insertAfter?).
+						that.lastCmdDirection = !!insertAfter;
+					} );
+
+					if ( !env.ie && that.enterMode != CKEDITOR.ENTER_BR )
+						that.hotNode.scrollIntoView();
+
+					// Detach the line if was visible (previously triggered by mouse).
+					that.line.detach();
+				}
+
+				return function( editor ) {
+					var selected = editor.getSelection().getStartElement(),
+						limit;
+
+					// (#9833) Go down to the closest non-inline element in DOM structure
+					// since inline elements don't participate in in magicline.
+					selected = selected.getAscendant( DTD_BLOCK, 1 );
+
+					// Stop if selected is a child of a tabu-list element.
+					if ( isInTabu( that, selected ) )
+						return;
+
+					// Sometimes it may happen that there's no parent block below selected element
+					// or, for example, getAscendant reaches editable or editable parent.
+					// We must avoid such pathological cases.
+					if ( !selected || selected.equals( that.editable ) || selected.contains( that.editable ) )
+						return;
+
+					// Executing the command directly in nested editable should
+					// access space before/after it.
+					if ( ( limit = getClosestEditableLimit( selected ) ) && limit.getAttribute( 'contenteditable' ) == 'false' )
+						selected = limit;
+
+					// That holds element from mouse. Replace it with the
+					// element under the caret.
+					that.element = selected;
+
+					// (3.) Handle the following cases where selected neighbour
+					// is a trigger inaccessible for the caret AND:
+					//	- Is first/last-child
+					//	OR
+					//	- Has a sibling, which is also a trigger.
+					var neighbor = getNonEmptyNeighbour( that, selected, !insertAfter ),
+						neighborSibling;
+
+					// Check for a neighbour that belongs to triggers.
+					// Consider only non-accessible elements (they cannot have any children)
+					// since they cannot be given a caret inside, to run the command
+					// the regular way (1. & 2.).
+					if ( isHtml( neighbor ) && neighbor.is( that.triggers ) && neighbor.is( DTD_NONACCESSIBLE ) &&
+							(
+									// Check whether neighbor is first/last-child.
+									!getNonEmptyNeighbour( that, neighbor, !insertAfter )
+								||
+									// Check for a sibling of a neighbour that also is a trigger.
+									(
+										( neighborSibling = getNonEmptyNeighbour( that, neighbor, !insertAfter ) ) &&
+										isHtml( neighborSibling ) &&
+										neighborSibling.is( that.triggers )
+									)
+							)
+						) {
+						doAccess( neighbor );
+						return;
+					}
+
+					// Look for possible target element DOWN "selected" DOM branch (towards editable)
+					// that belong to that.triggers
+					var target = getAscendantTrigger( that, selected );
+
+					// No HTML target -> no access.
+					if ( !isHtml( target ) )
+						return;
+
+					// (1.) Target is first/last child -> access.
+					if ( !getNonEmptyNeighbour( that, target, !insertAfter ) ) {
+						doAccess( target );
+						return;
+					}
+
+					var sibling = getNonEmptyNeighbour( that, target, !insertAfter );
+
+					// (2.) Target has a sibling that belongs to that.triggers -> access.
+					if ( sibling && isHtml( sibling ) && sibling.is( that.triggers ) ) {
+						doAccess( target );
+						return;
+					}
+				};
+			} )()
+		};
+	}
+
+	function isLine( that, node ) {
+		if ( !( node && node.type == CKEDITOR.NODE_ELEMENT && node.$ ) )
+			return false;
+
+		var line = that.line;
+
+		return line.wrap.equals( node ) || line.wrap.contains( node );
+	}
+
+	// Is text node containing white-spaces only?
+	var isEmptyTextNode = CKEDITOR.dom.walker.whitespaces();
+
+	// Is fully visible HTML node?
+	function isHtml( node ) {
+		return node && node.type == CKEDITOR.NODE_ELEMENT && node.$;	// IE requires that
+	}
+
+	function isFloated( element ) {
+		if ( !isHtml( element ) )
+			return false;
+
+		var options = { left: 1, right: 1, center: 1 };
+
+		return !!( options[ element.getComputedStyle( 'float' ) ] || options[ element.getAttribute( 'align' ) ] );
+	}
+
+	function isFlowBreaker( element ) {
+		if ( !isHtml( element ) )
+			return false;
+
+		return isPositioned( element ) || isFloated( element );
+	}
+
+	// Isn't node of NODE_COMMENT type?
+	var isComment = CKEDITOR.dom.walker.nodeType( CKEDITOR.NODE_COMMENT );
+
+	function isPositioned( element ) {
+		return !!{ absolute: 1, fixed: 1 }[ element.getComputedStyle( 'position' ) ];
+	}
+
+	// Is text node?
+	function isTextNode( node ) {
+		return node && node.type == CKEDITOR.NODE_TEXT;
+	}
+
+	function isTrigger( that, element ) {
+		return isHtml( element ) ? element.is( that.triggers ) : null;
+	}
+
+	function isInTabu( that, element ) {
+		if ( !element )
+			return false;
+
+		var parents = element.getParents( 1 );
+
+		for ( var i = parents.length ; i-- ; ) {
+			for ( var j = that.tabuList.length ; j-- ; ) {
+				if ( parents[ i ].hasAttribute( that.tabuList[ j ] ) )
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	// This function checks vertically is there's a relevant child between element's edge
+	// and the pointer.
+	//	\-> Table contents are omitted.
+	function isChildBetweenPointerAndEdge( that, parent, edgeBottom ) {
+		var edgeChild = parent[ edgeBottom ? 'getLast' : 'getFirst' ]( function( node ) {
+			return that.isRelevant( node ) && !node.is( DTD_TABLECONTENT );
+		} );
+
+		if ( !edgeChild )
+			return false;
+
+		updateSize( that, edgeChild );
+
+		return edgeBottom ? edgeChild.size.top > that.mouse.y : edgeChild.size.bottom < that.mouse.y;
+	}
+
+	// This method handles edge cases:
+	// 	\-> Mouse is around upper or lower edge of view pane.
+	// 	\-> Also scroll position is either minimal or maximal.
+	// 	\-> It's OK to show LOOK_TOP(BOTTOM) type line.
+	//
+	// This trigger doesn't need additional post-filtering.
+	//
+	//	+----------------------------- Editable -+  /--
+	//	| +---------------------- First child -+ |  | <-- Top edge (first child)
+	//	| |                                    | |  |
+	//	| |                                    | |  |	 * Mouse activation area *
+	//	| |                                    | |  |
+	//	| |                 ...                | |	\-- Top edge + trigger offset
+	//	| .                                    . |
+	//	|                                        |
+	//	| .                                    . |
+	//	| |                 ...                | |  /-- Bottom edge - trigger offset
+	//	| |                                    | |  |
+	//	| |                                    | |  |	 * Mouse activation area *
+	//	| |                                    | |  |
+	//	| +----------------------- Last child -+ |  | <-- Bottom edge (last child)
+	//	+----------------------------------------+  \--
+	//
+	function triggerEditable( that ) {
+		that.debug.groupStart( 'triggerEditable' ); // %REMOVE_LINE%
+
+		var editable = that.editable,
+			mouse = that.mouse,
+			view = that.view,
+			triggerOffset = that.triggerOffset,
+			triggerLook;
+
+		// Update editable dimensions.
+		updateEditableSize( that );
+
+		// This flag determines whether checking bottom trigger.
+		var bottomTrigger = mouse.y > ( that.inInlineMode ?
+				view.editable.top + view.editable.height / 2
+			:
+				// This is to handle case when editable.height / 2 <<< pane.height.
+				Math.min( view.editable.height, view.pane.height ) / 2 ),
+
+		// Edge node according to bottomTrigger.
+		edgeNode = editable[ bottomTrigger ? 'getLast' : 'getFirst' ]( function( node ) {
+			return !( isEmptyTextNode( node ) || isComment( node ) );
+		} );
+
+		// There's no edge node. Abort.
+		if ( !edgeNode ) {
+			that.debug.logEnd( 'ABORT. No edge node found.' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		// If the edgeNode in editable is ML, get the next one.
+		if ( isLine( that, edgeNode ) ) {
+			edgeNode = that.line.wrap[ bottomTrigger ? 'getPrevious' : 'getNext' ]( function( node ) {
+				return !( isEmptyTextNode( node ) || isComment( node ) );
+			} );
+		}
+
+		// Exclude bad nodes (no ML needed then):
+		//	\-> Edge node is text.
+		//	\-> Edge node is floated, etc.
+		//
+		// Edge node *must be* a valid trigger at this stage as well.
+		if ( !isHtml( edgeNode ) || isFlowBreaker( edgeNode ) || !isTrigger( that, edgeNode ) ) {
+			that.debug.logEnd( 'ABORT. Invalid edge node.' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		// Update size of edge node. Dimensions will be necessary.
+		updateSize( that, edgeNode );
+
+		// Return appropriate trigger according to bottomTrigger.
+		// \->	Top edge trigger case first.
+		if ( !bottomTrigger &&													// Top trigger case.
+			edgeNode.size.top >= 0 &&											// Check if the first element is fully visible.
+			inBetween( mouse.y, 0, edgeNode.size.top + triggerOffset ) ) {		// Check if mouse in [0, edgeNode.top + triggerOffset].
+
+			// Determine trigger look.
+			triggerLook = that.inInlineMode || view.scroll.y === 0 ?
+				LOOK_TOP : LOOK_NORMAL;
+
+			that.debug.logEnd( 'SUCCESS. Created box trigger. EDGE_TOP.' ); // %REMOVE_LINE%
+
+			return new boxTrigger( [ null, edgeNode,
+				EDGE_TOP,
+				TYPE_EDGE,
+				triggerLook
+			] );
+		}
+
+		// \->	Bottom case.
+		else if ( bottomTrigger &&
+			edgeNode.size.bottom <= view.pane.height &&							// Check if the last element is fully visible
+			inBetween( mouse.y,													// Check if mouse in...
+				edgeNode.size.bottom - triggerOffset, view.pane.height ) ) {	// [ edgeNode.bottom - triggerOffset, paneHeight ]
+
+			// Determine trigger look.
+			triggerLook = that.inInlineMode ||
+				inBetween( edgeNode.size.bottom, view.pane.height - triggerOffset, view.pane.height ) ?
+					LOOK_BOTTOM : LOOK_NORMAL;
+
+			that.debug.logEnd( 'SUCCESS. Created box trigger. EDGE_BOTTOM.' ); // %REMOVE_LINE%
+
+			return new boxTrigger( [ edgeNode, null,
+				EDGE_BOTTOM,
+				TYPE_EDGE,
+				triggerLook
+			] );
+		}
+
+		that.debug.logEnd( 'ABORT. No trigger created.' ); // %REMOVE_LINE%
+		return null;
+	}
+
+	// This method covers cases *inside* of an element:
+	// 	\->	The pointer is in the top (bottom) area of an element and there's
+	//		HTML node before (after) this element.
+	// 	\-> An element being the first or last child of its parent.
+	//
+	//	+----------------------- Parent element -+
+	//	| +----------------------- Element #1 -+ |  /--
+	//	| |                                    | |  |	 * Mouse activation area (as first child) *
+	//	| |                                    | |  \--
+	//	| |                                    | |  /--
+	//	| |                                    | |  |	 * Mouse activation area (Element #2) *
+	//	| +------------------------------------+ |  \--
+	//	|                                        |
+	//	| +----------------------- Element #2 -+ |  /--
+	//	| |                                    | |  |	 * Mouse activation area (Element #1) *
+	//	| |                                    | |  \--
+	//	| |                                    | |
+	//	| +------------------------------------+ |
+	//	|                                        |
+	//	|            Text node is here.          |
+	//	|                                        |
+	//	| +----------------------- Element #3 -+ |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| |                                    | |  /--
+	//	| |                                    | |  |	 * Mouse activation area (as last child) *
+	//	| +------------------------------------+ |  \--
+	//	+----------------------------------------+
+	//
+	function triggerEdge( that ) {
+		that.debug.groupStart( 'triggerEdge' ); // %REMOVE_LINE%
+
+		var mouse = that.mouse,
+			view = that.view,
+			triggerOffset = that.triggerOffset;
+
+		// Get the ascendant trigger basing on elementFromMouse.
+		var element = getAscendantTrigger( that );
+
+		that.debug.logElements( [ element ], [ 'Ascendant trigger' ], 'First stage' ); // %REMOVE_LINE%
+
+		// Abort if there's no appropriate element.
+		if ( !element ) {
+			that.debug.logEnd( 'ABORT. No element, element is editable or element contains editable.' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		// Dimensions will be necessary.
+		updateSize( that, element );
+
+		// If triggerOffset is larger than a half of element's height,
+		// use an offset of 1/2 of element's height. If the offset wasn't reduced,
+		// top area would cover most (all) cases.
+		var fixedOffset = Math.min( triggerOffset,
+				0 | ( element.size.outerHeight / 2 ) ),
+
+		// This variable will hold the trigger to be returned.
+			triggerSetup = [],
+			triggerLook,
+
+		// This flag determines whether dealing with a bottom trigger.
+			bottomTrigger;
+
+		//	\-> Top trigger.
+		if ( inBetween( mouse.y, element.size.top - 1, element.size.top + fixedOffset ) )
+			bottomTrigger = false;
+		//	\-> Bottom trigger.
+		else if ( inBetween( mouse.y, element.size.bottom - fixedOffset, element.size.bottom + 1 ) )
+			bottomTrigger = true;
+		//	\-> Abort. Not in a valid trigger space.
+		else {
+			that.debug.logEnd( 'ABORT. Not around of any edge.' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		// Reject wrong elements.
+		// 	\-> Reject an element which is a flow breaker.
+		// 	\-> Reject an element which has a child above/below the mouse pointer.
+		//	\-> Reject an element which belongs to list items.
+		if ( isFlowBreaker( element ) ||
+			isChildBetweenPointerAndEdge( that, element, bottomTrigger ) ||
+			element.getParent().is( DTD_LISTITEM ) ) {
+				that.debug.logEnd( 'ABORT. element is wrong', element ); // %REMOVE_LINE%
+				return null;
+		}
+
+		// Get sibling according to bottomTrigger.
+		var elementSibling = getNonEmptyNeighbour( that, element, !bottomTrigger );
+
+		// No sibling element.
+		// This is a first or last child case.
+		if ( !elementSibling ) {
+			// No need to reject the element as it has already been done before.
+			// Prepare a trigger.
+
+			// Determine trigger look.
+			if ( element.equals( that.editable[ bottomTrigger ? 'getLast' : 'getFirst' ]( that.isRelevant ) ) ) {
+				updateEditableSize( that );
+
+				if ( bottomTrigger && inBetween( mouse.y,
+					element.size.bottom - fixedOffset, view.pane.height ) &&
+					inBetween( element.size.bottom, view.pane.height - fixedOffset, view.pane.height ) ) {
+						triggerLook = LOOK_BOTTOM;
+				}
+				else if ( inBetween( mouse.y, 0, element.size.top + fixedOffset ) )
+					triggerLook = LOOK_TOP;
+
+			}
+			else
+				triggerLook = LOOK_NORMAL;
+
+			triggerSetup = [ null, element ][ bottomTrigger ? 'reverse' : 'concat' ]().concat( [
+					bottomTrigger ? EDGE_BOTTOM : EDGE_TOP,
+					TYPE_EDGE,
+					triggerLook,
+					element.equals( that.editable[ bottomTrigger ? 'getLast' : 'getFirst' ]( that.isRelevant ) ) ?
+						( bottomTrigger ? LOOK_BOTTOM : LOOK_TOP ) : LOOK_NORMAL
+				] );
+
+			that.debug.log( 'Configured edge trigger of ' + ( bottomTrigger ? 'EDGE_BOTTOM' : 'EDGE_TOP' ) ); // %REMOVE_LINE%
+		}
+
+		// Abort. Sibling is a text element.
+		else if ( isTextNode( elementSibling ) ) {
+			that.debug.logEnd( 'ABORT. Sibling is non-empty text element' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		// Check if the sibling is a HTML element.
+		// If so, create an TYPE_EDGE, EDGE_MIDDLE trigger.
+		else if ( isHtml( elementSibling ) ) {
+			// Reject wrong elementSiblings.
+			// 	\-> Reject an elementSibling which is a flow breaker.
+			//	\-> Reject an elementSibling which isn't a trigger.
+			//	\-> Reject an elementSibling which belongs to list items.
+			if ( isFlowBreaker( elementSibling ) ||
+				!isTrigger( that, elementSibling ) ||
+				elementSibling.getParent().is( DTD_LISTITEM ) ) {
+					that.debug.logEnd( 'ABORT. elementSibling is wrong', elementSibling ); // %REMOVE_LINE%
+					return null;
+			}
+
+			// Prepare a trigger.
+			triggerSetup = [ elementSibling, element ][ bottomTrigger ? 'reverse' : 'concat' ]().concat( [
+					EDGE_MIDDLE,
+					TYPE_EDGE
+				] );
+
+			that.debug.log( 'Configured edge trigger of EDGE_MIDDLE' ); // %REMOVE_LINE%
+		}
+
+		if ( 0 in triggerSetup ) {
+			that.debug.logEnd( 'SUCCESS. Returning a trigger.' ); // %REMOVE_LINE%
+			return new boxTrigger( triggerSetup );
+		}
+
+		that.debug.logEnd( 'ABORT. No trigger generated.' ); // %REMOVE_LINE%
+		return null;
+	}
+
+	// Checks iteratively up and down in search for elements using elementFromMouse method.
+	// Useful if between two triggers.
+	//
+	//	+----------------------- Parent element -+
+	//	| +----------------------- Element #1 -+ |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| +------------------------------------+ |
+	//	|                                        |  /--
+	//	|                  .                     |  |
+	//	|                  .      +-- Floated -+ |  |
+	//	|                  |      |            | |  |	* Mouse activation area *
+	//	|                  |      |   IGNORE   | |  |
+	//	|                  X      |            | |  |	Method searches vertically for sibling elements.
+	//	|                  |      +------------+ |  |	Start point is X (mouse-y coordinate).
+	//	|                  |                     |  |	Floated elements, comments and empty text nodes are omitted.
+	//	|                  .                     |  |
+	//	|                  .                     |  |
+	//	|                                        |  \--
+	//	| +----------------------- Element #2 -+ |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| |                                    | |
+	//	| +------------------------------------+ |
+	//	+----------------------------------------+
+	//
+	var triggerExpand = ( function() {
+		// The heart of the procedure. This method creates triggers that are
+		// filtered by expandFilter method.
+		function expandEngine( that ) {
+			that.debug.groupStart( 'expandEngine' ); // %REMOVE_LINE%
+
+			var startElement = that.element,
+				upper, lower, trigger;
+
+			if ( !isHtml( startElement ) || startElement.contains( that.editable ) ) {
+				that.debug.logEnd( 'ABORT. No start element, or start element contains editable.' ); // %REMOVE_LINE%
+				return null;
+			}
+
+			// Stop searching if element is in non-editable branch of DOM.
+			if ( startElement.isReadOnly() )
+				return null;
+
+			trigger = verticalSearch( that,
+				function( current, startElement ) {
+					return !startElement.equals( current );	// stop when start element and the current one differ
+				}, function( that, mouse ) {
+					return elementFromMouse( that, true, mouse );
+				}, startElement ),
+
+			upper = trigger.upper,
+			lower = trigger.lower;
+
+			that.debug.logElements( [ upper, lower ], [ 'Upper', 'Lower' ], 'Pair found' ); // %REMOVE_LINE%
+
+			// Success: two siblings have been found
+			if ( areSiblings( that, upper, lower ) ) {
+				that.debug.logEnd( 'SUCCESS. Expand trigger created.' ); // %REMOVE_LINE%
+				return trigger.set( EDGE_MIDDLE, TYPE_EXPAND );
+			}
+
+			that.debug.logElements( [ startElement, upper, lower ], // %REMOVE_LINE%
+				[ 'Start', 'Upper', 'Lower' ], 'Post-processing' ); // %REMOVE_LINE%
+
+			// Danger. Dragons ahead.
+			// No siblings have been found during previous phase, post-processing may be necessary.
+			// We can traverse DOM until a valid pair of elements around the pointer is found.
+
+			// Prepare for post-processing:
+			// 	1. Determine if upper and lower are children of startElement.
+			// 		1.1. If so, find their ascendants that are closest to startElement (one level deeper than startElement).
+			// 		1.2. Otherwise use first/last-child of the startElement as upper/lower. Why?:
+			// 			a) 	upper/lower belongs to another branch of the DOM tree.
+			// 			b) 	verticalSearch encountered an edge of the viewport and failed.
+			// 		1.3. Make sure upper and lower still exist. Why?:
+			// 			a) 	Upper and lower may be not belong to the branch of the startElement (may not exist at all) and
+			// 				startElement has no children.
+			// 	2. Perform the post-processing.
+			// 		2.1. Gather dimensions of an upper element.
+			// 		2.2. Abort if lower edge of upper is already under the mouse pointer. Why?:
+			// 			a) 	We expect upper to be above and lower below the mouse pointer.
+			// 	3. Perform iterative search while upper != lower.
+			// 		3.1. Find the upper-next element. If there's no such element, break current search. Why?:
+			// 			a)	There's no point in further search if there are only text nodes ahead.
+			// 		3.2. Calculate the distance between the middle point of ( upper, upperNext ) and mouse-y.
+			// 		3.3. If the distance is shorter than the previous best, save it (save upper, upperNext as well).
+			// 		3.4. If the optimal pair is found, assign it back to the trigger.
+
+			// 1.1., 1.2.
+			if ( upper && startElement.contains( upper ) ) {
+				while ( !upper.getParent().equals( startElement ) )
+					upper = upper.getParent();
+			} else {
+				upper = startElement.getFirst( function( node ) {
+					return expandSelector( that, node );
+				} );
+			}
+
+			if ( lower && startElement.contains( lower ) ) {
+				while ( !lower.getParent().equals( startElement ) )
+					lower = lower.getParent();
+			} else {
+				lower = startElement.getLast( function( node ) {
+					return expandSelector( that, node );
+				} );
+			}
+
+			// 1.3.
+			if ( !upper || !lower ) {
+				that.debug.logEnd( 'ABORT. There is no upper or no lower element.' ); // %REMOVE_LINE%
+				return null;
+			}
+
+			// 2.1.
+			updateSize( that, upper );
+			updateSize( that, lower );
+
+			if ( !checkMouseBetweenElements( that, upper, lower ) ) {
+				that.debug.logEnd( 'ABORT. Mouse is already above upper or below lower.' ); // %REMOVE_LINE%
+				return null;
+			}
+
+			var minDistance = Number.MAX_VALUE,
+				currentDistance, upperNext, minElement, minElementNext;
+
+			while ( lower && !lower.equals( upper ) ) {
+				// 3.1.
+				if ( !( upperNext = upper.getNext( that.isRelevant ) ) )
+					break;
+
+				// 3.2.
+				currentDistance = Math.abs( getMidpoint( that, upper, upperNext ) - that.mouse.y );
+
+				// 3.3.
+				if ( currentDistance < minDistance ) {
+					minDistance = currentDistance;
+					minElement = upper;
+					minElementNext = upperNext;
+				}
+
+				upper = upperNext;
+				updateSize( that, upper );
+			}
+
+			that.debug.logElements( [ minElement, minElementNext ], // %REMOVE_LINE%
+				[ 'Min', 'MinNext' ], 'Post-processing results' ); // %REMOVE_LINE%
+
+			// 3.4.
+			if ( !minElement || !minElementNext ) {
+				that.debug.logEnd( 'ABORT. No Min or MinNext' ); // %REMOVE_LINE%
+				return null;
+			}
+
+			if ( !checkMouseBetweenElements( that, minElement, minElementNext ) ) {
+				that.debug.logEnd( 'ABORT. Mouse is already above minElement or below minElementNext.' ); // %REMOVE_LINE%
+				return null;
+			}
+
+			// An element of minimal distance has been found. Assign it to the trigger.
+			trigger.upper = minElement;
+			trigger.lower = minElementNext;
+
+			// Success: post-processing revealed a pair of elements.
+			that.debug.logEnd( 'SUCCESSFUL post-processing. Trigger created.' ); // %REMOVE_LINE%
+			return trigger.set( EDGE_MIDDLE, TYPE_EXPAND );
+		}
+
+		// This is default element selector used by the engine.
+		function expandSelector( that, node ) {
+			return !( isTextNode( node )
+				|| isComment( node )
+				|| isFlowBreaker( node )
+				|| isLine( that, node )
+				|| ( node.type == CKEDITOR.NODE_ELEMENT && node.$ && node.is( 'br' ) ) );
+		}
+
+		// This method checks whether mouse-y is between the top edge of upper
+		// and bottom edge of lower.
+		//
+		// NOTE: This method assumes that updateSize has already been called
+		// for the elements and is up-to-date.
+		//
+		//	+---------------------------- Upper -+  /--
+		//	|                                    |  |
+		//	+------------------------------------+  |
+		//                                          |
+		//                     ...                  |
+		//                                          |
+		//						X                   |	* Return true for mouse-y in this range *
+		//                                          |
+		//                     ...                  |
+		//                                          |
+		//	+---------------------------- Lower -+  |
+		//	|                                    |  |
+		//	+------------------------------------+  \--
+		//
+		function checkMouseBetweenElements( that, upper, lower ) {
+			return inBetween( that.mouse.y, upper.size.top, lower.size.bottom );
+		}
+
+		// A method for trigger filtering. Accepts or rejects trigger pairs
+		// by their location in DOM etc.
+		function expandFilter( that, trigger ) {
+			that.debug.groupStart( 'expandFilter' ); // %REMOVE_LINE%
+
+			var upper = trigger.upper,
+				lower = trigger.lower;
+
+			if ( !upper || !lower 											// NOT: EDGE_MIDDLE trigger ALWAYS has two elements.
+				|| isFlowBreaker( lower ) || isFlowBreaker( upper )			// NOT: one of the elements is floated or positioned
+				|| lower.equals( upper ) || upper.equals( lower ) 			// NOT: two trigger elements, one equals another.
+				|| lower.contains( upper ) || upper.contains( lower ) ) { 	// NOT: two trigger elements, one contains another.
+				that.debug.logEnd( 'REJECTED. No upper or no lower or they contain each other.' ); // %REMOVE_LINE%
+
+				return false;
+			}
+
+			// YES: two trigger elements, pure siblings.
+			else if ( isTrigger( that, upper ) && isTrigger( that, lower ) && areSiblings( that, upper, lower ) ) {
+				that.debug.logElementsEnd( [ upper, lower ], // %REMOVE_LINE%
+					[ 'upper', 'lower' ], 'APPROVED EDGE_MIDDLE' ); // %REMOVE_LINE%
+
+				return true;
+			}
+
+			that.debug.logElementsEnd( [ upper, lower ], // %REMOVE_LINE%
+				[ 'upper', 'lower' ], 'Rejected unknown pair' ); // %REMOVE_LINE%
+
+			return false;
+		}
+
+		// Simple wrapper for expandEngine and expandFilter.
+		return function( that ) {
+			that.debug.groupStart( 'triggerExpand' ); // %REMOVE_LINE%
+
+			var trigger = expandEngine( that );
+
+			that.debug.groupEnd(); // %REMOVE_LINE%
+			return trigger && expandFilter( that, trigger ) ? trigger : null;
+		};
+	} )();
+
+	// Collects dimensions of an element.
+	var sizePrefixes = [ 'top', 'left', 'right', 'bottom' ];
+
+	function getSize( that, element, ignoreScroll, force ) {
+		var getStyle = ( function() {
+			// Better "cache and reuse" than "call again and again".
+			var computed = env.ie ? element.$.currentStyle : that.win.$.getComputedStyle( element.$, '' );
+
+				return env.ie ?
+					function( propertyName ) {
+						return computed[ CKEDITOR.tools.cssStyleToDomStyle( propertyName ) ];
+					} : function( propertyName ) {
+						return computed.getPropertyValue( propertyName );
+					};
+			} )(),
+			docPosition = element.getDocumentPosition(),
+			border = {},
+			margin = {},
+			padding = {},
+			box = {};
+
+		for ( var i = sizePrefixes.length; i--; ) {
+			border[ sizePrefixes[ i ] ] = parseInt( getStyle( 'border-' + sizePrefixes[ i ] + '-width' ), 10 ) || 0;
+			padding[ sizePrefixes[ i ] ] = parseInt( getStyle( 'padding-' + sizePrefixes[ i ] ), 10 ) || 0;
+			margin[ sizePrefixes[ i ] ] = parseInt( getStyle( 'margin-' + sizePrefixes[ i ] ), 10 ) || 0;
+		}
+
+		// updateWindowSize if forced to do so OR NOT ignoring scroll.
+		if ( !ignoreScroll || force )
+			updateWindowSize( that, force );
+
+		box.top = docPosition.y - ( ignoreScroll ? 0 : that.view.scroll.y ), box.left = docPosition.x - ( ignoreScroll ? 0 : that.view.scroll.x ),
+
+		// w/ borders and paddings.
+		box.outerWidth = element.$.offsetWidth, box.outerHeight = element.$.offsetHeight,
+
+		// w/o borders and paddings.
+		box.height = box.outerHeight - ( padding.top + padding.bottom + border.top + border.bottom ), box.width = box.outerWidth - ( padding.left + padding.right + border.left + border.right ),
+
+		box.bottom = box.top + box.outerHeight, box.right = box.left + box.outerWidth;
+
+		if ( that.inInlineMode ) {
+			box.scroll = {
+				top: element.$.scrollTop,
+				left: element.$.scrollLeft
+			};
+		}
+
+		return extend( {
+			border: border,
+			padding: padding,
+			margin: margin,
+			ignoreScroll: ignoreScroll
+		}, box, true );
+	}
+
+	function updateSize( that, element, ignoreScroll ) {
+		if ( !isHtml( element ) ) // i.e. an element is hidden
+			return ( element.size = null ); //	-> reset size to make it useless for other methods
+
+		if ( !element.size )
+			element.size = {};
+
+		// Abort if there was a similar query performed recently.
+		// This kind of caching provides great performance improvement.
+		else if ( element.size.ignoreScroll == ignoreScroll && element.size.date > new Date() - CACHE_TIME ) {
+			that.debug.log( 'element.size: get from cache' ); // %REMOVE_LINE%
+			return null;
+		}
+
+		that.debug.log( 'element.size: capture' ); // %REMOVE_LINE%
+
+		return extend( element.size, getSize( that, element, ignoreScroll ), {
+			date: +new Date()
+		}, true );
+	}
+
+	// Updates that.view.editable object.
+	// This one must be called separately outside of updateWindowSize
+	// to prevent cyclic dependency getSize<->updateWindowSize.
+	// It calls getSize with force flag to avoid getWindowSize cache (look: getSize).
+	function updateEditableSize( that, ignoreScroll ) {
+		that.view.editable = getSize( that, that.editable, ignoreScroll, true );
+	}
+
+	function updateWindowSize( that, force ) {
+		if ( !that.view )
+			that.view = {};
+
+		var view = that.view;
+
+		if ( !force && view && view.date > new Date() - CACHE_TIME ) {
+			that.debug.log( 'win.size: get from cache' ); // %REMOVE_LINE%
+			return;
+		}
+
+		that.debug.log( 'win.size: capturing' ); // %REMOVE_LINE%
+
+		var win = that.win,
+			scroll = win.getScrollPosition(),
+			paneSize = win.getViewPaneSize();
+
+		extend( that.view, {
+			scroll: {
+				x: scroll.x,
+				y: scroll.y,
+				width: that.doc.$.documentElement.scrollWidth - paneSize.width,
+				height: that.doc.$.documentElement.scrollHeight - paneSize.height
+			},
+			pane: {
+				width: paneSize.width,
+				height: paneSize.height,
+				bottom: paneSize.height + scroll.y
+			},
+			date: +new Date()
+		}, true );
+	}
+
+	// This method searches document vertically using given
+	// select criterion until stop criterion is fulfilled.
+	function verticalSearch( that, stopCondition, selectCriterion, startElement ) {
+		var upper = startElement,
+			lower = startElement,
+			mouseStep = 0,
+			upperFound = false,
+			lowerFound = false,
+			viewPaneHeight = that.view.pane.height,
+			mouse = that.mouse;
+
+		while ( mouse.y + mouseStep < viewPaneHeight && mouse.y - mouseStep > 0 ) {
+			if ( !upperFound )
+				upperFound = stopCondition( upper, startElement );
+
+			if ( !lowerFound )
+				lowerFound = stopCondition( lower, startElement );
+
+			// Still not found...
+			if ( !upperFound && mouse.y - mouseStep > 0 )
+				upper = selectCriterion( that, { x: mouse.x, y: mouse.y - mouseStep } );
+
+			if ( !lowerFound && mouse.y + mouseStep < viewPaneHeight )
+				lower = selectCriterion( that, { x: mouse.x, y: mouse.y + mouseStep } );
+
+			if ( upperFound && lowerFound )
+				break;
+
+			// Instead of ++ to reduce the number of invocations by half.
+			// It's trades off accuracy in some edge cases for improved performance.
+			mouseStep += 2;
+		}
+
+		return new boxTrigger( [ upper, lower, null, null ] );
+	}
+
+} )();
+
+/**
+ * Sets the default vertical distance between element edge and mouse pointer that
+ * causes the box to appear. The distance is expressed in pixels (px).
+ *
+ *		// Changes the offset to 15px.
+ *		CKEDITOR.config.magicline_triggerOffset = 15;
+ *
+ * @cfg {Number} [magicline_triggerOffset=30]
+ * @member CKEDITOR.config
+ * @see CKEDITOR.config#magicline_holdDistance
+ */
+
+/**
+ * Defines the distance between mouse pointer and the box, within
+ * which the box stays revealed and no other focus space is offered to be accessed.
+ * The value is relative to {@link #magicline_triggerOffset}.
+ *
+ *		// Increases the distance to 80% of CKEDITOR.config.magicline_triggerOffset.
+ *		CKEDITOR.config.magicline_holdDistance = .8;
+ *
+ * @cfg {Number} [magicline_holdDistance=0.5]
+ * @member CKEDITOR.config
+ * @see CKEDITOR.config#magicline_triggerOffset
+ */
+
+/**
+ * Defines default keystroke that access the closest unreachable focus space **before**
+ * the caret (start of the selection). If there's no any focus space, selection remains.
+ *
+ *		// Changes keystroke to CTRL + ,
+ *		CKEDITOR.config.magicline_keystrokePrevious = CKEDITOR.CTRL + 188;
+ *
+ * @cfg {Number} [magicline_keystrokePrevious=CKEDITOR.CTRL + CKEDITOR.SHIFT + 51 (CTRL + SHIFT + 3)]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.magicline_keystrokePrevious = CKEDITOR.CTRL + CKEDITOR.SHIFT + 51; // CTRL + SHIFT + 3
+
+/**
+ * Defines default keystroke that access the closest unreachable focus space **after**
+ * the caret (start of the selection). If there's no any focus space, selection remains.
+ *
+ *		// Changes keystroke to CTRL + .
+ *		CKEDITOR.config.magicline_keystrokeNext = CKEDITOR.CTRL + 190;
+ *
+ * @cfg {Number} [magicline_keystrokeNext=CKEDITOR.CTRL + CKEDITOR.SHIFT + 52 (CTRL + SHIFT + 4)]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.magicline_keystrokeNext = CKEDITOR.CTRL + CKEDITOR.SHIFT + 52; // CTRL + SHIFT + 4
+
+/**
+ * Defines a list of attributes that, if assigned to some elements, prevent magicline from being
+ * used within these elements.
+ *
+ *		// Adds "data-tabu" attribute to magicline tabu list.
+ *		CKEDITOR.config.magicline_tabuList = [ 'data-tabu' ];
+ *
+ * @cfg {Number} [magicline_tabuList=[ 'data-widget-wrapper' ]]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Defines box color. The color may be adjusted to enhance readability.
+ *
+ *		// Changes color to blue.
+ *		CKEDITOR.config.magicline_color = '#0000FF';
+ *
+ * @cfg {String} [magicline_color='#FF0000']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Activates plugin mode that considers all focus spaces between
+ * {@link CKEDITOR.dtd#$block} elements as accessible by the box.
+ *
+ *		// Enables "put everywhere" mode.
+ *		CKEDITOR.config.magicline_putEverywhere = true;
+ *
+ * @cfg {Boolean} [magicline_putEverywhere=false]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/maximize/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/maximize/plugin.js
new file mode 100644
index 00000000..9e0d174a
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/maximize/plugin.js
@@ -0,0 +1,305 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	function protectFormStyles( formElement ) {
+		if ( !formElement || formElement.type != CKEDITOR.NODE_ELEMENT || formElement.getName() != 'form' )
+			return [];
+
+		var hijackRecord = [],
+			hijackNames = [ 'style', 'className' ];
+		for ( var i = 0; i < hijackNames.length; i++ ) {
+			var name = hijackNames[ i ];
+			var $node = formElement.$.elements.namedItem( name );
+			if ( $node ) {
+				var hijackNode = new CKEDITOR.dom.element( $node );
+				hijackRecord.push( [ hijackNode, hijackNode.nextSibling ] );
+				hijackNode.remove();
+			}
+		}
+
+		return hijackRecord;
+	}
+
+	function restoreFormStyles( formElement, hijackRecord ) {
+		if ( !formElement || formElement.type != CKEDITOR.NODE_ELEMENT || formElement.getName() != 'form' )
+			return;
+
+		if ( hijackRecord.length > 0 ) {
+			for ( var i = hijackRecord.length - 1; i >= 0; i-- ) {
+				var node = hijackRecord[ i ][ 0 ];
+				var sibling = hijackRecord[ i ][ 1 ];
+				if ( sibling )
+					node.insertBefore( sibling );
+				else
+					node.appendTo( formElement );
+			}
+		}
+	}
+
+	function saveStyles( element, isInsideEditor ) {
+		var data = protectFormStyles( element );
+		var retval = {};
+
+		var $element = element.$;
+
+		if ( !isInsideEditor ) {
+			retval[ 'class' ] = $element.className || '';
+			$element.className = '';
+		}
+
+		retval.inline = $element.style.cssText || '';
+		if ( !isInsideEditor ) // Reset any external styles that might interfere. (#2474)
+		$element.style.cssText = 'position: static; overflow: visible';
+
+		restoreFormStyles( data );
+		return retval;
+	}
+
+	function restoreStyles( element, savedStyles ) {
+		var data = protectFormStyles( element );
+		var $element = element.$;
+		if ( 'class' in savedStyles )
+			$element.className = savedStyles[ 'class' ];
+		if ( 'inline' in savedStyles )
+			$element.style.cssText = savedStyles.inline;
+		restoreFormStyles( data );
+	}
+
+	function refreshCursor( editor ) {
+		if ( editor.editable().isInline() )
+			return;
+
+		// Refresh all editor instances on the page (#5724).
+		var all = CKEDITOR.instances;
+		for ( var i in all ) {
+			var one = all[ i ];
+			if ( one.mode == 'wysiwyg' && !one.readOnly ) {
+				var body = one.document.getBody();
+				// Refresh 'contentEditable' otherwise
+				// DOM lifting breaks design mode. (#5560)
+				body.setAttribute( 'contentEditable', false );
+				body.setAttribute( 'contentEditable', true );
+			}
+		}
+
+		if ( editor.editable().hasFocus ) {
+			editor.toolbox.focus();
+			editor.focus();
+		}
+	}
+
+	CKEDITOR.plugins.add( 'maximize', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'maximize', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			// Maximize plugin isn't available in inline mode yet.
+			if ( editor.elementMode == CKEDITOR.ELEMENT_MODE_INLINE )
+				return;
+
+			var lang = editor.lang;
+			var mainDocument = CKEDITOR.document,
+				mainWindow = mainDocument.getWindow();
+
+			// Saved selection and scroll position for the editing area.
+			var savedSelection, savedScroll;
+
+			// Saved scroll position for the outer window.
+			var outerScroll;
+
+			// Saved resize handler function.
+			function resizeHandler() {
+				var viewPaneSize = mainWindow.getViewPaneSize();
+				editor.resize( viewPaneSize.width, viewPaneSize.height, null, true );
+			}
+
+			// Retain state after mode switches.
+			var savedState = CKEDITOR.TRISTATE_OFF;
+
+			editor.addCommand( 'maximize', {
+				// Disabled on iOS (#8307).
+				modes: { wysiwyg: !CKEDITOR.env.iOS, source: !CKEDITOR.env.iOS },
+				readOnly: 1,
+				editorFocus: false,
+				exec: function() {
+					var container = editor.container.getChild( 1 );
+					var contents = editor.ui.space( 'contents' );
+
+					// Save current selection and scroll position in editing area.
+					if ( editor.mode == 'wysiwyg' ) {
+						var selection = editor.getSelection();
+						savedSelection = selection && selection.getRanges();
+						savedScroll = mainWindow.getScrollPosition();
+					} else {
+						var $textarea = editor.editable().$;
+						savedSelection = !CKEDITOR.env.ie && [ $textarea.selectionStart, $textarea.selectionEnd ];
+						savedScroll = [ $textarea.scrollLeft, $textarea.scrollTop ];
+					}
+
+					if ( this.state == CKEDITOR.TRISTATE_OFF ) // Go fullscreen if the state is off.
+					{
+						// Add event handler for resizing.
+						mainWindow.on( 'resize', resizeHandler );
+
+						// Save the scroll bar position.
+						outerScroll = mainWindow.getScrollPosition();
+
+						// Save and reset the styles for the entire node tree.
+						var currentNode = editor.container;
+						while ( ( currentNode = currentNode.getParent() ) ) {
+							currentNode.setCustomData( 'maximize_saved_styles', saveStyles( currentNode ) );
+							// Show under floatpanels (-1) and context menu (-2).
+							currentNode.setStyle( 'z-index', editor.config.baseFloatZIndex - 5 );
+						}
+						contents.setCustomData( 'maximize_saved_styles', saveStyles( contents, true ) );
+						container.setCustomData( 'maximize_saved_styles', saveStyles( container, true ) );
+
+						// Hide scroll bars.
+						var styles = {
+							overflow: CKEDITOR.env.webkit ? '' : 'hidden', // #6896
+							width: 0,
+							height: 0
+						};
+
+						mainDocument.getDocumentElement().setStyles( styles );
+						!CKEDITOR.env.gecko && mainDocument.getDocumentElement().setStyle( 'position', 'fixed' );
+						!( CKEDITOR.env.gecko && CKEDITOR.env.quirks ) && mainDocument.getBody().setStyles( styles );
+
+						// Scroll to the top left (IE needs some time for it - #4923).
+						CKEDITOR.env.ie ? setTimeout( function() {
+							mainWindow.$.scrollTo( 0, 0 );
+						}, 0 ) : mainWindow.$.scrollTo( 0, 0 );
+
+						// Resize and move to top left.
+						// Special treatment for FF Quirks (#7284)
+						container.setStyle( 'position', CKEDITOR.env.gecko && CKEDITOR.env.quirks ? 'fixed' : 'absolute' );
+						container.$.offsetLeft; // SAFARI BUG: See #2066.
+						container.setStyles( {
+							// Show under floatpanels (-1) and context menu (-2).
+							'z-index': editor.config.baseFloatZIndex - 5,
+							left: '0px',
+							top: '0px'
+						} );
+
+						// Add cke_maximized class before resize handle since that will change things sizes (#5580)
+						container.addClass( 'cke_maximized' );
+
+						resizeHandler();
+
+						// Still not top left? Fix it. (Bug #174)
+						var offset = container.getDocumentPosition();
+						container.setStyles( {
+							left: ( -1 * offset.x ) + 'px',
+							top: ( -1 * offset.y ) + 'px'
+						} );
+
+						// Fixing positioning editor chrome in Firefox break design mode. (#5149)
+						CKEDITOR.env.gecko && refreshCursor( editor );
+
+					} else if ( this.state == CKEDITOR.TRISTATE_ON ) // Restore from fullscreen if the state is on.
+					{
+						// Remove event handler for resizing.
+						mainWindow.removeListener( 'resize', resizeHandler );
+
+						// Restore CSS styles for the entire node tree.
+						var editorElements = [ contents, container ];
+						for ( var i = 0; i < editorElements.length; i++ ) {
+							restoreStyles( editorElements[ i ], editorElements[ i ].getCustomData( 'maximize_saved_styles' ) );
+							editorElements[ i ].removeCustomData( 'maximize_saved_styles' );
+						}
+
+						currentNode = editor.container;
+						while ( ( currentNode = currentNode.getParent() ) ) {
+							restoreStyles( currentNode, currentNode.getCustomData( 'maximize_saved_styles' ) );
+							currentNode.removeCustomData( 'maximize_saved_styles' );
+						}
+
+						// Restore the window scroll position.
+						CKEDITOR.env.ie ? setTimeout( function() {
+							mainWindow.$.scrollTo( outerScroll.x, outerScroll.y );
+						}, 0 ) : mainWindow.$.scrollTo( outerScroll.x, outerScroll.y );
+
+						// Remove cke_maximized class.
+						container.removeClass( 'cke_maximized' );
+
+						// Webkit requires a re-layout on editor chrome. (#6695)
+						if ( CKEDITOR.env.webkit ) {
+							container.setStyle( 'display', 'inline' );
+							setTimeout( function() {
+								container.setStyle( 'display', 'block' );
+							}, 0 );
+						}
+
+						// Emit a resize event, because this time the size is modified in
+						// restoreStyles.
+						editor.fire( 'resize' );
+					}
+
+					this.toggleState();
+
+					// Toggle button label.
+					var button = this.uiItems[ 0 ];
+					// Only try to change the button if it exists (#6166)
+					if ( button ) {
+						var label = ( this.state == CKEDITOR.TRISTATE_OFF ) ? lang.maximize.maximize : lang.maximize.minimize;
+						var buttonNode = CKEDITOR.document.getById( button._.id );
+						buttonNode.getChild( 1 ).setHtml( label );
+						buttonNode.setAttribute( 'title', label );
+						buttonNode.setAttribute( 'href', 'javascript:void("' + label + '");' );
+					}
+
+					// Restore selection and scroll position in editing area.
+					if ( editor.mode == 'wysiwyg' ) {
+						if ( savedSelection ) {
+							// Fixing positioning editor chrome in Firefox break design mode. (#5149)
+							CKEDITOR.env.gecko && refreshCursor( editor );
+
+							editor.getSelection().selectRanges( savedSelection );
+							var element = editor.getSelection().getStartElement();
+							element && element.scrollIntoView( true );
+						} else
+							mainWindow.$.scrollTo( savedScroll.x, savedScroll.y );
+					} else {
+						if ( savedSelection ) {
+							$textarea.selectionStart = savedSelection[ 0 ];
+							$textarea.selectionEnd = savedSelection[ 1 ];
+						}
+						$textarea.scrollLeft = savedScroll[ 0 ];
+						$textarea.scrollTop = savedScroll[ 1 ];
+					}
+
+					savedSelection = savedScroll = null;
+					savedState = this.state;
+
+					editor.fire( 'maximize', this.state );
+				},
+				canUndo: false
+			} );
+
+			editor.ui.addButton && editor.ui.addButton( 'Maximize', {
+				label: lang.maximize.maximize,
+				command: 'maximize',
+				toolbar: 'tools,10'
+			} );
+
+			// Restore the command state after mode change, unless it has been changed to disabled (#6467)
+			editor.on( 'mode', function() {
+				var command = editor.getCommand( 'maximize' );
+				command.setState( command.state == CKEDITOR.TRISTATE_DISABLED ? CKEDITOR.TRISTATE_DISABLED : savedState );
+			}, null, null, 100 );
+		}
+	} );
+} )();
+
+/**
+ * Event fired when the maximize command is called.
+ * It also indicates whether an editor is maximized or not.
+ *
+ * @event maximize
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {Number} data Current state of the command. See {@link CKEDITOR#TRISTATE_ON} and {@link CKEDITOR#TRISTATE_OFF}.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/menu/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/menu/plugin.js
new file mode 100644
index 00000000..dffa7839
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/menu/plugin.js
@@ -0,0 +1,545 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'menu', {
+	requires: 'floatpanel',
+
+	beforeInit: function( editor ) {
+		var groups = editor.config.menu_groups.split( ',' ),
+			groupsOrder = editor._.menuGroups = {},
+			menuItems = editor._.menuItems = {};
+
+		for ( var i = 0; i < groups.length; i++ )
+			groupsOrder[ groups[ i ] ] = i + 1;
+
+		/**
+		 * Registers an item group to the editor context menu in order to make it
+		 * possible to associate it with menu items later.
+		 *
+		 * @param {String} name Specify a group name.
+		 * @param {Number} [order=100] Define the display sequence of this group
+		 * inside the menu. A smaller value gets displayed first.
+		 * @member CKEDITOR.editor
+		 */
+		editor.addMenuGroup = function( name, order ) {
+			groupsOrder[ name ] = order || 100;
+		};
+
+		/**
+		 * Adds an item from the specified definition to the editor context menu.
+		 *
+		 * @method
+		 * @param {String} name The menu item name.
+		 * @param {Object} definition The menu item definition.
+		 * @member CKEDITOR.editor
+		 */
+		editor.addMenuItem = function( name, definition ) {
+			if ( groupsOrder[ definition.group ] )
+				menuItems[ name ] = new CKEDITOR.menuItem( this, name, definition );
+		};
+
+		/**
+		 * Adds one or more items from the specified definition array to the editor context menu.
+		 *
+		 * @method
+		 * @param {Array} definitions List of definitions for each menu item as if {@link #addMenuItem} is called.
+		 * @member CKEDITOR.editor
+		 */
+		editor.addMenuItems = function( definitions ) {
+			for ( var itemName in definitions ) {
+				this.addMenuItem( itemName, definitions[ itemName ] );
+			}
+		};
+
+		/**
+		 * Retrieves a particular menu item definition from the editor context menu.
+		 *
+		 * @method
+		 * @param {String} name The name of the desired menu item.
+		 * @returns {Object}
+		 * @member CKEDITOR.editor
+		 */
+		editor.getMenuItem = function( name ) {
+			return menuItems[ name ];
+		};
+
+		/**
+		 * Removes a particular menu item added before from the editor context menu.
+		 *
+		 * @since 3.6.1
+		 * @method
+		 * @param {String} name The name of the desired menu item.
+		 * @member CKEDITOR.editor
+		 */
+		editor.removeMenuItem = function( name ) {
+			delete menuItems[ name ];
+		};
+	}
+} );
+
+( function() {
+	var menuItemSource = '<span class="cke_menuitem">' +
+		'<a id="{id}"' +
+		' class="cke_menubutton cke_menubutton__{name} cke_menubutton_{state} {cls}" href="{href}"' +
+		' title="{title}"' +
+		' tabindex="-1"' +
+		'_cke_focus=1' +
+		' hidefocus="true"' +
+		' role="{role}"' +
+		' aria-haspopup="{hasPopup}"' +
+		' aria-disabled="{disabled}"' +
+		' {ariaChecked}';
+
+	// Some browsers don't cancel key events in the keydown but in the
+	// keypress.
+	// TODO: Check if really needed for Gecko+Mac.
+	if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+		menuItemSource += ' onkeypress="return false;"';
+
+	// With Firefox, we need to force the button to redraw, otherwise it
+	// will remain in the focus state.
+	if ( CKEDITOR.env.gecko )
+		menuItemSource += ' onblur="this.style.cssText = this.style.cssText;"';
+
+	// #188
+	menuItemSource += ' onmouseover="CKEDITOR.tools.callFunction({hoverFn},{index});"' +
+			' onmouseout="CKEDITOR.tools.callFunction({moveOutFn},{index});" ' +
+			( CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick' ) +
+				'="CKEDITOR.tools.callFunction({clickFn},{index}); return false;"' +
+			'>';
+
+	menuItemSource +=
+				'<span class="cke_menubutton_inner">' +
+					'<span class="cke_menubutton_icon">' +
+						'<span class="cke_button_icon cke_button__{iconName}_icon" style="{iconStyle}"></span>' +
+					'</span>' +
+					'<span class="cke_menubutton_label">' +
+						'{label}' +
+					'</span>' +
+					'{arrowHtml}' +
+				'</span>' +
+			'</a></span>';
+
+	var menuArrowSource = '<span class="cke_menuarrow">' +
+				'<span>{label}</span>' +
+			'</span>';
+
+	var menuItemTpl = CKEDITOR.addTemplate( 'menuItem', menuItemSource ),
+		menuArrowTpl = CKEDITOR.addTemplate( 'menuArrow', menuArrowSource );
+
+	/**
+	 * @class
+	 * @todo
+	 */
+	CKEDITOR.menu = CKEDITOR.tools.createClass( {
+		/**
+		 * @constructor
+		 */
+		$: function( editor, definition ) {
+			definition = this._.definition = definition || {};
+			this.id = CKEDITOR.tools.getNextId();
+
+			this.editor = editor;
+			this.items = [];
+			this._.listeners = [];
+
+			this._.level = definition.level || 1;
+
+			var panelDefinition = CKEDITOR.tools.extend( {}, definition.panel, {
+				css: [ CKEDITOR.skin.getPath( 'editor' ) ],
+				level: this._.level - 1,
+				block: {}
+			} );
+
+			var attrs = panelDefinition.block.attributes = ( panelDefinition.attributes || {} );
+			// Provide default role of 'menu'.
+			!attrs.role && ( attrs.role = 'menu' );
+			this._.panelDefinition = panelDefinition;
+		},
+
+		_: {
+			onShow: function() {
+				var selection = this.editor.getSelection(),
+					start = selection && selection.getStartElement(),
+					path = this.editor.elementPath(),
+					listeners = this._.listeners;
+
+				this.removeAll();
+				// Call all listeners, filling the list of items to be displayed.
+				for ( var i = 0; i < listeners.length; i++ ) {
+					var listenerItems = listeners[ i ]( start, selection, path );
+
+					if ( listenerItems ) {
+						for ( var itemName in listenerItems ) {
+							var item = this.editor.getMenuItem( itemName );
+
+							if ( item && ( !item.command || this.editor.getCommand( item.command ).state ) ) {
+								item.state = listenerItems[ itemName ];
+								this.add( item );
+							}
+						}
+					}
+				}
+			},
+
+			onClick: function( item ) {
+				this.hide();
+
+				if ( item.onClick )
+					item.onClick();
+				else if ( item.command )
+					this.editor.execCommand( item.command );
+			},
+
+			onEscape: function( keystroke ) {
+				var parent = this.parent;
+				// 1. If it's sub-menu, close it, with focus restored on this.
+				// 2. In case of a top-menu, close it, with focus returned to page.
+				if ( parent )
+					parent._.panel.hideChild( 1 );
+				else if ( keystroke == 27 )
+					this.hide( 1 );
+
+				return false;
+			},
+
+			onHide: function() {
+				this.onHide && this.onHide();
+			},
+
+			showSubMenu: function( index ) {
+				var menu = this._.subMenu,
+					item = this.items[ index ],
+					subItemDefs = item.getItems && item.getItems();
+
+				// If this item has no subitems, we just hide the submenu, if
+				// available, and return back.
+				if ( !subItemDefs ) {
+					// Hide sub menu with focus returned.
+					this._.panel.hideChild( 1 );
+					return;
+				}
+
+				// Create the submenu, if not available, or clean the existing
+				// one.
+				if ( menu )
+					menu.removeAll();
+				else {
+					menu = this._.subMenu = new CKEDITOR.menu( this.editor, CKEDITOR.tools.extend( {}, this._.definition, { level: this._.level + 1 }, true ) );
+					menu.parent = this;
+					menu._.onClick = CKEDITOR.tools.bind( this._.onClick, this );
+				}
+
+				// Add all submenu items to the menu.
+				for ( var subItemName in subItemDefs ) {
+					var subItem = this.editor.getMenuItem( subItemName );
+					if ( subItem ) {
+						subItem.state = subItemDefs[ subItemName ];
+						menu.add( subItem );
+					}
+				}
+
+				// Get the element representing the current item.
+				var element = this._.panel.getBlock( this.id ).element.getDocument().getById( this.id + String( index ) );
+
+				// Show the submenu.
+				// This timeout is needed to give time for the sub-menu get
+				// focus when JAWS is running. (#9844)
+				setTimeout( function() {
+					menu.show( element, 2 );
+				}, 0 );
+			}
+		},
+
+		proto: {
+			/**
+			 * Adds an item.
+			 *
+			 * @param item
+			 */
+			add: function( item ) {
+				// Later we may sort the items, but Array#sort is not stable in
+				// some browsers, here we're forcing the original sequence with
+				// 'order' attribute if it hasn't been assigned. (#3868)
+				if ( !item.order )
+					item.order = this.items.length;
+
+				this.items.push( item );
+			},
+
+			/**
+			 * Removes all items.
+			 */
+			removeAll: function() {
+				this.items = [];
+			},
+
+			/**
+			 * Shows the menu in given location.
+			 *
+			 * @param {CKEDITOR.dom.element} offsetParent
+			 * @param {Number} [corner]
+			 * @param {Number} [offsetX]
+			 * @param {Number} [offsetY]
+			 */
+			show: function( offsetParent, corner, offsetX, offsetY ) {
+				// Not for sub menu.
+				if ( !this.parent ) {
+					this._.onShow();
+					// Don't menu with zero items.
+					if ( !this.items.length )
+						return;
+				}
+
+				corner = corner || ( this.editor.lang.dir == 'rtl' ? 2 : 1 );
+
+				var items = this.items,
+					editor = this.editor,
+					panel = this._.panel,
+					element = this._.element;
+
+				// Create the floating panel for this menu.
+				if ( !panel ) {
+					panel = this._.panel = new CKEDITOR.ui.floatPanel( this.editor, CKEDITOR.document.getBody(), this._.panelDefinition, this._.level );
+
+					panel.onEscape = CKEDITOR.tools.bind( function( keystroke ) {
+						if ( this._.onEscape( keystroke ) === false )
+							return false;
+					}, this );
+
+					panel.onShow = function() {
+						// Menu need CSS resets, compensate class name.
+						var holder = panel._.panel.getHolderElement();
+						holder.getParent().addClass( 'cke cke_reset_all' );
+					};
+
+					panel.onHide = CKEDITOR.tools.bind( function() {
+						this._.onHide && this._.onHide();
+					}, this );
+
+					// Create an autosize block inside the panel.
+					var block = panel.addBlock( this.id, this._.panelDefinition.block );
+					block.autoSize = true;
+
+					var keys = block.keys;
+					keys[ 40 ] = 'next'; // ARROW-DOWN
+					keys[ 9 ] = 'next'; // TAB
+					keys[ 38 ] = 'prev'; // ARROW-UP
+					keys[ CKEDITOR.SHIFT + 9 ] = 'prev'; // SHIFT + TAB
+					keys[ ( editor.lang.dir == 'rtl' ? 37 : 39 ) ] = CKEDITOR.env.ie ? 'mouseup' : 'click'; // ARROW-RIGHT/ARROW-LEFT(rtl)
+					keys[ 32 ] = CKEDITOR.env.ie ? 'mouseup' : 'click'; // SPACE
+					CKEDITOR.env.ie && ( keys[ 13 ] = 'mouseup' ); // Manage ENTER, since onclick is blocked in IE (#8041).
+
+					element = this._.element = block.element;
+
+					var elementDoc = element.getDocument();
+					elementDoc.getBody().setStyle( 'overflow', 'hidden' );
+					elementDoc.getElementsByTag( 'html' ).getItem( 0 ).setStyle( 'overflow', 'hidden' );
+
+					this._.itemOverFn = CKEDITOR.tools.addFunction( function( index ) {
+						clearTimeout( this._.showSubTimeout );
+						this._.showSubTimeout = CKEDITOR.tools.setTimeout( this._.showSubMenu, editor.config.menu_subMenuDelay || 400, this, [ index ] );
+					}, this );
+
+					this._.itemOutFn = CKEDITOR.tools.addFunction( function( index ) {
+						clearTimeout( this._.showSubTimeout );
+					}, this );
+
+					this._.itemClickFn = CKEDITOR.tools.addFunction( function( index ) {
+						var item = this.items[ index ];
+
+						if ( item.state == CKEDITOR.TRISTATE_DISABLED ) {
+							this.hide( 1 );
+							return;
+						}
+
+						if ( item.getItems )
+							this._.showSubMenu( index );
+						else
+							this._.onClick( item );
+					}, this );
+				}
+
+				// Put the items in the right order.
+				sortItems( items );
+
+				// Apply the editor mixed direction status to menu.
+				var path = editor.elementPath(),
+					mixedDirCls = ( path && path.direction() != editor.lang.dir ) ? ' cke_mixed_dir_content' : '';
+
+				// Build the HTML that composes the menu and its items.
+				var output = [ '<div class="cke_menu' + mixedDirCls + '" role="presentation">' ];
+
+				var length = items.length,
+					lastGroup = length && items[ 0 ].group;
+
+				for ( var i = 0; i < length; i++ ) {
+					var item = items[ i ];
+					if ( lastGroup != item.group ) {
+						output.push( '<div class="cke_menuseparator" role="separator"></div>' );
+						lastGroup = item.group;
+					}
+
+					item.render( this, i, output );
+				}
+
+				output.push( '</div>' );
+
+				// Inject the HTML inside the panel.
+				element.setHtml( output.join( '' ) );
+
+				CKEDITOR.ui.fire( 'ready', this );
+
+				// Show the panel.
+				if ( this.parent )
+					this.parent._.panel.showAsChild( panel, this.id, offsetParent, corner, offsetX, offsetY );
+				else
+					panel.showBlock( this.id, offsetParent, corner, offsetX, offsetY );
+
+				editor.fire( 'menuShow', [ panel ] );
+			},
+
+			/**
+			 * Adds a callback executed on opening the menu. Items
+			 * returned by that callback are added to the menu.
+			 *
+			 * @param {Function} listenerFn
+			 * @param {CKEDITOR.dom.element} listenerFn.startElement The selection start anchor element.
+			 * @param {CKEDITOR.dom.selection} listenerFn.selection The current selection.
+			 * @param {CKEDITOR.dom.elementPath} listenerFn.path The current elements path.
+			 * @param listenerFn.return Object (`commandName` => `state`) of items that should be added to the menu.
+			 */
+			addListener: function( listenerFn ) {
+				this._.listeners.push( listenerFn );
+			},
+
+			/**
+			 * Hides the menu.
+			 *
+			 * @param {Boolean} [returnFocus]
+			 */
+			hide: function( returnFocus ) {
+				this._.onHide && this._.onHide();
+				this._.panel && this._.panel.hide( returnFocus );
+			}
+		}
+	} );
+
+	function sortItems( items ) {
+		items.sort( function( itemA, itemB ) {
+			if ( itemA.group < itemB.group )
+				return -1;
+			else if ( itemA.group > itemB.group )
+				return 1;
+
+			return itemA.order < itemB.order ? -1 : itemA.order > itemB.order ? 1 : 0;
+		} );
+	}
+
+	/**
+	 * @class
+	 * @todo
+	 */
+	CKEDITOR.menuItem = CKEDITOR.tools.createClass( {
+		$: function( editor, name, definition ) {
+			CKEDITOR.tools.extend( this, definition,
+			// Defaults
+			{
+				order: 0,
+				className: 'cke_menubutton__' + name
+			} );
+
+			// Transform the group name into its order number.
+			this.group = editor._.menuGroups[ this.group ];
+
+			this.editor = editor;
+			this.name = name;
+		},
+
+		proto: {
+			render: function( menu, index, output ) {
+				var id = menu.id + String( index ),
+					state = ( typeof this.state == 'undefined' ) ? CKEDITOR.TRISTATE_OFF : this.state,
+					ariaChecked = '';
+
+				var stateName = state == CKEDITOR.TRISTATE_ON ? 'on' : state == CKEDITOR.TRISTATE_DISABLED ? 'disabled' : 'off';
+
+				if ( this.role in { menuitemcheckbox: 1, menuitemradio: 1 } )
+					ariaChecked = ' aria-checked="' + ( state == CKEDITOR.TRISTATE_ON ? 'true' : 'false' ) + '"';
+
+				var hasSubMenu = this.getItems;
+				// ltr: BLACK LEFT-POINTING POINTER
+				// rtl: BLACK RIGHT-POINTING POINTER
+				var arrowLabel = '&#' + ( this.editor.lang.dir == 'rtl' ? '9668' : '9658' ) + ';';
+
+				var iconName = this.name;
+				if ( this.icon && !( /\./ ).test( this.icon ) )
+					iconName = this.icon;
+
+				var params = {
+					id: id,
+					name: this.name,
+					iconName: iconName,
+					label: this.label,
+					cls: this.className || '',
+					state: stateName,
+					hasPopup: hasSubMenu ? 'true' : 'false',
+					disabled: state == CKEDITOR.TRISTATE_DISABLED,
+					title: this.label,
+					href: 'javascript:void(\'' + ( this.label || '' ).replace( "'" + '' ) + '\')',
+					hoverFn: menu._.itemOverFn,
+					moveOutFn: menu._.itemOutFn,
+					clickFn: menu._.itemClickFn,
+					index: index,
+					iconStyle: CKEDITOR.skin.getIconStyle( iconName, ( this.editor.lang.dir == 'rtl' ), iconName == this.icon ? null : this.icon, this.iconOffset ),
+					arrowHtml: hasSubMenu ? menuArrowTpl.output( { label : arrowLabel } ) : '',
+					role: this.role ? this.role : 'menuitem',
+					ariaChecked: ariaChecked
+				};
+
+				menuItemTpl.output( params, output );
+			}
+		}
+	} );
+
+} )();
+
+
+/**
+ * The amount of time, in milliseconds, the editor waits before displaying submenu
+ * options when moving the mouse over options that contain submenus, like the
+ * "Cell Properties" entry for tables.
+ *
+ *		// Remove the submenu delay.
+ *		config.menu_subMenuDelay = 0;
+ *
+ * @cfg {Number} [menu_subMenuDelay=400]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Fired when a menu is shown.
+ *
+ * @event menuShow
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {CKEDITOR.ui.panel[]} data
+ */
+
+/**
+ * A comma separated list of items group names to be displayed in the context
+ * menu. The order of items will reflect the order specified in this list if
+ * no priority was defined in the groups.
+ *
+ *		config.menu_groups = 'clipboard,table,anchor,link,image';
+ *
+ * @cfg {String} [menu_groups=see source]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.menu_groups = 'clipboard,' +
+	'form,' +
+	'tablecell,tablecellproperties,tablerow,tablecolumn,table,' +
+	'anchor,link,image,flash,' +
+	'checkbox,radio,textfield,hiddenfield,imagebutton,button,select,textarea,div';
diff --git a/lam/templates/lib/extra/ckeditor/plugins/panel/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/panel/plugin.js
new file mode 100644
index 00000000..fd00edf2
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/panel/plugin.js
@@ -0,0 +1,402 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'panel', {
+		beforeInit: function( editor ) {
+			editor.ui.addHandler( CKEDITOR.UI_PANEL, CKEDITOR.ui.panel.handler );
+		}
+	} );
+
+	/**
+	 * Panel UI element.
+	 *
+	 * @readonly
+	 * @property {String} [='panel']
+	 * @member CKEDITOR
+	 */
+	CKEDITOR.UI_PANEL = 'panel';
+
+	/**
+	 * @class
+	 * @constructor Creates a panel class instance.
+	 * @param {CKEDITOR.dom.document} document
+	 * @param {Object} definition
+	 */
+	CKEDITOR.ui.panel = function( document, definition ) {
+		// Copy all definition properties to this object.
+		if ( definition )
+			CKEDITOR.tools.extend( this, definition );
+
+		// Set defaults.
+		CKEDITOR.tools.extend( this, {
+			className: '',
+			css: []
+		} );
+
+		this.id = CKEDITOR.tools.getNextId();
+		this.document = document;
+		this.isFramed = this.forceIFrame || this.css.length;
+
+		this._ = {
+			blocks: {}
+		};
+	};
+
+	/**
+	 * Represents panel handler object.
+	 *
+	 * @class
+	 * @singleton
+	 * @extends CKEDITOR.ui.handlerDefinition
+	 */
+	CKEDITOR.ui.panel.handler = {
+		/**
+		 * Transforms a panel definition in a {@link CKEDITOR.ui.panel} instance.
+		 *
+		 * @param {Object} definition
+		 * @returns {CKEDITOR.ui.panel}
+		 */
+		create: function( definition ) {
+			return new CKEDITOR.ui.panel( definition );
+		}
+	};
+
+	var panelTpl = CKEDITOR.addTemplate( 'panel', '<div lang="{langCode}" id="{id}" dir={dir}' +
+		' class="cke cke_reset_all {editorId} cke_panel cke_panel {cls} cke_{dir}"' +
+		' style="z-index:{z-index}" role="presentation">' +
+		'{frame}' +
+		'</div>' );
+
+	var frameTpl = CKEDITOR.addTemplate( 'panel-frame', '<iframe id="{id}" class="cke_panel_frame" role="presentation" frameborder="0" src="{src}"></iframe>' );
+
+	var frameDocTpl = CKEDITOR.addTemplate( 'panel-frame-inner', '<!DOCTYPE html>' +
+		'<html class="cke_panel_container {env}" dir="{dir}" lang="{langCode}">' +
+			'<head>{css}</head>' +
+			'<body class="cke_{dir}"' +
+				' style="margin:0;padding:0" onload="{onload}"></body>' +
+		'<\/html>' );
+
+	/** @class CKEDITOR.ui.panel */
+	CKEDITOR.ui.panel.prototype = {
+		/**
+		 * Renders the combo.
+		 *
+		 * @param {CKEDITOR.editor} editor The editor instance which this button is
+		 * to be used by.
+		 * @param {Array} [output] The output array to which append the HTML relative
+		 * to this button.
+		 */
+		render: function( editor, output ) {
+			this.getHolderElement = function() {
+				var holder = this._.holder;
+
+				if ( !holder ) {
+					if ( this.isFramed ) {
+						var iframe = this.document.getById( this.id + '_frame' ),
+							parentDiv = iframe.getParent(),
+							doc = iframe.getFrameDocument();
+
+						// Make it scrollable on iOS. (#8308)
+						CKEDITOR.env.iOS && parentDiv.setStyles( {
+							'overflow': 'scroll',
+							'-webkit-overflow-scrolling': 'touch'
+						} );
+
+						var onLoad = CKEDITOR.tools.addFunction( CKEDITOR.tools.bind( function( ev ) {
+							this.isLoaded = true;
+							if ( this.onLoad )
+								this.onLoad();
+						}, this ) );
+
+						doc.write( frameDocTpl.output( CKEDITOR.tools.extend( {
+							css: CKEDITOR.tools.buildStyleHtml( this.css ),
+							onload: 'window.parent.CKEDITOR.tools.callFunction(' + onLoad + ');'
+						}, data ) ) );
+
+						var win = doc.getWindow();
+
+						// Register the CKEDITOR global.
+						win.$.CKEDITOR = CKEDITOR;
+
+						// Arrow keys for scrolling is only preventable with 'keypress' event in Opera (#4534).
+						doc.on( 'key' + ( CKEDITOR.env.opera ? 'press' : 'down' ), function( evt ) {
+							var keystroke = evt.data.getKeystroke(),
+								dir = this.document.getById( this.id ).getAttribute( 'dir' );
+
+							// Delegate key processing to block.
+							if ( this._.onKeyDown && this._.onKeyDown( keystroke ) === false ) {
+								evt.data.preventDefault();
+								return;
+							}
+
+							// ESC/ARROW-LEFT(ltr) OR ARROW-RIGHT(rtl)
+							if ( keystroke == 27 || keystroke == ( dir == 'rtl' ? 39 : 37 ) ) {
+								if ( this.onEscape && this.onEscape( keystroke ) === false )
+									evt.data.preventDefault();
+							}
+						}, this );
+
+						holder = doc.getBody();
+						holder.unselectable();
+						CKEDITOR.env.air && CKEDITOR.tools.callFunction( onLoad );
+					} else
+						holder = this.document.getById( this.id );
+
+					this._.holder = holder;
+				}
+
+				return holder;
+			};
+
+			var data = {
+				editorId: editor.id,
+				id: this.id,
+				langCode: editor.langCode,
+				dir: editor.lang.dir,
+				cls: this.className,
+				frame: '',
+				env: CKEDITOR.env.cssClass,
+				'z-index': editor.config.baseFloatZIndex + 1
+			};
+
+			if ( this.isFramed ) {
+				// With IE, the custom domain has to be taken care at first,
+				// for other browers, the 'src' attribute should be left empty to
+				// trigger iframe's 'load' event.
+				var src =
+					CKEDITOR.env.air ? 'javascript:void(0)' :
+					CKEDITOR.env.ie ? 'javascript:void(function(){' + encodeURIComponent(
+						'document.open();' +
+						// In IE, the document domain must be set any time we call document.open().
+						'(' + CKEDITOR.tools.fixDomain + ')();' +
+						'document.close();'
+					) + '}())' :
+					'';
+
+				data.frame = frameTpl.output( {
+					id: this.id + '_frame',
+					src: src
+				} );
+			}
+
+			var html = panelTpl.output( data );
+
+			if ( output )
+				output.push( html );
+
+			return html;
+		},
+
+		/**
+		 * @todo
+		 */
+		addBlock: function( name, block ) {
+			block = this._.blocks[ name ] = block instanceof CKEDITOR.ui.panel.block ? block : new CKEDITOR.ui.panel.block( this.getHolderElement(), block );
+
+			if ( !this._.currentBlock )
+				this.showBlock( name );
+
+			return block;
+		},
+
+		/**
+		 * @todo
+		 */
+		getBlock: function( name ) {
+			return this._.blocks[ name ];
+		},
+
+		/**
+		 * @todo
+		 */
+		showBlock: function( name ) {
+			var blocks = this._.blocks,
+				block = blocks[ name ],
+				current = this._.currentBlock;
+
+			// ARIA role works better in IE on the body element, while on the iframe
+			// for FF. (#8864)
+			var holder = !this.forceIFrame || CKEDITOR.env.ie ? this._.holder : this.document.getById( this.id + '_frame' );
+
+			if ( current )
+				current.hide();
+
+			this._.currentBlock = block;
+
+			CKEDITOR.fire( 'ariaWidget', holder );
+
+			// Reset the focus index, so it will always go into the first one.
+			block._.focusIndex = -1;
+
+			this._.onKeyDown = block.onKeyDown && CKEDITOR.tools.bind( block.onKeyDown, block );
+
+			block.show();
+
+			return block;
+		},
+
+		/**
+		 * @todo
+		 */
+		destroy: function() {
+			this.element && this.element.remove();
+		}
+	};
+
+	/**
+	 * @class
+	 *
+	 * @todo class and all methods
+	 */
+	CKEDITOR.ui.panel.block = CKEDITOR.tools.createClass( {
+		/**
+		 * Creates a block class instances.
+		 *
+		 * @constructor
+		 * @todo
+		 */
+		$: function( blockHolder, blockDefinition ) {
+			this.element = blockHolder.append( blockHolder.getDocument().createElement( 'div', {
+				attributes: {
+					'tabindex': -1,
+					'class': 'cke_panel_block'
+				},
+				styles: {
+					display: 'none'
+				}
+			} ) );
+
+			// Copy all definition properties to this object.
+			if ( blockDefinition )
+				CKEDITOR.tools.extend( this, blockDefinition );
+
+			// Set the a11y attributes of this element ...
+			this.element.setAttributes( {
+				'role': this.attributes.role || 'presentation',
+				'aria-label': this.attributes[ 'aria-label' ],
+				'title': this.attributes.title || this.attributes[ 'aria-label' ]
+			} );
+
+			this.keys = {};
+
+			this._.focusIndex = -1;
+
+			// Disable context menu for panels.
+			this.element.disableContextMenu();
+		},
+
+		_: {
+
+			/**
+			 * Mark the item specified by the index as current activated.
+			 */
+			markItem: function( index ) {
+				if ( index == -1 )
+					return;
+				var links = this.element.getElementsByTag( 'a' );
+				var item = links.getItem( this._.focusIndex = index );
+
+				// Safari need focus on the iframe window first(#3389), but we need
+				// lock the blur to avoid hiding the panel.
+				if ( CKEDITOR.env.webkit || CKEDITOR.env.opera )
+					item.getDocument().getWindow().focus();
+				item.focus();
+
+				this.onMark && this.onMark( item );
+			}
+		},
+
+		proto: {
+			show: function() {
+				this.element.setStyle( 'display', '' );
+			},
+
+			hide: function() {
+				if ( !this.onHide || this.onHide.call( this ) !== true )
+					this.element.setStyle( 'display', 'none' );
+			},
+
+			onKeyDown: function( keystroke, noCycle ) {
+				var keyAction = this.keys[ keystroke ];
+				switch ( keyAction ) {
+					// Move forward.
+					case 'next':
+						var index = this._.focusIndex,
+							links = this.element.getElementsByTag( 'a' ),
+							link;
+
+						while ( ( link = links.getItem( ++index ) ) ) {
+							// Move the focus only if the element is marked with
+							// the _cke_focus and it it's visible (check if it has
+							// width).
+							if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth ) {
+								this._.focusIndex = index;
+								link.focus();
+								break;
+							}
+						}
+
+						// If no link was found, cycle and restart from the top. (#11125)
+						if ( !link && !noCycle ) {
+							this._.focusIndex = -1;
+							return this.onKeyDown( keystroke, 1 );
+						}
+
+						return false;
+
+						// Move backward.
+					case 'prev':
+						index = this._.focusIndex;
+						links = this.element.getElementsByTag( 'a' );
+
+						while ( index > 0 && ( link = links.getItem( --index ) ) ) {
+							// Move the focus only if the element is marked with
+							// the _cke_focus and it it's visible (check if it has
+							// width).
+							if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth ) {
+								this._.focusIndex = index;
+								link.focus();
+								break;
+							}
+
+							// Make sure link is null when the loop ends and nothing was
+							// found (#11125).
+							link = null;
+						}
+
+						// If no link was found, cycle and restart from the bottom. (#11125)
+						if ( !link && !noCycle ) {
+							this._.focusIndex = links.count();
+							return this.onKeyDown( keystroke, 1 );
+						}
+
+						return false;
+
+					case 'click':
+					case 'mouseup':
+						index = this._.focusIndex;
+						link = index >= 0 && this.element.getElementsByTag( 'a' ).getItem( index );
+
+						if ( link )
+							link.$[ keyAction ] ? link.$[ keyAction ]() : link.$[ 'on' + keyAction ]();
+
+						return false;
+				}
+
+				return true;
+			}
+		}
+	} );
+
+} )();
+
+/**
+ * Fired when a panel is added to the document.
+ *
+ * @event ariaWidget
+ * @member CKEDITOR
+ * @param {Object} data The element wrapping the panel.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/panelbutton/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/panelbutton/plugin.js
new file mode 100644
index 00000000..67a31237
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/panelbutton/plugin.js
@@ -0,0 +1,138 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'panelbutton', {
+	requires: 'button',
+	onLoad: function() {
+		function clickFn( editor ) {
+			var _ = this._;
+
+			if ( _.state == CKEDITOR.TRISTATE_DISABLED )
+				return;
+
+			this.createPanel( editor );
+
+			if ( _.on ) {
+				_.panel.hide();
+				return;
+			}
+
+			_.panel.showBlock( this._.id, this.document.getById( this._.id ), 4 );
+		}
+
+		/**
+		 * @class
+		 * @extends CKEDITOR.ui.button
+		 * @todo class and methods
+		 */
+		CKEDITOR.ui.panelButton = CKEDITOR.tools.createClass( {
+			base: CKEDITOR.ui.button,
+
+			/**
+			 * Creates a panelButton class instance.
+			 *
+			 * @constructor
+			 */
+			$: function( definition ) {
+				// We don't want the panel definition in this object.
+				var panelDefinition = definition.panel || {};
+				delete definition.panel;
+
+				this.base( definition );
+
+				this.document = ( panelDefinition.parent && panelDefinition.parent.getDocument() ) || CKEDITOR.document;
+
+				panelDefinition.block = {
+					attributes: panelDefinition.attributes
+				};
+				panelDefinition.toolbarRelated = true;
+
+				this.hasArrow = true;
+
+				this.click = clickFn;
+
+				this._ = {
+					panelDefinition: panelDefinition
+				};
+			},
+
+			statics: {
+				handler: {
+					create: function( definition ) {
+						return new CKEDITOR.ui.panelButton( definition );
+					}
+				}
+			},
+
+			proto: {
+				createPanel: function( editor ) {
+					var _ = this._;
+
+					if ( _.panel )
+						return;
+
+					var panelDefinition = this._.panelDefinition,
+						panelBlockDefinition = this._.panelDefinition.block,
+						panelParentElement = panelDefinition.parent || CKEDITOR.document.getBody(),
+						panel = this._.panel = new CKEDITOR.ui.floatPanel( editor, panelParentElement, panelDefinition ),
+						block = panel.addBlock( _.id, panelBlockDefinition ),
+						me = this;
+
+					panel.onShow = function() {
+						if ( me.className )
+							this.element.addClass( me.className + '_panel' );
+
+						me.setState( CKEDITOR.TRISTATE_ON );
+
+						_.on = 1;
+
+						me.editorFocus && editor.focus();
+
+						if ( me.onOpen )
+							me.onOpen();
+					};
+
+					panel.onHide = function( preventOnClose ) {
+						if ( me.className )
+							this.element.getFirst().removeClass( me.className + '_panel' );
+
+						me.setState( me.modes && me.modes[ editor.mode ] ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+
+						_.on = 0;
+
+						if ( !preventOnClose && me.onClose )
+							me.onClose();
+					};
+
+					panel.onEscape = function() {
+						panel.hide( 1 );
+						me.document.getById( _.id ).focus();
+					};
+
+					if ( this.onBlock )
+						this.onBlock( panel, block );
+
+					block.onHide = function() {
+						_.on = 0;
+						me.setState( CKEDITOR.TRISTATE_OFF );
+					};
+				}
+			}
+		} );
+
+	},
+	beforeInit: function( editor ) {
+		editor.ui.addHandler( CKEDITOR.UI_PANELBUTTON, CKEDITOR.ui.panelButton.handler );
+	}
+} );
+
+/**
+ * Button UI element.
+ *
+ * @readonly
+ * @property {String} [='panelbutton']
+ * @member CKEDITOR
+ */
+CKEDITOR.UI_PANELBUTTON = 'panelbutton';
diff --git a/lam/templates/lib/extra/ckeditor/plugins/removeformat/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/removeformat/plugin.js
new file mode 100644
index 00000000..ef3c4d73
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/removeformat/plugin.js
@@ -0,0 +1,174 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'removeformat', {
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	icons: 'removeformat', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		editor.addCommand( 'removeFormat', CKEDITOR.plugins.removeformat.commands.removeformat );
+		editor.ui.addButton && editor.ui.addButton( 'RemoveFormat', {
+			label: editor.lang.removeformat.toolbar,
+			command: 'removeFormat',
+			toolbar: 'cleanup,10'
+		} );
+	}
+} );
+
+CKEDITOR.plugins.removeformat = {
+	commands: {
+		removeformat: {
+			exec: function( editor ) {
+				var tagsRegex = editor._.removeFormatRegex || ( editor._.removeFormatRegex = new RegExp( '^(?:' + editor.config.removeFormatTags.replace( /,/g, '|' ) + ')$', 'i' ) );
+
+				var removeAttributes = editor._.removeAttributes || ( editor._.removeAttributes = editor.config.removeFormatAttributes.split( ',' ) );
+
+				var filter = CKEDITOR.plugins.removeformat.filter;
+				var ranges = editor.getSelection().getRanges( 1 ),
+					iterator = ranges.createIterator(),
+					range;
+
+				while ( ( range = iterator.getNextRange() ) ) {
+					if ( !range.collapsed )
+						range.enlarge( CKEDITOR.ENLARGE_ELEMENT );
+
+					// Bookmark the range so we can re-select it after processing.
+					var bookmark = range.createBookmark(),
+						// The style will be applied within the bookmark boundaries.
+						startNode = bookmark.startNode,
+						endNode = bookmark.endNode,
+						currentNode;
+
+					// We need to check the selection boundaries (bookmark spans) to break
+					// the code in a way that we can properly remove partially selected nodes.
+					// For example, removing a <b> style from
+					//		<b>This is [some text</b> to show <b>the] problem</b>
+					// ... where [ and ] represent the selection, must result:
+					//		<b>This is </b>[some text to show the]<b> problem</b>
+					// The strategy is simple, we just break the partial nodes before the
+					// removal logic, having something that could be represented this way:
+					//		<b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>
+
+					var breakParent = function( node ) {
+							// Let's start checking the start boundary.
+							var path = editor.elementPath( node ),
+								pathElements = path.elements;
+
+							for ( var i = 1, pathElement; pathElement = pathElements[ i ]; i++ ) {
+								if ( pathElement.equals( path.block ) || pathElement.equals( path.blockLimit ) )
+									break;
+
+								// If this element can be removed (even partially).
+								if ( tagsRegex.test( pathElement.getName() ) && filter( editor, pathElement ) )
+									node.breakParent( pathElement );
+							}
+						};
+
+					breakParent( startNode );
+					if ( endNode ) {
+						breakParent( endNode );
+
+						// Navigate through all nodes between the bookmarks.
+						currentNode = startNode.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT );
+
+						while ( currentNode ) {
+							// If we have reached the end of the selection, stop looping.
+							if ( currentNode.equals( endNode ) )
+								break;
+
+							// Cache the next node to be processed. Do it now, because
+							// currentNode may be removed.
+							var nextNode = currentNode.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT );
+
+							// This node must not be a fake element.
+							if ( !( currentNode.getName() == 'img' && currentNode.data( 'cke-realelement' ) ) && filter( editor, currentNode ) ) {
+								// Remove elements nodes that match with this style rules.
+								if ( tagsRegex.test( currentNode.getName() ) )
+									currentNode.remove( 1 );
+								else {
+									currentNode.removeAttributes( removeAttributes );
+									editor.fire( 'removeFormatCleanup', currentNode );
+								}
+							}
+
+							currentNode = nextNode;
+						}
+					}
+
+					range.moveToBookmark( bookmark );
+				}
+
+				// The selection path may not changed, but we should force a selection
+				// change event to refresh command states, due to the above attribution change. (#9238)
+				editor.forceNextSelectionCheck();
+				editor.getSelection().selectRanges( ranges );
+			}
+		}
+	},
+
+	// Perform the remove format filters on the passed element.
+	// @param {CKEDITOR.editor} editor
+	// @param {CKEDITOR.dom.element} element
+	filter: function( editor, element ) {
+		// If editor#addRemoveFotmatFilter hasn't been executed yet value is not initialized.
+		var filters = editor._.removeFormatFilters || [];
+		for ( var i = 0; i < filters.length; i++ ) {
+			if ( filters[ i ]( element ) === false )
+				return false;
+		}
+		return true;
+	}
+};
+
+/**
+ * Add to a collection of functions to decide whether a specific
+ * element should be considered as formatting element and thus
+ * could be removed during `removeFormat` command.
+ *
+ * **Note:** Only available with the existence of `removeformat` plugin.
+ *
+ *		// Don't remove empty span.
+ *		editor.addRemoveFormatFilter( function( element ) {
+ *			return !( element.is( 'span' ) && CKEDITOR.tools.isEmpty( element.getAttributes() ) );
+ *		} );
+ *
+ * @since 3.3
+ * @member CKEDITOR.editor
+ * @param {Function} func The function to be called, which will be passed a {CKEDITOR.dom.element} element to test.
+ */
+CKEDITOR.editor.prototype.addRemoveFormatFilter = function( func ) {
+	if ( !this._.removeFormatFilters )
+		this._.removeFormatFilters = [];
+
+	this._.removeFormatFilters.push( func );
+};
+
+/**
+ * A comma separated list of elements to be removed when executing the `remove
+ * format` command. Note that only inline elements are allowed.
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.removeFormatTags = 'b,big,code,del,dfn,em,font,i,ins,kbd,q,s,samp,small,span,strike,strong,sub,sup,tt,u,var';
+
+/**
+ * A comma separated list of elements attributes to be removed when executing
+ * the `remove format` command.
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.removeFormatAttributes = 'class,style,lang,width,height,align,hspace,valign';
+
+/**
+ * Fired after an element was cleaned by the removeFormat plugin.
+ *
+ * @event removeFormatCleanup
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param data
+ * @param {CKEDITOR.dom.element} data.element The element that was cleaned up.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/richcombo/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/richcombo/plugin.js
new file mode 100644
index 00000000..8ea5c12a
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/richcombo/plugin.js
@@ -0,0 +1,441 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'richcombo', {
+	requires: 'floatpanel,listblock,button',
+
+	beforeInit: function( editor ) {
+		editor.ui.addHandler( CKEDITOR.UI_RICHCOMBO, CKEDITOR.ui.richCombo.handler );
+	}
+} );
+
+( function() {
+	var template = '<span id="{id}"' +
+		' class="cke_combo cke_combo__{name} {cls}"' +
+		' role="presentation">' +
+			'<span id="{id}_label" class="cke_combo_label">{label}</span>' +
+			'<a class="cke_combo_button" hidefocus=true title="{title}" tabindex="-1"' +
+			( CKEDITOR.env.gecko && CKEDITOR.env.version >= 10900 && !CKEDITOR.env.hc ? '' : '" href="javascript:void(\'{titleJs}\')"' ) +
+			' hidefocus="true"' +
+			' role="button"' +
+			' aria-labelledby="{id}_label"' +
+			' aria-haspopup="true"';
+
+	// Some browsers don't cancel key events in the keydown but in the
+	// keypress.
+	// TODO: Check if really needed for Gecko+Mac.
+	if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+		template += ' onkeypress="return false;"';
+
+	// With Firefox, we need to force the button to redraw, otherwise it
+	// will remain in the focus state.
+	if ( CKEDITOR.env.gecko )
+		template += ' onblur="this.style.cssText = this.style.cssText;"';
+
+	template +=
+		' onkeydown="return CKEDITOR.tools.callFunction({keydownFn},event,this);"' +
+		' onmousedown="return CKEDITOR.tools.callFunction({mousedownFn},event);" ' +
+		' onfocus="return CKEDITOR.tools.callFunction({focusFn},event);" ' +
+			( CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick' ) + // #188
+				'="CKEDITOR.tools.callFunction({clickFn},this);return false;">' +
+			'<span id="{id}_text" class="cke_combo_text cke_combo_inlinelabel">{label}</span>' +
+			'<span class="cke_combo_open">' +
+				'<span class="cke_combo_arrow">' +
+				// BLACK DOWN-POINTING TRIANGLE
+	( CKEDITOR.env.hc ? '&#9660;' : CKEDITOR.env.air ? '&nbsp;' : '' ) +
+				'</span>' +
+			'</span>' +
+		'</a>' +
+		'</span>';
+
+	var rcomboTpl = CKEDITOR.addTemplate( 'combo', template );
+
+	/**
+	 * Button UI element.
+	 *
+	 * @readonly
+	 * @property {String} [='richcombo']
+	 * @member CKEDITOR
+	 */
+	CKEDITOR.UI_RICHCOMBO = 'richcombo';
+
+	/**
+	 * @class
+	 * @todo
+	 */
+	CKEDITOR.ui.richCombo = CKEDITOR.tools.createClass( {
+		$: function( definition ) {
+			// Copy all definition properties to this object.
+			CKEDITOR.tools.extend( this, definition,
+			// Set defaults.
+			{
+				// The combo won't participate in toolbar grouping.
+				canGroup: false,
+				title: definition.label,
+				modes: { wysiwyg: 1 },
+				editorFocus: 1
+			} );
+
+			// We don't want the panel definition in this object.
+			var panelDefinition = this.panel || {};
+			delete this.panel;
+
+			this.id = CKEDITOR.tools.getNextNumber();
+
+			this.document = ( panelDefinition.parent && panelDefinition.parent.getDocument() ) || CKEDITOR.document;
+
+			panelDefinition.className = 'cke_combopanel';
+			panelDefinition.block = {
+				multiSelect: panelDefinition.multiSelect,
+				attributes: panelDefinition.attributes
+			};
+			panelDefinition.toolbarRelated = true;
+
+			this._ = {
+				panelDefinition: panelDefinition,
+				items: {}
+			};
+		},
+
+		proto: {
+			renderHtml: function( editor ) {
+				var output = [];
+				this.render( editor, output );
+				return output.join( '' );
+			},
+
+			/**
+			 * Renders the combo.
+			 *
+			 * @param {CKEDITOR.editor} editor The editor instance which this button is
+			 * to be used by.
+			 * @param {Array} output The output array to which append the HTML relative
+			 * to this button.
+			 */
+			render: function( editor, output ) {
+				var env = CKEDITOR.env;
+
+				var id = 'cke_' + this.id;
+				var clickFn = CKEDITOR.tools.addFunction( function( el ) {
+					// Restore locked selection in Opera.
+					if ( selLocked ) {
+						editor.unlockSelection( 1 );
+						selLocked = 0;
+					}
+					instance.execute( el );
+				}, this );
+
+				var combo = this;
+				var instance = {
+					id: id,
+					combo: this,
+					focus: function() {
+						var element = CKEDITOR.document.getById( id ).getChild( 1 );
+						element.focus();
+					},
+					execute: function( el ) {
+						var _ = combo._;
+
+						if ( _.state == CKEDITOR.TRISTATE_DISABLED )
+							return;
+
+						combo.createPanel( editor );
+
+						if ( _.on ) {
+							_.panel.hide();
+							return;
+						}
+
+						combo.commit();
+						var value = combo.getValue();
+						if ( value )
+							_.list.mark( value );
+						else
+							_.list.unmarkAll();
+
+						_.panel.showBlock( combo.id, new CKEDITOR.dom.element( el ), 4 );
+					},
+					clickFn: clickFn
+				};
+
+				function updateState() {
+					var state = this.modes[ editor.mode ] ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
+
+					if ( editor.readOnly && !this.readOnly )
+						state = CKEDITOR.TRISTATE_DISABLED;
+
+					this.setState( state );
+					this.setValue( '' );
+
+					// Let plugin to disable button.
+					if ( state != CKEDITOR.TRISTATE_DISABLED && this.refresh )
+						this.refresh();
+				}
+
+				// Update status when activeFilter, mode, selection or readOnly changes.
+				editor.on( 'activeFilterChange', updateState, this );
+				editor.on( 'mode', updateState, this );
+				editor.on( 'selectionChange', updateState, this );
+				// If this combo is sensitive to readOnly state, update it accordingly.
+				!this.readOnly && editor.on( 'readOnly', updateState, this );
+
+				var keyDownFn = CKEDITOR.tools.addFunction( function( ev, element ) {
+					ev = new CKEDITOR.dom.event( ev );
+
+					var keystroke = ev.getKeystroke();
+
+					// ARROW-DOWN
+					// This call is duplicated in plugins/toolbar/plugin.js in itemKeystroke().
+					// Move focus to the first element after drop down was opened by the arrow down key.
+					if ( keystroke == 40 ) {
+						editor.once( 'panelShow', function( evt ) {
+							evt.data._.panel._.currentBlock.onKeyDown( 40 );
+						} );
+					}
+
+					switch ( keystroke ) {
+						case 13: // ENTER
+						case 32: // SPACE
+						case 40: // ARROW-DOWN
+							// Show panel
+							CKEDITOR.tools.callFunction( clickFn, element );
+							break;
+						default:
+							// Delegate the default behavior to toolbar button key handling.
+							instance.onkey( instance, keystroke );
+					}
+
+					// Avoid subsequent focus grab on editor document.
+					ev.preventDefault();
+				} );
+
+				var focusFn = CKEDITOR.tools.addFunction( function() {
+					instance.onfocus && instance.onfocus();
+				} );
+
+				var selLocked = 0;
+				var mouseDownFn = CKEDITOR.tools.addFunction( function() {
+					// Opera: lock to prevent loosing editable text selection when clicking on button.
+					if ( CKEDITOR.env.opera ) {
+						var edt = editor.editable();
+						if ( edt.isInline() && edt.hasFocus ) {
+							editor.lockSelection();
+							selLocked = 1;
+						}
+					}
+				} );
+
+				// For clean up
+				instance.keyDownFn = keyDownFn;
+
+				var params = {
+					id: id,
+					name: this.name || this.command,
+					label: this.label,
+					title: this.title,
+					cls: this.className || '',
+					titleJs: env.gecko && env.version >= 10900 && !env.hc ? '' : ( this.title || '' ).replace( "'", '' ),
+					keydownFn: keyDownFn,
+					mousedownFn: mouseDownFn,
+					focusFn: focusFn,
+					clickFn: clickFn
+				};
+
+				rcomboTpl.output( params, output );
+
+				if ( this.onRender )
+					this.onRender();
+
+				return instance;
+			},
+
+			createPanel: function( editor ) {
+				if ( this._.panel )
+					return;
+
+				var panelDefinition = this._.panelDefinition,
+					panelBlockDefinition = this._.panelDefinition.block,
+					panelParentElement = panelDefinition.parent || CKEDITOR.document.getBody(),
+					namedPanelCls = 'cke_combopanel__' + this.name,
+					panel = new CKEDITOR.ui.floatPanel( editor, panelParentElement, panelDefinition ),
+					list = panel.addListBlock( this.id, panelBlockDefinition ),
+					me = this;
+
+				panel.onShow = function() {
+					this.element.addClass( namedPanelCls );
+
+					me.setState( CKEDITOR.TRISTATE_ON );
+
+					me._.on = 1;
+
+					me.editorFocus && !editor.focusManager.hasFocus && editor.focus();
+
+					if ( me.onOpen )
+						me.onOpen();
+
+					// The "panelShow" event is fired assinchronously, after the
+					// onShow method call.
+					editor.once( 'panelShow', function() {
+						list.focus( !list.multiSelect && me.getValue() );
+					} );
+				};
+
+				panel.onHide = function( preventOnClose ) {
+					this.element.removeClass( namedPanelCls );
+
+					me.setState( me.modes && me.modes[ editor.mode ] ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+
+					me._.on = 0;
+
+					if ( !preventOnClose && me.onClose )
+						me.onClose();
+				};
+
+				panel.onEscape = function() {
+					// Hide drop-down with focus returned.
+					panel.hide( 1 );
+				};
+
+				list.onClick = function( value, marked ) {
+
+					if ( me.onClick )
+						me.onClick.call( me, value, marked );
+
+					panel.hide();
+				};
+
+				this._.panel = panel;
+				this._.list = list;
+
+				panel.getBlock( this.id ).onHide = function() {
+					me._.on = 0;
+					me.setState( CKEDITOR.TRISTATE_OFF );
+				};
+
+				if ( this.init )
+					this.init();
+			},
+
+			setValue: function( value, text ) {
+				this._.value = value;
+
+				var textElement = this.document.getById( 'cke_' + this.id + '_text' );
+				if ( textElement ) {
+					if ( !( value || text ) ) {
+						text = this.label;
+						textElement.addClass( 'cke_combo_inlinelabel' );
+					} else
+						textElement.removeClass( 'cke_combo_inlinelabel' );
+
+					textElement.setText( typeof text != 'undefined' ? text : value );
+				}
+			},
+
+			getValue: function() {
+				return this._.value || '';
+			},
+
+			unmarkAll: function() {
+				this._.list.unmarkAll();
+			},
+
+			mark: function( value ) {
+				this._.list.mark( value );
+			},
+
+			hideItem: function( value ) {
+				this._.list.hideItem( value );
+			},
+
+			hideGroup: function( groupTitle ) {
+				this._.list.hideGroup( groupTitle );
+			},
+
+			showAll: function() {
+				this._.list.showAll();
+			},
+
+			add: function( value, html, text ) {
+				this._.items[ value ] = text || value;
+				this._.list.add( value, html, text );
+			},
+
+			startGroup: function( title ) {
+				this._.list.startGroup( title );
+			},
+
+			commit: function() {
+				if ( !this._.committed ) {
+					this._.list.commit();
+					this._.committed = 1;
+					CKEDITOR.ui.fire( 'ready', this );
+				}
+				this._.committed = 1;
+			},
+
+			setState: function( state ) {
+				if ( this._.state == state )
+					return;
+
+				var el = this.document.getById( 'cke_' + this.id );
+				el.setState( state, 'cke_combo' );
+
+				state == CKEDITOR.TRISTATE_DISABLED ?
+					el.setAttribute( 'aria-disabled', true ) :
+					el.removeAttribute( 'aria-disabled' );
+
+				this._.state = state;
+			},
+
+			getState: function() {
+				return this._.state;
+			},
+
+			enable: function() {
+				if ( this._.state == CKEDITOR.TRISTATE_DISABLED )
+					this.setState( this._.lastState );
+			},
+
+			disable: function() {
+				if ( this._.state != CKEDITOR.TRISTATE_DISABLED ) {
+					this._.lastState = this._.state;
+					this.setState( CKEDITOR.TRISTATE_DISABLED );
+				}
+			}
+		},
+
+		/**
+		 * Represents richCombo handler object.
+		 *
+		 * @class CKEDITOR.ui.richCombo.handler
+		 * @singleton
+		 * @extends CKEDITOR.ui.handlerDefinition
+		 */
+		statics: {
+			handler: {
+				/**
+				 * Transforms a richCombo definition in a {@link CKEDITOR.ui.richCombo} instance.
+				 *
+				 * @param {Object} definition
+				 * @returns {CKEDITOR.ui.richCombo}
+				 */
+				create: function( definition ) {
+					return new CKEDITOR.ui.richCombo( definition );
+				}
+			}
+		}
+	} );
+
+	/**
+	 * @param {String} name
+	 * @param {Object} definition
+	 * @member CKEDITOR.ui
+	 * @todo
+	 */
+	CKEDITOR.ui.prototype.addRichCombo = function( name, definition ) {
+		this.add( name, CKEDITOR.UI_RICHCOMBO, definition );
+	};
+
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/showborders/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/showborders/plugin.js
new file mode 100644
index 00000000..940d2c19
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/showborders/plugin.js
@@ -0,0 +1,174 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "show border" plugin. The command display visible outline
+ * border line around all table elements if table doesn't have a none-zero 'border' attribute specified.
+ */
+
+( function() {
+	var commandDefinition = {
+		preserveState: true,
+		editorFocus: false,
+		readOnly: 1,
+
+		exec: function( editor ) {
+			this.toggleState();
+			this.refresh( editor );
+		},
+
+		refresh: function( editor ) {
+			if ( editor.document ) {
+				var funcName = ( this.state == CKEDITOR.TRISTATE_ON ) ? 'attachClass' : 'removeClass';
+				editor.editable()[ funcName ]( 'cke_show_borders' );
+			}
+		}
+	};
+
+	var showBorderClassName = 'cke_show_border';
+
+	CKEDITOR.plugins.add( 'showborders', {
+		modes: { 'wysiwyg': 1 },
+
+		onLoad: function() {
+			var cssStyleText,
+				cssTemplate =
+			// TODO: For IE6, we don't have child selector support,
+			// where nested table cells could be incorrect.
+			( CKEDITOR.env.ie6Compat ? [
+				'.%1 table.%2,',
+					'.%1 table.%2 td, .%1 table.%2 th',
+					'{',
+					'border : #d3d3d3 1px dotted',
+					'}'
+				] : [
+				'.%1 table.%2,',
+				'.%1 table.%2 > tr > td, .%1 table.%2 > tr > th,',
+				'.%1 table.%2 > tbody > tr > td, .%1 table.%2 > tbody > tr > th,',
+				'.%1 table.%2 > thead > tr > td, .%1 table.%2 > thead > tr > th,',
+				'.%1 table.%2 > tfoot > tr > td, .%1 table.%2 > tfoot > tr > th',
+				'{',
+					'border : #d3d3d3 1px dotted',
+				'}'
+				] ).join( '' );
+
+			cssStyleText = cssTemplate.replace( /%2/g, showBorderClassName ).replace( /%1/g, 'cke_show_borders ' );
+
+			CKEDITOR.addCss( cssStyleText );
+		},
+
+		init: function( editor ) {
+
+			var command = editor.addCommand( 'showborders', commandDefinition );
+			command.canUndo = false;
+
+			if ( editor.config.startupShowBorders !== false )
+				command.setState( CKEDITOR.TRISTATE_ON );
+
+			// Refresh the command on setData.
+			editor.on( 'mode', function() {
+				if ( command.state != CKEDITOR.TRISTATE_DISABLED )
+					command.refresh( editor );
+			}, null, null, 100 );
+
+			// Refresh the command on wysiwyg frame reloads.
+			editor.on( 'contentDom', function() {
+				if ( command.state != CKEDITOR.TRISTATE_DISABLED )
+					command.refresh( editor );
+			} );
+
+			editor.on( 'removeFormatCleanup', function( evt ) {
+				var element = evt.data;
+				if ( editor.getCommand( 'showborders' ).state == CKEDITOR.TRISTATE_ON && element.is( 'table' ) && ( !element.hasAttribute( 'border' ) || parseInt( element.getAttribute( 'border' ), 10 ) <= 0 ) )
+					element.addClass( showBorderClassName );
+			} );
+		},
+
+		afterInit: function( editor ) {
+			var dataProcessor = editor.dataProcessor,
+				dataFilter = dataProcessor && dataProcessor.dataFilter,
+				htmlFilter = dataProcessor && dataProcessor.htmlFilter;
+
+			if ( dataFilter ) {
+				dataFilter.addRules( {
+					elements: {
+						'table': function( element ) {
+							var attributes = element.attributes,
+								cssClass = attributes[ 'class' ],
+								border = parseInt( attributes.border, 10 );
+
+							if ( ( !border || border <= 0 ) && ( !cssClass || cssClass.indexOf( showBorderClassName ) == -1 ) )
+								attributes[ 'class' ] = ( cssClass || '' ) + ' ' + showBorderClassName;
+						}
+					}
+				} );
+			}
+
+			if ( htmlFilter ) {
+				htmlFilter.addRules( {
+					elements: {
+						'table': function( table ) {
+							var attributes = table.attributes,
+								cssClass = attributes[ 'class' ];
+
+							cssClass && ( attributes[ 'class' ] = cssClass.replace( showBorderClassName, '' ).replace( /\s{2}/, ' ' ).replace( /^\s+|\s+$/, '' ) );
+						}
+					}
+				} );
+			}
+		}
+	} );
+
+	// Table dialog must be aware of it.
+	CKEDITOR.on( 'dialogDefinition', function( ev ) {
+		var dialogName = ev.data.name;
+
+		if ( dialogName == 'table' || dialogName == 'tableProperties' ) {
+			var dialogDefinition = ev.data.definition,
+				infoTab = dialogDefinition.getContents( 'info' ),
+				borderField = infoTab.get( 'txtBorder' ),
+				originalCommit = borderField.commit;
+
+			borderField.commit = CKEDITOR.tools.override( originalCommit, function( org ) {
+				return function( data, selectedTable ) {
+					org.apply( this, arguments );
+					var value = parseInt( this.getValue(), 10 );
+					selectedTable[ ( !value || value <= 0 ) ? 'addClass' : 'removeClass' ]( showBorderClassName );
+				};
+			} );
+
+			var advTab = dialogDefinition.getContents( 'advanced' ),
+				classField = advTab && advTab.get( 'advCSSClasses' );
+
+			if ( classField ) {
+				classField.setup = CKEDITOR.tools.override( classField.setup, function( originalSetup ) {
+					return function() {
+						originalSetup.apply( this, arguments );
+						this.setValue( this.getValue().replace( /cke_show_border/, '' ) );
+					};
+				} );
+
+				classField.commit = CKEDITOR.tools.override( classField.commit, function( originalCommit ) {
+					return function( data, element ) {
+						originalCommit.apply( this, arguments );
+
+						if ( !parseInt( element.getAttribute( 'border' ), 10 ) )
+							element.addClass( 'cke_show_border' );
+					};
+				} );
+			}
+		}
+	} );
+
+} )();
+
+/**
+ * Whether to automatically enable the "show borders" command when the editor loads.
+ *
+ *		config.startupShowBorders = false;
+ *
+ * @cfg {Boolean} [startupShowBorders=true]
+ * @member CKEDITOR.config
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/sourcearea/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/sourcearea/plugin.js
new file mode 100644
index 00000000..6d7747ae
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/sourcearea/plugin.js
@@ -0,0 +1,154 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "sourcearea" plugin. It registers the "source" editing
+ *		mode, which displays the raw data being edited in the editor.
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'sourcearea', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'source,source-rtl', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			// Source mode isn't available in inline mode yet.
+			if ( editor.elementMode == CKEDITOR.ELEMENT_MODE_INLINE )
+				return;
+
+			var sourcearea = CKEDITOR.plugins.sourcearea;
+
+			editor.addMode( 'source', function( callback ) {
+				var contentsSpace = editor.ui.space( 'contents' ),
+					textarea = contentsSpace.getDocument().createElement( 'textarea' );
+
+				textarea.setStyles(
+					CKEDITOR.tools.extend( {
+						// IE7 has overflow the <textarea> from wrapping table cell.
+						width: CKEDITOR.env.ie7Compat ? '99%' : '100%',
+						height: '100%',
+						resize: 'none',
+						outline: 'none',
+						'text-align': 'left'
+					},
+					CKEDITOR.tools.cssVendorPrefix( 'tab-size', editor.config.sourceAreaTabSize || 4 ) ) );
+
+				// Make sure that source code is always displayed LTR,
+				// regardless of editor language (#10105).
+				textarea.setAttribute( 'dir', 'ltr' );
+
+				textarea.addClass( 'cke_source cke_reset cke_enable_context_menu' );
+
+				editor.ui.space( 'contents' ).append( textarea );
+
+				var editable = editor.editable( new sourceEditable( editor, textarea ) );
+
+				// Fill the textarea with the current editor data.
+				editable.setData( editor.getData( 1 ) );
+
+				// Having to make <textarea> fixed sized to conquer the following bugs:
+				// 1. The textarea height/width='100%' doesn't constraint to the 'td' in IE6/7.
+				// 2. Unexpected vertical-scrolling behavior happens whenever focus is moving out of editor
+				// if text content within it has overflowed. (#4762)
+				if ( CKEDITOR.env.ie ) {
+					editable.attachListener( editor, 'resize', onResize, editable );
+					editable.attachListener( CKEDITOR.document.getWindow(), 'resize', onResize, editable );
+					CKEDITOR.tools.setTimeout( onResize, 0, editable );
+				}
+
+				editor.fire( 'ariaWidget', this );
+
+				callback();
+			} );
+
+			editor.addCommand( 'source', sourcearea.commands.source );
+
+			if ( editor.ui.addButton ) {
+				editor.ui.addButton( 'Source', {
+					label: editor.lang.sourcearea.toolbar,
+					command: 'source',
+					toolbar: 'mode,10'
+				} );
+			}
+
+			editor.on( 'mode', function() {
+				editor.getCommand( 'source' ).setState( editor.mode == 'source' ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+			} );
+
+			function onResize() {
+				// Holder rectange size is stretched by textarea,
+				// so hide it just for a moment.
+				this.hide();
+				this.setStyle( 'height', this.getParent().$.clientHeight + 'px' );
+				this.setStyle( 'width', this.getParent().$.clientWidth + 'px' );
+				// When we have proper holder size, show textarea again.
+				this.show();
+			}
+		}
+	} );
+
+	var sourceEditable = CKEDITOR.tools.createClass( {
+		base: CKEDITOR.editable,
+		proto: {
+			setData: function( data ) {
+				this.setValue( data );
+				this.editor.fire( 'dataReady' );
+			},
+
+			getData: function() {
+				return this.getValue();
+			},
+
+			// Insertions are not supported in source editable.
+			insertHtml: function() {},
+			insertElement: function() {},
+			insertText: function() {},
+
+			// Read-only support for textarea.
+			setReadOnly: function( isReadOnly ) {
+				this[ ( isReadOnly ? 'set' : 'remove' ) + 'Attribute' ]( 'readOnly', 'readonly' );
+			},
+
+			detach: function() {
+				sourceEditable.baseProto.detach.call( this );
+				this.clearCustomData();
+				this.remove();
+			}
+		}
+	} );
+} )();
+
+CKEDITOR.plugins.sourcearea = {
+	commands: {
+		source: {
+			modes: { wysiwyg: 1, source: 1 },
+			editorFocus: false,
+			readOnly: 1,
+			exec: function( editor ) {
+				if ( editor.mode == 'wysiwyg' )
+					editor.fire( 'saveSnapshot' );
+				editor.getCommand( 'source' ).setState( CKEDITOR.TRISTATE_DISABLED );
+				editor.setMode( editor.mode == 'source' ? 'wysiwyg' : 'source' );
+			},
+
+			canUndo: false
+		}
+	}
+};
+
+/**
+ * Controls CSS tab-size property of the sourcearea view.
+ *
+ * **Note:** Works only with {@link #dataIndentationChars}
+ * set to `'\t'`. Please consider that not all browsers support CSS
+ * `tab-size` property yet.
+ *
+ *		// Set tab-size to 20 characters.
+ *		CKEDITOR.config.sourceAreaTabSize = 20;
+ *
+ * @cfg {Number} [sourceAreaTabSize=4]
+ * @member CKEDITOR.config
+ * @see CKEDITOR.config#dataIndentationChars
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/specialchar/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/specialchar/plugin.js
new file mode 100644
index 00000000..7db32321
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/specialchar/plugin.js
@@ -0,0 +1,72 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Special Character plugin
+ */
+
+CKEDITOR.plugins.add( 'specialchar', {
+	// List of available localizations.
+	availableLangs: { ar: 1, bg: 1, ca: 1, cs: 1, cy: 1, de: 1, el: 1, en: 1, eo: 1, es: 1, et: 1, fa: 1, fi: 1, fr: 1,
+		'fr-ca': 1, gl: 1, he: 1, hr: 1, hu: 1, id: 1, it: 1, ja: 1, km: 1, ku: 1, lv: 1, nb: 1, nl: 1, no: 1, pl: 1,
+		pt: 1, 'pt-br': 1, ru: 1, si: 1, sk: 1, sl: 1, sq: 1, sv: 1, th: 1, tr: 1, ug: 1, uk: 1, vi: 1, zh: 1, 'zh-cn': 1 },
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	requires: 'dialog',
+	icons: 'specialchar', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		var pluginName = 'specialchar',
+			plugin = this;
+
+		// Register the dialog.
+		CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/specialchar.js' );
+
+		editor.addCommand( pluginName, {
+			exec: function() {
+				var langCode = editor.langCode;
+				langCode =
+					plugin.availableLangs[ langCode ] ? langCode :
+					plugin.availableLangs[ langCode.replace( /-.*/, '' ) ] ? langCode.replace( /-.*/, '' ) :
+					'en';
+
+				CKEDITOR.scriptLoader.load( CKEDITOR.getUrl( plugin.path + 'dialogs/lang/' + langCode + '.js' ), function() {
+					CKEDITOR.tools.extend( editor.lang.specialchar, plugin.langEntries[ langCode ] );
+					editor.openDialog( pluginName );
+				} );
+			},
+			modes: { wysiwyg: 1 },
+			canUndo: false
+		} );
+
+		// Register the toolbar button.
+		editor.ui.addButton && editor.ui.addButton( 'SpecialChar', {
+			label: editor.lang.specialchar.toolbar,
+			command: pluginName,
+			toolbar: 'insert,50'
+		} );
+	}
+} );
+
+/**
+ * The list of special characters visible in the "Special Character" dialog window.
+ *
+ *		config.specialChars = [ '&quot;', '&rsquo;', [ '&custom;', 'Custom label' ] ];
+ *		config.specialChars = config.specialChars.concat( [ '&quot;', [ '&rsquo;', 'Custom label' ] ] );
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.specialChars = [
+	'!', '&quot;', '#', '$', '%', '&amp;', "'", '(', ')', '*', '+', '-', '.', '/',
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
+	'&lt;', '=', '&gt;', '?', '@',
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+	'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'[', ']', '^', '_', '`',
+	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+	'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+	'{', '|', '}', '~',
+	"&euro;", "&lsquo;", "&rsquo;", "&ldquo;", "&rdquo;", "&ndash;", "&mdash;", "&iexcl;", "&cent;", "&pound;", "&curren;", "&yen;", "&brvbar;", "&sect;", "&uml;", "&copy;", "&ordf;", "&laquo;", "&not;", "&reg;", "&macr;", "&deg;", "&sup2;", "&sup3;", "&acute;", "&micro;", "&para;", "&middot;", "&cedil;", "&sup1;", "&ordm;", "&raquo;", "&frac14;", "&frac12;", "&frac34;", "&iquest;", "&Agrave;", "&Aacute;", "&Acirc;", "&Atilde;", "&Auml;", "&Aring;", "&AElig;", "&Ccedil;", "&Egrave;", "&Eacute;", "&Ecirc;", "&Euml;", "&Igrave;", "&Iacute;", "&Icirc;", "&Iuml;", "&ETH;", "&Ntilde;", "&Ograve;", "&Oacute;", "&Ocirc;", "&Otilde;", "&Ouml;", "&times;", "&Oslash;", "&Ugrave;", "&Uacute;", "&Ucirc;", "&Uuml;", "&Yacute;", "&THORN;", "&szlig;", "&agrave;", "&aacute;", "&acirc;", "&atilde;", "&auml;", "&aring;", "&aelig;", "&ccedil;", "&egrave;", "&eacute;", "&ecirc;", "&euml;", "&igrave;", "&iacute;", "&icirc;", "&iuml;", "&eth;", "&ntilde;", "&ograve;", "&oacute;", "&ocirc;", "&otilde;", "&ouml;", "&divide;", "&oslash;", "&ugrave;", "&uacute;", "&ucirc;", "&uuml;", "&yacute;", "&thorn;", "&yuml;", "&OElig;", "&oelig;", "&#372;", "&#374", "&#373", "&#375;", "&sbquo;", "&#8219;", "&bdquo;", "&hellip;", "&trade;", "&#9658;", "&bull;", "&rarr;", "&rArr;", "&hArr;", "&diams;", "&asymp;"
+];
diff --git a/lam/templates/lib/extra/ckeditor/plugins/stylescombo/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/stylescombo/plugin.js
new file mode 100644
index 00000000..f88412c4
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/stylescombo/plugin.js
@@ -0,0 +1,188 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	'use strict';
+
+	CKEDITOR.plugins.add( 'stylescombo', {
+		requires: 'richcombo',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+
+		init: function( editor ) {
+			var config = editor.config,
+				lang = editor.lang.stylescombo,
+				styles = {},
+				stylesList = [],
+				combo,
+				allowedContent = [];
+
+			editor.on( 'stylesSet', function( evt ) {
+				var stylesDefinitions = evt.data.styles;
+
+				if ( !stylesDefinitions )
+					return;
+
+				var style, styleName;
+
+				// Put all styles into an Array.
+				for ( var i = 0, count = stylesDefinitions.length; i < count; i++ ) {
+					var styleDefinition = stylesDefinitions[ i ];
+
+					if ( editor.blockless && ( styleDefinition.element in CKEDITOR.dtd.$block ) )
+						continue;
+
+					styleName = styleDefinition.name;
+
+					style = new CKEDITOR.style( styleDefinition );
+
+					if ( !editor.filter.customConfig || editor.filter.check( style ) ) {
+						style._name = styleName;
+						style._.enterMode = config.enterMode;
+
+						// Weight is used to sort styles (#9029).
+						style._.weight = i + ( style.type == CKEDITOR.STYLE_OBJECT ? 1 : style.type == CKEDITOR.STYLE_BLOCK ? 2 : 3 ) * 1000;
+
+						styles[ styleName ] = style;
+						stylesList.push( style );
+						allowedContent.push( style );
+					}
+				}
+
+				// Sorts the Array, so the styles get grouped by type in proper order (#9029).
+				stylesList.sort( function( styleA, styleB ) { return styleA._.weight - styleB._.weight; } );
+			} );
+
+			editor.ui.addRichCombo( 'Styles', {
+				label: lang.label,
+				title: lang.panelTitle,
+				toolbar: 'styles,10',
+				allowedContent: allowedContent,
+
+				panel: {
+					css: [ CKEDITOR.skin.getPath( 'editor' ) ].concat( config.contentsCss ),
+					multiSelect: true,
+					attributes: { 'aria-label': lang.panelTitle }
+				},
+
+				init: function() {
+					var style, styleName, lastType, type, i, count;
+
+					// Loop over the Array, adding all items to the
+					// combo.
+					for ( i = 0, count = stylesList.length; i < count; i++ ) {
+						style = stylesList[ i ];
+						styleName = style._name;
+						type = style.type;
+
+						if ( type != lastType ) {
+							this.startGroup( lang[ 'panelTitle' + String( type ) ] );
+							lastType = type;
+						}
+
+						this.add( styleName, style.type == CKEDITOR.STYLE_OBJECT ? styleName : style.buildPreview(), styleName );
+					}
+
+					this.commit();
+				},
+
+				onClick: function( value ) {
+					editor.focus();
+					editor.fire( 'saveSnapshot' );
+
+					var style = styles[ value ],
+						elementPath = editor.elementPath();
+
+					editor[ style.checkActive( elementPath ) ? 'removeStyle' : 'applyStyle' ]( style );
+					editor.fire( 'saveSnapshot' );
+				},
+
+				onRender: function() {
+					editor.on( 'selectionChange', function( ev ) {
+						var currentValue = this.getValue(),
+							elementPath = ev.data.path,
+							elements = elementPath.elements;
+
+						// For each element into the elements path.
+						for ( var i = 0, count = elements.length, element; i < count; i++ ) {
+							element = elements[ i ];
+
+							// Check if the element is removable by any of
+							// the styles.
+							for ( var value in styles ) {
+								if ( styles[ value ].checkElementRemovable( element, true ) ) {
+									if ( value != currentValue )
+										this.setValue( value );
+									return;
+								}
+							}
+						}
+
+						// If no styles match, just empty it.
+						this.setValue( '' );
+					}, this );
+				},
+
+				onOpen: function() {
+					var selection = editor.getSelection(),
+						element = selection.getSelectedElement(),
+						elementPath = editor.elementPath( element ),
+						counter = [ 0, 0, 0, 0 ];
+
+					this.showAll();
+					this.unmarkAll();
+					for ( var name in styles ) {
+						var style = styles[ name ],
+							type = style.type;
+
+						if ( style.checkApplicable( elementPath, editor.activeFilter ) )
+							counter[ type ]++;
+						else
+							this.hideItem( name );
+
+						if ( style.checkActive( elementPath ) )
+							this.mark( name );
+					}
+
+					if ( !counter[ CKEDITOR.STYLE_BLOCK ] )
+						this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_BLOCK ) ] );
+
+					if ( !counter[ CKEDITOR.STYLE_INLINE ] )
+						this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_INLINE ) ] );
+
+					if ( !counter[ CKEDITOR.STYLE_OBJECT ] )
+						this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_OBJECT ) ] );
+				},
+
+				refresh: function() {
+					var elementPath = editor.elementPath();
+
+					if ( !elementPath )
+						return;
+
+					for ( var name in styles ) {
+						var style = styles[ name ];
+
+						if ( style.checkApplicable( elementPath, editor.activeFilter ) )
+							return;
+					}
+					this.setState( CKEDITOR.TRISTATE_DISABLED );
+				},
+
+				// Force a reload of the data
+				reset: function() {
+					if ( combo ) {
+						delete combo._.panel;
+						delete combo._.list;
+						combo._.committed = 0;
+						combo._.items = {};
+						combo._.state = CKEDITOR.TRISTATE_OFF;
+					}
+					styles = {};
+					stylesList = [];
+				}
+			} );
+		}
+	} );
+} )();
diff --git a/lam/templates/lib/extra/ckeditor/plugins/tab/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/tab/plugin.js
new file mode 100644
index 00000000..a0a24e51
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/tab/plugin.js
@@ -0,0 +1,301 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	var meta = {
+		editorFocus: false,
+		modes: { wysiwyg: 1, source: 1 }
+	};
+
+	var blurCommand = {
+		exec: function( editor ) {
+			editor.container.focusNext( true, editor.tabIndex );
+		}
+	};
+
+	var blurBackCommand = {
+		exec: function( editor ) {
+			editor.container.focusPrevious( true, editor.tabIndex );
+		}
+	};
+
+	function selectNextCellCommand( backward ) {
+		return {
+			editorFocus: false,
+			canUndo: false,
+			modes: { wysiwyg: 1 },
+			exec: function( editor ) {
+				if ( editor.editable().hasFocus ) {
+					var sel = editor.getSelection(),
+						path = new CKEDITOR.dom.elementPath( sel.getCommonAncestor(), sel.root ),
+						cell;
+
+					if ( ( cell = path.contains( { td: 1, th: 1 }, 1 ) ) ) {
+						var resultRange = editor.createRange(),
+							next = CKEDITOR.tools.tryThese( function() {
+								var row = cell.getParent(),
+									next = row.$.cells[ cell.$.cellIndex + ( backward ? -1 : 1 ) ];
+
+								// Invalid any empty value.
+								next.parentNode.parentNode;
+								return next;
+							}, function() {
+								var row = cell.getParent(),
+									table = row.getAscendant( 'table' ),
+									nextRow = table.$.rows[ row.$.rowIndex + ( backward ? -1 : 1 ) ];
+
+								return nextRow.cells[ backward ? nextRow.cells.length - 1 : 0 ];
+							} );
+
+						// Clone one more row at the end of table and select the first newly established cell.
+						if ( !( next || backward ) ) {
+							var table = cell.getAscendant( 'table' ).$,
+								cells = cell.getParent().$.cells;
+
+							var newRow = new CKEDITOR.dom.element( table.insertRow( -1 ), editor.document );
+
+							for ( var i = 0, count = cells.length; i < count; i++ ) {
+								var newCell = newRow.append( new CKEDITOR.dom.element( cells[ i ], editor.document ).clone( false, false ) );
+								newCell.appendBogus();
+							}
+
+							resultRange.moveToElementEditStart( newRow );
+						} else if ( next ) {
+							next = new CKEDITOR.dom.element( next );
+							resultRange.moveToElementEditStart( next );
+							// Avoid selecting empty block makes the cursor blind.
+							if ( !( resultRange.checkStartOfBlock() && resultRange.checkEndOfBlock() ) )
+								resultRange.selectNodeContents( next );
+						} else
+							return true;
+
+						resultRange.select( true );
+						return true;
+					}
+				}
+
+				return false;
+			}
+		};
+	}
+
+	CKEDITOR.plugins.add( 'tab', {
+		init: function( editor ) {
+			var tabTools = editor.config.enableTabKeyTools !== false,
+				tabSpaces = editor.config.tabSpaces || 0,
+				tabText = '';
+
+			while ( tabSpaces-- )
+				tabText += '\xa0';
+
+			if ( tabText ) {
+				editor.on( 'key', function( ev ) {
+					if ( ev.data.keyCode == 9 ) // TAB
+					{
+						editor.insertHtml( tabText );
+						ev.cancel();
+					}
+				} );
+			}
+
+			if ( tabTools ) {
+				editor.on( 'key', function( ev ) {
+					if ( ev.data.keyCode == 9 && editor.execCommand( 'selectNextCell' ) || // TAB
+					ev.data.keyCode == ( CKEDITOR.SHIFT + 9 ) && editor.execCommand( 'selectPreviousCell' ) ) // SHIFT+TAB
+					ev.cancel();
+				} );
+			}
+
+			editor.addCommand( 'blur', CKEDITOR.tools.extend( blurCommand, meta ) );
+			editor.addCommand( 'blurBack', CKEDITOR.tools.extend( blurBackCommand, meta ) );
+			editor.addCommand( 'selectNextCell', selectNextCellCommand() );
+			editor.addCommand( 'selectPreviousCell', selectNextCellCommand( true ) );
+		}
+	} );
+} )();
+
+/**
+ * Moves the UI focus to the element following this element in the tabindex order.
+ *
+ *		var element = CKEDITOR.document.getById( 'example' );
+ *		element.focusNext();
+ *
+ * @param {Boolean} [ignoreChildren=false]
+ * @param {Number} [indexToUse]
+ * @member CKEDITOR.dom.element
+ */
+CKEDITOR.dom.element.prototype.focusNext = function( ignoreChildren, indexToUse ) {
+	var $ = this.$,
+		curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
+		passedCurrent, enteredCurrent, elected, electedTabIndex, element, elementTabIndex;
+
+	if ( curTabIndex <= 0 ) {
+		// If this element has tabindex <= 0 then we must simply look for any
+		// element following it containing tabindex=0.
+
+		element = this.getNextSourceNode( ignoreChildren, CKEDITOR.NODE_ELEMENT );
+
+		while ( element ) {
+			if ( element.isVisible() && element.getTabIndex() === 0 ) {
+				elected = element;
+				break;
+			}
+
+			element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT );
+		}
+	} else {
+		// If this element has tabindex > 0 then we must look for:
+		//		1. An element following this element with the same tabindex.
+		//		2. The first element in source other with the lowest tabindex
+		//		   that is higher than this element tabindex.
+		//		3. The first element with tabindex=0.
+
+		element = this.getDocument().getBody().getFirst();
+
+		while ( ( element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) ) {
+			if ( !passedCurrent ) {
+				if ( !enteredCurrent && element.equals( this ) ) {
+					enteredCurrent = true;
+
+					// Ignore this element, if required.
+					if ( ignoreChildren ) {
+						if ( !( element = element.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
+							break;
+						passedCurrent = 1;
+					}
+				} else if ( enteredCurrent && !this.contains( element ) )
+					passedCurrent = 1;
+			}
+
+			if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
+				continue;
+
+			if ( passedCurrent && elementTabIndex == curTabIndex ) {
+				elected = element;
+				break;
+			}
+
+			if ( elementTabIndex > curTabIndex && ( !elected || !electedTabIndex || elementTabIndex < electedTabIndex ) ) {
+				elected = element;
+				electedTabIndex = elementTabIndex;
+			} else if ( !elected && elementTabIndex === 0 ) {
+				elected = element;
+				electedTabIndex = elementTabIndex;
+			}
+		}
+	}
+
+	if ( elected )
+		elected.focus();
+};
+
+/**
+ * Moves the UI focus to the element before this element in the tabindex order.
+ *
+ *		var element = CKEDITOR.document.getById( 'example' );
+ *		element.focusPrevious();
+ *
+ * @param {Boolean} [ignoreChildren=false]
+ * @param {Number} [indexToUse]
+ * @member CKEDITOR.dom.element
+ */
+CKEDITOR.dom.element.prototype.focusPrevious = function( ignoreChildren, indexToUse ) {
+	var $ = this.$,
+		curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
+		passedCurrent, enteredCurrent, elected,
+		electedTabIndex = 0,
+		elementTabIndex;
+
+	var element = this.getDocument().getBody().getLast();
+
+	while ( ( element = element.getPreviousSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) ) {
+		if ( !passedCurrent ) {
+			if ( !enteredCurrent && element.equals( this ) ) {
+				enteredCurrent = true;
+
+				// Ignore this element, if required.
+				if ( ignoreChildren ) {
+					if ( !( element = element.getPreviousSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
+						break;
+					passedCurrent = 1;
+				}
+			} else if ( enteredCurrent && !this.contains( element ) )
+				passedCurrent = 1;
+		}
+
+		if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
+			continue;
+
+		if ( curTabIndex <= 0 ) {
+			// If this element has tabindex <= 0 then we must look for:
+			//		1. An element before this one containing tabindex=0.
+			//		2. The last element with the highest tabindex.
+
+			if ( passedCurrent && elementTabIndex === 0 ) {
+				elected = element;
+				break;
+			}
+
+			if ( elementTabIndex > electedTabIndex ) {
+				elected = element;
+				electedTabIndex = elementTabIndex;
+			}
+		} else {
+			// If this element has tabindex > 0 we must look for:
+			//		1. An element preceeding this one, with the same tabindex.
+			//		2. The last element in source other with the highest tabindex
+			//		   that is lower than this element tabindex.
+
+			if ( passedCurrent && elementTabIndex == curTabIndex ) {
+				elected = element;
+				break;
+			}
+
+			if ( elementTabIndex < curTabIndex && ( !elected || elementTabIndex > electedTabIndex ) ) {
+				elected = element;
+				electedTabIndex = elementTabIndex;
+			}
+		}
+	}
+
+	if ( elected )
+		elected.focus();
+};
+
+/**
+ * Intructs the editor to add a number of spaces (`&nbsp;`) to the text when
+ * hitting the *TAB* key. If set to zero, the *TAB* key will be used to move the
+ * cursor focus to the next element in the page, out of the editor focus.
+ *
+ *		config.tabSpaces = 4;
+ *
+ * @cfg {Number} [tabSpaces=0]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Allow context-sensitive tab key behaviors, including the following scenarios:
+ *
+ * When selection is anchored inside **table cells**:
+ *
+ * * If *TAB* is pressed, select the contents of the "next" cell. If in the last
+ *     cell in the table, add a new row to it and focus its first cell.
+ * * If *SHIFT+TAB* is pressed, select the contents of the "previous" cell.
+ *     Do nothing when it's in the first cell.
+ *
+ * Example:
+ *
+ *		config.enableTabKeyTools = false;
+ *
+ * @cfg {Boolean} [enableTabKeyTools=true]
+ * @member CKEDITOR.config
+ */
+
+// If the TAB key is not supposed to be enabled for navigation, the following
+// settings could be used alternatively:
+// config.keystrokes.push(
+//	[ CKEDITOR.ALT + 38 /*Arrow Up*/, 'selectPreviousCell' ],
+//	[ CKEDITOR.ALT + 40 /*Arrow Down*/, 'selectNextCell' ]
+// );
diff --git a/lam/templates/lib/extra/ckeditor/plugins/table/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/table/plugin.js
new file mode 100644
index 00000000..553e9c49
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/table/plugin.js
@@ -0,0 +1,106 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+CKEDITOR.plugins.add( 'table', {
+	requires: 'dialog',
+	lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+	icons: 'table', // %REMOVE_LINE_CORE%
+	hidpi: true, // %REMOVE_LINE_CORE%
+	init: function( editor ) {
+		if ( editor.blockless )
+			return;
+
+		var table = CKEDITOR.plugins.table,
+			lang = editor.lang.table;
+
+		editor.addCommand( 'table', new CKEDITOR.dialogCommand( 'table', {
+			context: 'table',
+			allowedContent: 'table{width,height}[align,border,cellpadding,cellspacing,summary];' +
+				'caption tbody thead tfoot;' +
+				'th td tr[scope];' +
+				( editor.plugins.dialogadvtab ? 'table' + editor.plugins.dialogadvtab.allowedContent() : '' ),
+			requiredContent: 'table',
+			contentTransformations: [
+				[ 'table{width}: sizeToStyle', 'table[width]: sizeToAttribute' ]
+			]
+		} ) );
+
+		function createDef( def ) {
+			return CKEDITOR.tools.extend( def || {}, {
+				contextSensitive: 1,
+				refresh: function( editor, path ) {
+					this.setState( path.contains( 'table', 1 ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+				}
+			} );
+		}
+
+		editor.addCommand( 'tableProperties', new CKEDITOR.dialogCommand( 'tableProperties', createDef() ) );
+		editor.addCommand( 'tableDelete', createDef( {
+			exec: function( editor ) {
+				var path = editor.elementPath(),
+					table = path.contains( 'table', 1 );
+
+				if ( !table )
+					return;
+
+				// If the table's parent has only one child remove it as well (unless it's the body or a table cell) (#5416, #6289)
+				var parent = table.getParent();
+				if ( parent.getChildCount() == 1 && !parent.is( 'body', 'td', 'th' ) )
+					table = parent;
+
+				var range = editor.createRange();
+				range.moveToPosition( table, CKEDITOR.POSITION_BEFORE_START );
+				table.remove();
+				range.select();
+			}
+		} ) );
+
+		editor.ui.addButton && editor.ui.addButton( 'Table', {
+			label: lang.toolbar,
+			command: 'table',
+			toolbar: 'insert,30'
+		} );
+
+		CKEDITOR.dialog.add( 'table', this.path + 'dialogs/table.js' );
+		CKEDITOR.dialog.add( 'tableProperties', this.path + 'dialogs/table.js' );
+
+		// If the "menu" plugin is loaded, register the menu items.
+		if ( editor.addMenuItems ) {
+			editor.addMenuItems( {
+				table: {
+					label: lang.menu,
+					command: 'tableProperties',
+					group: 'table',
+					order: 5
+				},
+
+				tabledelete: {
+					label: lang.deleteTable,
+					command: 'tableDelete',
+					group: 'table',
+					order: 1
+				}
+			} );
+		}
+
+		editor.on( 'doubleclick', function( evt ) {
+			var element = evt.data.element;
+
+			if ( element.is( 'table' ) )
+				evt.data.dialog = 'tableProperties';
+		} );
+
+		// If the "contextmenu" plugin is loaded, register the listeners.
+		if ( editor.contextMenu ) {
+			editor.contextMenu.addListener( function() {
+				// menu item state is resolved on commands.
+				return {
+					tabledelete: CKEDITOR.TRISTATE_OFF,
+					table: CKEDITOR.TRISTATE_OFF
+				};
+			} );
+		}
+	}
+} );
diff --git a/lam/templates/lib/extra/ckeditor/plugins/tabletools/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/tabletools/plugin.js
new file mode 100644
index 00000000..2d4039b7
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/tabletools/plugin.js
@@ -0,0 +1,1037 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+( function() {
+	var cellNodeRegex = /^(?:td|th)$/;
+
+	function getSelectedCells( selection ) {
+		var ranges = selection.getRanges();
+		var retval = [];
+		var database = {};
+
+		function moveOutOfCellGuard( node ) {
+			// Apply to the first cell only.
+			if ( retval.length > 0 )
+				return;
+
+			// If we are exiting from the first </td>, then the td should definitely be
+			// included.
+			if ( node.type == CKEDITOR.NODE_ELEMENT && cellNodeRegex.test( node.getName() ) && !node.getCustomData( 'selected_cell' ) ) {
+				CKEDITOR.dom.element.setMarker( database, node, 'selected_cell', true );
+				retval.push( node );
+			}
+		}
+
+		for ( var i = 0; i < ranges.length; i++ ) {
+			var range = ranges[ i ];
+
+			if ( range.collapsed ) {
+				// Walker does not handle collapsed ranges yet - fall back to old API.
+				var startNode = range.getCommonAncestor();
+				var nearestCell = startNode.getAscendant( 'td', true ) || startNode.getAscendant( 'th', true );
+				if ( nearestCell )
+					retval.push( nearestCell );
+			} else {
+				var walker = new CKEDITOR.dom.walker( range );
+				var node;
+				walker.guard = moveOutOfCellGuard;
+
+				while ( ( node = walker.next() ) ) {
+					// If may be possible for us to have a range like this:
+					// <td>^1</td><td>^2</td>
+					// The 2nd td shouldn't be included.
+					//
+					// So we have to take care to include a td we've entered only when we've
+					// walked into its children.
+
+					if ( node.type != CKEDITOR.NODE_ELEMENT || !node.is( CKEDITOR.dtd.table ) ) {
+						var parent = node.getAscendant( 'td', true ) || node.getAscendant( 'th', true );
+						if ( parent && !parent.getCustomData( 'selected_cell' ) ) {
+							CKEDITOR.dom.element.setMarker( database, parent, 'selected_cell', true );
+							retval.push( parent );
+						}
+					}
+				}
+			}
+		}
+
+		CKEDITOR.dom.element.clearAllMarkers( database );
+
+		return retval;
+	}
+
+	function getFocusElementAfterDelCells( cellsToDelete ) {
+		var i = 0,
+			last = cellsToDelete.length - 1,
+			database = {},
+			cell, focusedCell, tr;
+
+		while ( ( cell = cellsToDelete[ i++ ] ) )
+			CKEDITOR.dom.element.setMarker( database, cell, 'delete_cell', true );
+
+		// 1.first we check left or right side focusable cell row by row;
+		i = 0;
+		while ( ( cell = cellsToDelete[ i++ ] ) ) {
+			if ( ( focusedCell = cell.getPrevious() ) && !focusedCell.getCustomData( 'delete_cell' ) || ( focusedCell = cell.getNext() ) && !focusedCell.getCustomData( 'delete_cell' ) ) {
+				CKEDITOR.dom.element.clearAllMarkers( database );
+				return focusedCell;
+			}
+		}
+
+		CKEDITOR.dom.element.clearAllMarkers( database );
+
+		// 2. then we check the toppest row (outside the selection area square) focusable cell
+		tr = cellsToDelete[ 0 ].getParent();
+		if ( ( tr = tr.getPrevious() ) )
+			return tr.getLast();
+
+		// 3. last we check the lowerest  row focusable cell
+		tr = cellsToDelete[ last ].getParent();
+		if ( ( tr = tr.getNext() ) )
+			return tr.getChild( 0 );
+
+		return null;
+	}
+
+	function insertRow( selection, insertBefore ) {
+		var cells = getSelectedCells( selection ),
+			firstCell = cells[ 0 ],
+			table = firstCell.getAscendant( 'table' ),
+			doc = firstCell.getDocument(),
+			startRow = cells[ 0 ].getParent(),
+			startRowIndex = startRow.$.rowIndex,
+			lastCell = cells[ cells.length - 1 ],
+			endRowIndex = lastCell.getParent().$.rowIndex + lastCell.$.rowSpan - 1,
+			endRow = new CKEDITOR.dom.element( table.$.rows[ endRowIndex ] ),
+			rowIndex = insertBefore ? startRowIndex : endRowIndex,
+			row = insertBefore ? startRow : endRow;
+
+		var map = CKEDITOR.tools.buildTableMap( table ),
+			cloneRow = map[ rowIndex ],
+			nextRow = insertBefore ? map[ rowIndex - 1 ] : map[ rowIndex + 1 ],
+			width = map[ 0 ].length;
+
+		var newRow = doc.createElement( 'tr' );
+		for ( var i = 0; cloneRow[ i ] && i < width; i++ ) {
+			var cell;
+			// Check whether there's a spanning row here, do not break it.
+			if ( cloneRow[ i ].rowSpan > 1 && nextRow && cloneRow[ i ] == nextRow[ i ] ) {
+				cell = cloneRow[ i ];
+				cell.rowSpan += 1;
+			} else {
+				cell = new CKEDITOR.dom.element( cloneRow[ i ] ).clone();
+				cell.removeAttribute( 'rowSpan' );
+				cell.appendBogus();
+				newRow.append( cell );
+				cell = cell.$;
+			}
+
+			i += cell.colSpan - 1;
+		}
+
+		insertBefore ? newRow.insertBefore( row ) : newRow.insertAfter( row );
+	}
+
+	function deleteRows( selectionOrRow ) {
+		if ( selectionOrRow instanceof CKEDITOR.dom.selection ) {
+			var cells = getSelectedCells( selectionOrRow ),
+				firstCell = cells[ 0 ],
+				table = firstCell.getAscendant( 'table' ),
+				map = CKEDITOR.tools.buildTableMap( table ),
+				startRow = cells[ 0 ].getParent(),
+				startRowIndex = startRow.$.rowIndex,
+				lastCell = cells[ cells.length - 1 ],
+				endRowIndex = lastCell.getParent().$.rowIndex + lastCell.$.rowSpan - 1,
+				rowsToDelete = [];
+
+			// Delete cell or reduce cell spans by checking through the table map.
+			for ( var i = startRowIndex; i <= endRowIndex; i++ ) {
+				var mapRow = map[ i ],
+					row = new CKEDITOR.dom.element( table.$.rows[ i ] );
+
+				for ( var j = 0; j < mapRow.length; j++ ) {
+					var cell = new CKEDITOR.dom.element( mapRow[ j ] ),
+						cellRowIndex = cell.getParent().$.rowIndex;
+
+					if ( cell.$.rowSpan == 1 )
+						cell.remove();
+					// Row spanned cell.
+					else {
+						// Span row of the cell, reduce spanning.
+						cell.$.rowSpan -= 1;
+						// Root row of the cell, root cell to next row.
+						if ( cellRowIndex == i ) {
+							var nextMapRow = map[ i + 1 ];
+							nextMapRow[ j - 1 ] ? cell.insertAfter( new CKEDITOR.dom.element( nextMapRow[ j - 1 ] ) ) : new CKEDITOR.dom.element( table.$.rows[ i + 1 ] ).append( cell, 1 );
+						}
+					}
+
+					j += cell.$.colSpan - 1;
+				}
+
+				rowsToDelete.push( row );
+			}
+
+			var rows = table.$.rows;
+
+			// Where to put the cursor after rows been deleted?
+			// 1. Into next sibling row if any;
+			// 2. Into previous sibling row if any;
+			// 3. Into table's parent element if it's the very last row.
+			var cursorPosition = new CKEDITOR.dom.element( rows[ endRowIndex + 1 ] || ( startRowIndex > 0 ? rows[ startRowIndex - 1 ] : null ) || table.$.parentNode );
+
+			for ( i = rowsToDelete.length; i >= 0; i-- )
+				deleteRows( rowsToDelete[ i ] );
+
+			return cursorPosition;
+		} else if ( selectionOrRow instanceof CKEDITOR.dom.element ) {
+			table = selectionOrRow.getAscendant( 'table' );
+
+			if ( table.$.rows.length == 1 )
+				table.remove();
+			else
+				selectionOrRow.remove();
+		}
+
+		return null;
+	}
+
+	function getCellColIndex( cell, isStart ) {
+		var row = cell.getParent(),
+			rowCells = row.$.cells;
+
+		var colIndex = 0;
+		for ( var i = 0; i < rowCells.length; i++ ) {
+			var mapCell = rowCells[ i ];
+			colIndex += isStart ? 1 : mapCell.colSpan;
+			if ( mapCell == cell.$ )
+				break;
+		}
+
+		return colIndex - 1;
+	}
+
+	function getColumnsIndices( cells, isStart ) {
+		var retval = isStart ? Infinity : 0;
+		for ( var i = 0; i < cells.length; i++ ) {
+			var colIndex = getCellColIndex( cells[ i ], isStart );
+			if ( isStart ? colIndex < retval : colIndex > retval )
+				retval = colIndex;
+		}
+		return retval;
+	}
+
+	function insertColumn( selection, insertBefore ) {
+		var cells = getSelectedCells( selection ),
+			firstCell = cells[ 0 ],
+			table = firstCell.getAscendant( 'table' ),
+			startCol = getColumnsIndices( cells, 1 ),
+			lastCol = getColumnsIndices( cells ),
+			colIndex = insertBefore ? startCol : lastCol;
+
+		var map = CKEDITOR.tools.buildTableMap( table ),
+			cloneCol = [],
+			nextCol = [],
+			height = map.length;
+
+		for ( var i = 0; i < height; i++ ) {
+			cloneCol.push( map[ i ][ colIndex ] );
+			var nextCell = insertBefore ? map[ i ][ colIndex - 1 ] : map[ i ][ colIndex + 1 ];
+			nextCol.push( nextCell );
+		}
+
+		for ( i = 0; i < height; i++ ) {
+			var cell;
+
+			if ( !cloneCol[ i ] )
+				continue;
+
+			// Check whether there's a spanning column here, do not break it.
+			if ( cloneCol[ i ].colSpan > 1 && nextCol[ i ] == cloneCol[ i ] ) {
+				cell = cloneCol[ i ];
+				cell.colSpan += 1;
+			} else {
+				cell = new CKEDITOR.dom.element( cloneCol[ i ] ).clone();
+				cell.removeAttribute( 'colSpan' );
+				cell.appendBogus();
+				cell[ insertBefore ? 'insertBefore' : 'insertAfter' ].call( cell, new CKEDITOR.dom.element( cloneCol[ i ] ) );
+				cell = cell.$;
+			}
+
+			i += cell.rowSpan - 1;
+		}
+	}
+
+	function deleteColumns( selectionOrCell ) {
+		var cells = getSelectedCells( selectionOrCell ),
+			firstCell = cells[ 0 ],
+			lastCell = cells[ cells.length - 1 ],
+			table = firstCell.getAscendant( 'table' ),
+			map = CKEDITOR.tools.buildTableMap( table ),
+			startColIndex, endColIndex,
+			rowsToDelete = [];
+
+		// Figure out selected cells' column indices.
+		for ( var i = 0, rows = map.length; i < rows; i++ ) {
+			for ( var j = 0, cols = map[ i ].length; j < cols; j++ ) {
+				if ( map[ i ][ j ] == firstCell.$ )
+					startColIndex = j;
+				if ( map[ i ][ j ] == lastCell.$ )
+					endColIndex = j;
+			}
+		}
+
+		// Delete cell or reduce cell spans by checking through the table map.
+		for ( i = startColIndex; i <= endColIndex; i++ ) {
+			for ( j = 0; j < map.length; j++ ) {
+				var mapRow = map[ j ],
+					row = new CKEDITOR.dom.element( table.$.rows[ j ] ),
+					cell = new CKEDITOR.dom.element( mapRow[ i ] );
+
+				if ( cell.$ ) {
+					if ( cell.$.colSpan == 1 )
+						cell.remove();
+					// Reduce the col spans.
+					else
+						cell.$.colSpan -= 1;
+
+					j += cell.$.rowSpan - 1;
+
+					if ( !row.$.cells.length )
+						rowsToDelete.push( row );
+				}
+			}
+		}
+
+		var firstRowCells = table.$.rows[ 0 ] && table.$.rows[ 0 ].cells;
+
+		// Where to put the cursor after columns been deleted?
+		// 1. Into next cell of the first row if any;
+		// 2. Into previous cell of the first row if any;
+		// 3. Into table's parent element;
+		var cursorPosition = new CKEDITOR.dom.element( firstRowCells[ startColIndex ] || ( startColIndex ? firstRowCells[ startColIndex - 1 ] : table.$.parentNode ) );
+
+		// Delete table rows only if all columns are gone (do not remove empty row).
+		if ( rowsToDelete.length == rows )
+			table.remove();
+
+		return cursorPosition;
+	}
+
+	function getFocusElementAfterDelCols( cells ) {
+		var cellIndexList = [],
+			table = cells[ 0 ] && cells[ 0 ].getAscendant( 'table' ),
+			i, length, targetIndex, targetCell;
+
+		// get the cellIndex list of delete cells
+		for ( i = 0, length = cells.length; i < length; i++ )
+			cellIndexList.push( cells[ i ].$.cellIndex );
+
+		// get the focusable column index
+		cellIndexList.sort();
+		for ( i = 1, length = cellIndexList.length; i < length; i++ ) {
+			if ( cellIndexList[ i ] - cellIndexList[ i - 1 ] > 1 ) {
+				targetIndex = cellIndexList[ i - 1 ] + 1;
+				break;
+			}
+		}
+
+		if ( !targetIndex )
+			targetIndex = cellIndexList[ 0 ] > 0 ? ( cellIndexList[ 0 ] - 1 ) : ( cellIndexList[ cellIndexList.length - 1 ] + 1 );
+
+		// scan row by row to get the target cell
+		var rows = table.$.rows;
+		for ( i = 0, length = rows.length; i < length; i++ ) {
+			targetCell = rows[ i ].cells[ targetIndex ];
+			if ( targetCell )
+				break;
+		}
+
+		return targetCell ? new CKEDITOR.dom.element( targetCell ) : table.getPrevious();
+	}
+
+	function insertCell( selection, insertBefore ) {
+		var startElement = selection.getStartElement();
+		var cell = startElement.getAscendant( 'td', 1 ) || startElement.getAscendant( 'th', 1 );
+
+		if ( !cell )
+			return;
+
+		// Create the new cell element to be added.
+		var newCell = cell.clone();
+		newCell.appendBogus();
+
+		if ( insertBefore )
+			newCell.insertBefore( cell );
+		else
+			newCell.insertAfter( cell );
+	}
+
+	function deleteCells( selectionOrCell ) {
+		if ( selectionOrCell instanceof CKEDITOR.dom.selection ) {
+			var cellsToDelete = getSelectedCells( selectionOrCell );
+			var table = cellsToDelete[ 0 ] && cellsToDelete[ 0 ].getAscendant( 'table' );
+			var cellToFocus = getFocusElementAfterDelCells( cellsToDelete );
+
+			for ( var i = cellsToDelete.length - 1; i >= 0; i-- )
+				deleteCells( cellsToDelete[ i ] );
+
+			if ( cellToFocus )
+				placeCursorInCell( cellToFocus, true );
+			else if ( table )
+				table.remove();
+		} else if ( selectionOrCell instanceof CKEDITOR.dom.element ) {
+			var tr = selectionOrCell.getParent();
+			if ( tr.getChildCount() == 1 )
+				tr.remove();
+			else
+				selectionOrCell.remove();
+		}
+	}
+
+	// Remove filler at end and empty spaces around the cell content.
+	function trimCell( cell ) {
+		var bogus = cell.getBogus();
+		bogus && bogus.remove();
+		cell.trim();
+	}
+
+	function placeCursorInCell( cell, placeAtEnd ) {
+		var docInner = cell.getDocument(),
+			docOuter = CKEDITOR.document;
+
+		// Fixing "Unspecified error" thrown in IE10 by resetting
+		// selection the dirty and shameful way (#10308).
+		// We can not apply this hack to IE8 because
+		// it causes error (#11058).
+		if ( CKEDITOR.env.ie && CKEDITOR.env.version == 10 ) {
+			docOuter.focus();
+			docInner.focus();
+		}
+
+		var range = new CKEDITOR.dom.range( docInner );
+		if ( !range[ 'moveToElementEdit' + ( placeAtEnd ? 'End' : 'Start' ) ]( cell ) ) {
+			range.selectNodeContents( cell );
+			range.collapse( placeAtEnd ? false : true );
+		}
+		range.select( true );
+	}
+
+	function cellInRow( tableMap, rowIndex, cell ) {
+		var oRow = tableMap[ rowIndex ];
+		if ( typeof cell == 'undefined' )
+			return oRow;
+
+		for ( var c = 0; oRow && c < oRow.length; c++ ) {
+			if ( cell.is && oRow[ c ] == cell.$ )
+				return c;
+			else if ( c == cell )
+				return new CKEDITOR.dom.element( oRow[ c ] );
+		}
+		return cell.is ? -1 : null;
+	}
+
+	function cellInCol( tableMap, colIndex ) {
+		var oCol = [];
+		for ( var r = 0; r < tableMap.length; r++ ) {
+			var row = tableMap[ r ];
+			oCol.push( row[ colIndex ] );
+
+			// Avoid adding duplicate cells.
+			if ( row[ colIndex ].rowSpan > 1 )
+				r += row[ colIndex ].rowSpan - 1;
+		}
+		return oCol;
+	}
+
+	function mergeCells( selection, mergeDirection, isDetect ) {
+		var cells = getSelectedCells( selection );
+
+		// Invalid merge request if:
+		// 1. In batch mode despite that less than two selected.
+		// 2. In solo mode while not exactly only one selected.
+		// 3. Cells distributed in different table groups (e.g. from both thead and tbody).
+		var commonAncestor;
+		if ( ( mergeDirection ? cells.length != 1 : cells.length < 2 ) || ( commonAncestor = selection.getCommonAncestor() ) && commonAncestor.type == CKEDITOR.NODE_ELEMENT && commonAncestor.is( 'table' ) )
+			return false;
+
+		var cell,
+			firstCell = cells[ 0 ],
+			table = firstCell.getAscendant( 'table' ),
+			map = CKEDITOR.tools.buildTableMap( table ),
+			mapHeight = map.length,
+			mapWidth = map[ 0 ].length,
+			startRow = firstCell.getParent().$.rowIndex,
+			startColumn = cellInRow( map, startRow, firstCell );
+
+		if ( mergeDirection ) {
+			var targetCell;
+			try {
+				var rowspan = parseInt( firstCell.getAttribute( 'rowspan' ), 10 ) || 1;
+				var colspan = parseInt( firstCell.getAttribute( 'colspan' ), 10 ) || 1;
+
+				targetCell = map[ mergeDirection == 'up' ? ( startRow - rowspan ) : mergeDirection == 'down' ? ( startRow + rowspan ) : startRow ][
+					mergeDirection == 'left' ?
+						( startColumn - colspan ) :
+					mergeDirection == 'right' ? ( startColumn + colspan ) : startColumn ];
+
+			} catch ( er ) {
+				return false;
+			}
+
+			// 1. No cell could be merged.
+			// 2. Same cell actually.
+			if ( !targetCell || firstCell.$ == targetCell )
+				return false;
+
+			// Sort in map order regardless of the DOM sequence.
+			cells[ ( mergeDirection == 'up' || mergeDirection == 'left' ) ? 'unshift' : 'push' ]( new CKEDITOR.dom.element( targetCell ) );
+		}
+
+		// Start from here are merging way ignorance (merge up/right, batch merge).
+		var doc = firstCell.getDocument(),
+			lastRowIndex = startRow,
+			totalRowSpan = 0,
+			totalColSpan = 0,
+			// Use a documentFragment as buffer when appending cell contents.
+			frag = !isDetect && new CKEDITOR.dom.documentFragment( doc ),
+			dimension = 0;
+
+		for ( var i = 0; i < cells.length; i++ ) {
+			cell = cells[ i ];
+
+			var tr = cell.getParent(),
+				cellFirstChild = cell.getFirst(),
+				colSpan = cell.$.colSpan,
+				rowSpan = cell.$.rowSpan,
+				rowIndex = tr.$.rowIndex,
+				colIndex = cellInRow( map, rowIndex, cell );
+
+			// Accumulated the actual places taken by all selected cells.
+			dimension += colSpan * rowSpan;
+			// Accumulated the maximum virtual spans from column and row.
+			totalColSpan = Math.max( totalColSpan, colIndex - startColumn + colSpan );
+			totalRowSpan = Math.max( totalRowSpan, rowIndex - startRow + rowSpan );
+
+			if ( !isDetect ) {
+				// Trim all cell fillers and check to remove empty cells.
+				if ( trimCell( cell ), cell.getChildren().count() ) {
+					// Merge vertically cells as two separated paragraphs.
+					if ( rowIndex != lastRowIndex && cellFirstChild && !( cellFirstChild.isBlockBoundary && cellFirstChild.isBlockBoundary( { br: 1 } ) ) ) {
+						var last = frag.getLast( CKEDITOR.dom.walker.whitespaces( true ) );
+						if ( last && !( last.is && last.is( 'br' ) ) )
+							frag.append( 'br' );
+					}
+
+					cell.moveChildren( frag );
+				}
+				i ? cell.remove() : cell.setHtml( '' );
+			}
+			lastRowIndex = rowIndex;
+		}
+
+		if ( !isDetect ) {
+			frag.moveChildren( firstCell );
+
+			firstCell.appendBogus();
+
+			if ( totalColSpan >= mapWidth )
+				firstCell.removeAttribute( 'rowSpan' );
+			else
+				firstCell.$.rowSpan = totalRowSpan;
+
+			if ( totalRowSpan >= mapHeight )
+				firstCell.removeAttribute( 'colSpan' );
+			else
+				firstCell.$.colSpan = totalColSpan;
+
+			// Swip empty <tr> left at the end of table due to the merging.
+			var trs = new CKEDITOR.dom.nodeList( table.$.rows ),
+				count = trs.count();
+
+			for ( i = count - 1; i >= 0; i-- ) {
+				var tailTr = trs.getItem( i );
+				if ( !tailTr.$.cells.length ) {
+					tailTr.remove();
+					count++;
+					continue;
+				}
+			}
+
+			return firstCell;
+		}
+		// Be able to merge cells only if actual dimension of selected
+		// cells equals to the caculated rectangle.
+		else
+			return ( totalRowSpan * totalColSpan ) == dimension;
+	}
+
+	function verticalSplitCell( selection, isDetect ) {
+		var cells = getSelectedCells( selection );
+		if ( cells.length > 1 )
+			return false;
+		else if ( isDetect )
+			return true;
+
+		var cell = cells[ 0 ],
+			tr = cell.getParent(),
+			table = tr.getAscendant( 'table' ),
+			map = CKEDITOR.tools.buildTableMap( table ),
+			rowIndex = tr.$.rowIndex,
+			colIndex = cellInRow( map, rowIndex, cell ),
+			rowSpan = cell.$.rowSpan,
+			newCell, newRowSpan, newCellRowSpan, newRowIndex;
+
+		if ( rowSpan > 1 ) {
+			newRowSpan = Math.ceil( rowSpan / 2 );
+			newCellRowSpan = Math.floor( rowSpan / 2 );
+			newRowIndex = rowIndex + newRowSpan;
+			var newCellTr = new CKEDITOR.dom.element( table.$.rows[ newRowIndex ] ),
+				newCellRow = cellInRow( map, newRowIndex ),
+				candidateCell;
+
+			newCell = cell.clone();
+
+			// Figure out where to insert the new cell by checking the vitual row.
+			for ( var c = 0; c < newCellRow.length; c++ ) {
+				candidateCell = newCellRow[ c ];
+				// Catch first cell actually following the column.
+				if ( candidateCell.parentNode == newCellTr.$ && c > colIndex ) {
+					newCell.insertBefore( new CKEDITOR.dom.element( candidateCell ) );
+					break;
+				} else
+					candidateCell = null;
+			}
+
+			// The destination row is empty, append at will.
+			if ( !candidateCell )
+				newCellTr.append( newCell );
+		} else {
+			newCellRowSpan = newRowSpan = 1;
+
+			newCellTr = tr.clone();
+			newCellTr.insertAfter( tr );
+			newCellTr.append( newCell = cell.clone() );
+
+			var cellsInSameRow = cellInRow( map, rowIndex );
+			for ( var i = 0; i < cellsInSameRow.length; i++ )
+				cellsInSameRow[ i ].rowSpan++;
+		}
+
+		newCell.appendBogus();
+
+		cell.$.rowSpan = newRowSpan;
+		newCell.$.rowSpan = newCellRowSpan;
+		if ( newRowSpan == 1 )
+			cell.removeAttribute( 'rowSpan' );
+		if ( newCellRowSpan == 1 )
+			newCell.removeAttribute( 'rowSpan' );
+
+		return newCell;
+	}
+
+	function horizontalSplitCell( selection, isDetect ) {
+		var cells = getSelectedCells( selection );
+		if ( cells.length > 1 )
+			return false;
+		else if ( isDetect )
+			return true;
+
+		var cell = cells[ 0 ],
+			tr = cell.getParent(),
+			table = tr.getAscendant( 'table' ),
+			map = CKEDITOR.tools.buildTableMap( table ),
+			rowIndex = tr.$.rowIndex,
+			colIndex = cellInRow( map, rowIndex, cell ),
+			colSpan = cell.$.colSpan,
+			newCell, newColSpan, newCellColSpan;
+
+		if ( colSpan > 1 ) {
+			newColSpan = Math.ceil( colSpan / 2 );
+			newCellColSpan = Math.floor( colSpan / 2 );
+		} else {
+			newCellColSpan = newColSpan = 1;
+			var cellsInSameCol = cellInCol( map, colIndex );
+			for ( var i = 0; i < cellsInSameCol.length; i++ )
+				cellsInSameCol[ i ].colSpan++;
+		}
+		newCell = cell.clone();
+		newCell.insertAfter( cell );
+		newCell.appendBogus();
+
+		cell.$.colSpan = newColSpan;
+		newCell.$.colSpan = newCellColSpan;
+		if ( newColSpan == 1 )
+			cell.removeAttribute( 'colSpan' );
+		if ( newCellColSpan == 1 )
+			newCell.removeAttribute( 'colSpan' );
+
+		return newCell;
+	}
+	// Context menu on table caption incorrect (#3834)
+	var contextMenuTags = { thead: 1, tbody: 1, tfoot: 1, td: 1, tr: 1, th: 1 };
+
+	CKEDITOR.plugins.tabletools = {
+		requires: 'table,dialog,contextmenu',
+		init: function( editor ) {
+			var lang = editor.lang.table;
+
+			function createDef( def ) {
+				return CKEDITOR.tools.extend( def || {}, {
+					contextSensitive: 1,
+					refresh: function( editor, path ) {
+						this.setState( path.contains( { td: 1, th: 1 }, 1 ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+					}
+				} );
+			}
+			function addCmd( name, def ) {
+				var cmd = editor.addCommand( name, def );
+				editor.addFeature( cmd );
+			}
+
+			addCmd( 'cellProperties', new CKEDITOR.dialogCommand( 'cellProperties', createDef( {
+				allowedContent: 'td th{width,height,border-color,background-color,white-space,vertical-align,text-align}[colspan,rowspan]',
+				requiredContent: 'table'
+			} ) ) );
+			CKEDITOR.dialog.add( 'cellProperties', this.path + 'dialogs/tableCell.js' );
+
+			addCmd( 'rowDelete', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					placeCursorInCell( deleteRows( selection ) );
+				}
+			} ) );
+
+			addCmd( 'rowInsertBefore', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertRow( selection, true );
+				}
+			} ) );
+
+			addCmd( 'rowInsertAfter', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertRow( selection );
+				}
+			} ) );
+
+			addCmd( 'columnDelete', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					var element = deleteColumns( selection );
+					element && placeCursorInCell( element, true );
+				}
+			} ) );
+
+			addCmd( 'columnInsertBefore', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertColumn( selection, true );
+				}
+			} ) );
+
+			addCmd( 'columnInsertAfter', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertColumn( selection );
+				}
+			} ) );
+
+			addCmd( 'cellDelete', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					deleteCells( selection );
+				}
+			} ) );
+
+			addCmd( 'cellMerge', createDef( {
+				allowedContent: 'td[colspan,rowspan]',
+				requiredContent: 'td[colspan,rowspan]',
+				exec: function( editor ) {
+					placeCursorInCell( mergeCells( editor.getSelection() ), true );
+				}
+			} ) );
+
+			addCmd( 'cellMergeRight', createDef( {
+				allowedContent: 'td[colspan]',
+				requiredContent: 'td[colspan]',
+				exec: function( editor ) {
+					placeCursorInCell( mergeCells( editor.getSelection(), 'right' ), true );
+				}
+			} ) );
+
+			addCmd( 'cellMergeDown', createDef( {
+				allowedContent: 'td[rowspan]',
+				requiredContent: 'td[rowspan]',
+				exec: function( editor ) {
+					placeCursorInCell( mergeCells( editor.getSelection(), 'down' ), true );
+				}
+			} ) );
+
+			addCmd( 'cellVerticalSplit', createDef( {
+				allowedContent: 'td[rowspan]',
+				requiredContent: 'td[rowspan]',
+				exec: function( editor ) {
+					placeCursorInCell( verticalSplitCell( editor.getSelection() ) );
+				}
+			} ) );
+
+			addCmd( 'cellHorizontalSplit', createDef( {
+				allowedContent: 'td[colspan]',
+				requiredContent: 'td[colspan]',
+				exec: function( editor ) {
+					placeCursorInCell( horizontalSplitCell( editor.getSelection() ) );
+				}
+			} ) );
+
+			addCmd( 'cellInsertBefore', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertCell( selection, true );
+				}
+			} ) );
+
+			addCmd( 'cellInsertAfter', createDef( {
+				requiredContent: 'table',
+				exec: function( editor ) {
+					var selection = editor.getSelection();
+					insertCell( selection );
+				}
+			} ) );
+
+			// If the "menu" plugin is loaded, register the menu items.
+			if ( editor.addMenuItems ) {
+				editor.addMenuItems( {
+					tablecell: {
+						label: lang.cell.menu,
+						group: 'tablecell',
+						order: 1,
+						getItems: function() {
+							var selection = editor.getSelection(),
+								cells = getSelectedCells( selection );
+							return {
+								tablecell_insertBefore: CKEDITOR.TRISTATE_OFF,
+								tablecell_insertAfter: CKEDITOR.TRISTATE_OFF,
+								tablecell_delete: CKEDITOR.TRISTATE_OFF,
+								tablecell_merge: mergeCells( selection, null, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
+								tablecell_merge_right: mergeCells( selection, 'right', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
+								tablecell_merge_down: mergeCells( selection, 'down', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
+								tablecell_split_vertical: verticalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
+								tablecell_split_horizontal: horizontalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
+								tablecell_properties: cells.length > 0 ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED
+							};
+						}
+					},
+
+					tablecell_insertBefore: {
+						label: lang.cell.insertBefore,
+						group: 'tablecell',
+						command: 'cellInsertBefore',
+						order: 5
+					},
+
+					tablecell_insertAfter: {
+						label: lang.cell.insertAfter,
+						group: 'tablecell',
+						command: 'cellInsertAfter',
+						order: 10
+					},
+
+					tablecell_delete: {
+						label: lang.cell.deleteCell,
+						group: 'tablecell',
+						command: 'cellDelete',
+						order: 15
+					},
+
+					tablecell_merge: {
+						label: lang.cell.merge,
+						group: 'tablecell',
+						command: 'cellMerge',
+						order: 16
+					},
+
+					tablecell_merge_right: {
+						label: lang.cell.mergeRight,
+						group: 'tablecell',
+						command: 'cellMergeRight',
+						order: 17
+					},
+
+					tablecell_merge_down: {
+						label: lang.cell.mergeDown,
+						group: 'tablecell',
+						command: 'cellMergeDown',
+						order: 18
+					},
+
+					tablecell_split_horizontal: {
+						label: lang.cell.splitHorizontal,
+						group: 'tablecell',
+						command: 'cellHorizontalSplit',
+						order: 19
+					},
+
+					tablecell_split_vertical: {
+						label: lang.cell.splitVertical,
+						group: 'tablecell',
+						command: 'cellVerticalSplit',
+						order: 20
+					},
+
+					tablecell_properties: {
+						label: lang.cell.title,
+						group: 'tablecellproperties',
+						command: 'cellProperties',
+						order: 21
+					},
+
+					tablerow: {
+						label: lang.row.menu,
+						group: 'tablerow',
+						order: 1,
+						getItems: function() {
+							return {
+								tablerow_insertBefore: CKEDITOR.TRISTATE_OFF,
+								tablerow_insertAfter: CKEDITOR.TRISTATE_OFF,
+								tablerow_delete: CKEDITOR.TRISTATE_OFF
+							};
+						}
+					},
+
+					tablerow_insertBefore: {
+						label: lang.row.insertBefore,
+						group: 'tablerow',
+						command: 'rowInsertBefore',
+						order: 5
+					},
+
+					tablerow_insertAfter: {
+						label: lang.row.insertAfter,
+						group: 'tablerow',
+						command: 'rowInsertAfter',
+						order: 10
+					},
+
+					tablerow_delete: {
+						label: lang.row.deleteRow,
+						group: 'tablerow',
+						command: 'rowDelete',
+						order: 15
+					},
+
+					tablecolumn: {
+						label: lang.column.menu,
+						group: 'tablecolumn',
+						order: 1,
+						getItems: function() {
+							return {
+								tablecolumn_insertBefore: CKEDITOR.TRISTATE_OFF,
+								tablecolumn_insertAfter: CKEDITOR.TRISTATE_OFF,
+								tablecolumn_delete: CKEDITOR.TRISTATE_OFF
+							};
+						}
+					},
+
+					tablecolumn_insertBefore: {
+						label: lang.column.insertBefore,
+						group: 'tablecolumn',
+						command: 'columnInsertBefore',
+						order: 5
+					},
+
+					tablecolumn_insertAfter: {
+						label: lang.column.insertAfter,
+						group: 'tablecolumn',
+						command: 'columnInsertAfter',
+						order: 10
+					},
+
+					tablecolumn_delete: {
+						label: lang.column.deleteColumn,
+						group: 'tablecolumn',
+						command: 'columnDelete',
+						order: 15
+					}
+				} );
+			}
+
+			// If the "contextmenu" plugin is laoded, register the listeners.
+			if ( editor.contextMenu ) {
+				editor.contextMenu.addListener( function( element, selection, path ) {
+					var cell = path.contains( { 'td': 1, 'th': 1 }, 1 );
+					if ( cell && !cell.isReadOnly() ) {
+						return {
+							tablecell: CKEDITOR.TRISTATE_OFF,
+							tablerow: CKEDITOR.TRISTATE_OFF,
+							tablecolumn: CKEDITOR.TRISTATE_OFF
+						};
+					}
+
+					return null;
+				} );
+			}
+		},
+
+		getSelectedCells: getSelectedCells
+
+	};
+	CKEDITOR.plugins.add( 'tabletools', CKEDITOR.plugins.tabletools );
+} )();
+
+/**
+ * Create a two-dimension array that reflects the actual layout of table cells,
+ * with cell spans, with mappings to the original td elements.
+ *
+ * @param {CKEDITOR.dom.element} table
+ * @member CKEDITOR.tools
+ */
+CKEDITOR.tools.buildTableMap = function( table ) {
+	var aRows = table.$.rows;
+
+	// Row and Column counters.
+	var r = -1;
+
+	var aMap = [];
+
+	for ( var i = 0; i < aRows.length; i++ ) {
+		r++;
+		!aMap[ r ] && ( aMap[ r ] = [] );
+
+		var c = -1;
+
+		for ( var j = 0; j < aRows[ i ].cells.length; j++ ) {
+			var oCell = aRows[ i ].cells[ j ];
+
+			c++;
+			while ( aMap[ r ][ c ] )
+				c++;
+
+			var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan;
+			var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan;
+
+			for ( var rs = 0; rs < iRowSpan; rs++ ) {
+				if ( !aMap[ r + rs ] )
+					aMap[ r + rs ] = [];
+
+				for ( var cs = 0; cs < iColSpan; cs++ ) {
+					aMap[ r + rs ][ c + cs ] = aRows[ i ].cells[ j ];
+				}
+			}
+
+			c += iColSpan - 1;
+		}
+	}
+	return aMap;
+};
diff --git a/lam/templates/lib/extra/ckeditor/plugins/toolbar/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/toolbar/plugin.js
new file mode 100644
index 00000000..66968154
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/toolbar/plugin.js
@@ -0,0 +1,781 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "toolbar" plugin. Renders the default toolbar interface in
+ * the editor.
+ */
+
+( function() {
+	var toolbox = function() {
+			this.toolbars = [];
+			this.focusCommandExecuted = false;
+		};
+
+	toolbox.prototype.focus = function() {
+		for ( var t = 0, toolbar; toolbar = this.toolbars[ t++ ]; ) {
+			for ( var i = 0, item; item = toolbar.items[ i++ ]; ) {
+				if ( item.focus ) {
+					item.focus();
+					return;
+				}
+			}
+		}
+	};
+
+	var commands = {
+		toolbarFocus: {
+			modes: { wysiwyg: 1, source: 1 },
+			readOnly: 1,
+
+			exec: function( editor ) {
+				if ( editor.toolbox ) {
+					editor.toolbox.focusCommandExecuted = true;
+
+					// Make the first button focus accessible for IE. (#3417)
+					// Adobe AIR instead need while of delay.
+					if ( CKEDITOR.env.ie || CKEDITOR.env.air )
+						setTimeout( function() {
+						editor.toolbox.focus();
+					}, 100 );
+					else
+						editor.toolbox.focus();
+				}
+			}
+		}
+	};
+
+	CKEDITOR.plugins.add( 'toolbar', {
+		requires: 'button',
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+
+		init: function( editor ) {
+			var endFlag;
+
+			var itemKeystroke = function( item, keystroke ) {
+					var next, toolbar;
+					var rtl = editor.lang.dir == 'rtl',
+						toolbarGroupCycling = editor.config.toolbarGroupCycling,
+						// Picking right/left key codes.
+						rightKeyCode = rtl ? 37 : 39,
+						leftKeyCode = rtl ? 39 : 37;
+
+					toolbarGroupCycling = toolbarGroupCycling === undefined || toolbarGroupCycling;
+
+					switch ( keystroke ) {
+						case 9: // TAB
+						case CKEDITOR.SHIFT + 9: // SHIFT + TAB
+							// Cycle through the toolbars, starting from the one
+							// closest to the current item.
+							while ( !toolbar || !toolbar.items.length ) {
+								toolbar = keystroke == 9 ? ( ( toolbar ? toolbar.next : item.toolbar.next ) || editor.toolbox.toolbars[ 0 ] ) : ( ( toolbar ? toolbar.previous : item.toolbar.previous ) || editor.toolbox.toolbars[ editor.toolbox.toolbars.length - 1 ] );
+
+								// Look for the first item that accepts focus.
+								if ( toolbar.items.length ) {
+									item = toolbar.items[ endFlag ? ( toolbar.items.length - 1 ) : 0 ];
+									while ( item && !item.focus ) {
+										item = endFlag ? item.previous : item.next;
+
+										if ( !item )
+											toolbar = 0;
+									}
+								}
+							}
+
+							if ( item )
+								item.focus();
+
+							return false;
+
+						case rightKeyCode:
+							next = item;
+							do {
+								// Look for the next item in the toolbar.
+								next = next.next;
+
+								// If it's the last item, cycle to the first one.
+								if ( !next && toolbarGroupCycling ) next = item.toolbar.items[ 0 ];
+							}
+							while ( next && !next.focus );
+
+							// If available, just focus it, otherwise focus the
+							// first one.
+							if ( next )
+								next.focus();
+							else
+								// Send a TAB.
+								itemKeystroke( item, 9 );
+
+							return false;
+						case 40: // DOWN-ARROW
+							if ( item.button && item.button.hasArrow ) {
+								// Note: code is duplicated in plugins\richcombo\plugin.js in keyDownFn().
+								editor.once( 'panelShow', function( evt ) {
+									evt.data._.panel._.currentBlock.onKeyDown( 40 );
+								} );
+								item.execute();
+							} else {
+								// Send left arrow key.
+								itemKeystroke( item, keystroke == 40 ? rightKeyCode : leftKeyCode );
+							}
+							return false;
+						case leftKeyCode:
+						case 38: // UP-ARROW
+							next = item;
+							do {
+								// Look for the previous item in the toolbar.
+								next = next.previous;
+
+								// If it's the first item, cycle to the last one.
+								if ( !next && toolbarGroupCycling ) next = item.toolbar.items[ item.toolbar.items.length - 1 ];
+							}
+							while ( next && !next.focus );
+
+							// If available, just focus it, otherwise focus the
+							// last one.
+							if ( next )
+								next.focus();
+							else {
+								endFlag = 1;
+								// Send a SHIFT + TAB.
+								itemKeystroke( item, CKEDITOR.SHIFT + 9 );
+								endFlag = 0;
+							}
+
+							return false;
+
+						case 27: // ESC
+							editor.focus();
+							return false;
+
+						case 13: // ENTER
+						case 32: // SPACE
+							item.execute();
+							return false;
+					}
+					return true;
+				};
+
+			editor.on( 'uiSpace', function( event ) {
+				if ( event.data.space != editor.config.toolbarLocation )
+					return;
+
+				// Create toolbar only once.
+				event.removeListener();
+
+				editor.toolbox = new toolbox();
+
+				var labelId = CKEDITOR.tools.getNextId();
+
+				var output = [
+					'<span id="', labelId, '" class="cke_voice_label">', editor.lang.toolbar.toolbars, '</span>',
+					'<span id="' + editor.ui.spaceId( 'toolbox' ) + '" class="cke_toolbox" role="group" aria-labelledby="', labelId, '" onmousedown="return false;">' ];
+
+				var expanded = editor.config.toolbarStartupExpanded !== false,
+					groupStarted, pendingSeparator;
+
+				// If the toolbar collapser will be available, we'll have
+				// an additional container for all toolbars.
+				if ( editor.config.toolbarCanCollapse && editor.elementMode != CKEDITOR.ELEMENT_MODE_INLINE )
+					output.push( '<span class="cke_toolbox_main"' + ( expanded ? '>' : ' style="display:none">' ) );
+
+				var toolbars = editor.toolbox.toolbars,
+					toolbar = getToolbarConfig( editor );
+
+				for ( var r = 0; r < toolbar.length; r++ ) {
+					var toolbarId,
+						toolbarObj = 0,
+						toolbarName,
+						row = toolbar[ r ],
+						items;
+
+					// It's better to check if the row object is really
+					// available because it's a common mistake to leave
+					// an extra comma in the toolbar definition
+					// settings, which leads on the editor not loading
+					// at all in IE. (#3983)
+					if ( !row )
+						continue;
+
+					if ( groupStarted ) {
+						output.push( '</span>' );
+						groupStarted = 0;
+						pendingSeparator = 0;
+					}
+
+					if ( row === '/' ) {
+						output.push( '<span class="cke_toolbar_break"></span>' );
+						continue;
+					}
+
+					items = row.items || row;
+
+					// Create all items defined for this toolbar.
+					for ( var i = 0; i < items.length; i++ ) {
+						var item = items[ i ],
+							canGroup;
+
+						if ( item ) {
+							if ( item.type == CKEDITOR.UI_SEPARATOR ) {
+								// Do not add the separator immediately. Just save
+								// it be included if we already have something in
+								// the toolbar and if a new item is to be added (later).
+								pendingSeparator = groupStarted && item;
+								continue;
+							}
+
+							canGroup = item.canGroup !== false;
+
+							// Initialize the toolbar first, if needed.
+							if ( !toolbarObj ) {
+								// Create the basic toolbar object.
+								toolbarId = CKEDITOR.tools.getNextId();
+								toolbarObj = { id: toolbarId, items: [] };
+								toolbarName = row.name && ( editor.lang.toolbar.toolbarGroups[ row.name ] || row.name );
+
+								// Output the toolbar opener.
+								output.push( '<span id="', toolbarId, '" class="cke_toolbar"', ( toolbarName ? ' aria-labelledby="' + toolbarId + '_label"' : '' ), ' role="toolbar">' );
+
+								// If a toolbar name is available, send the voice label.
+								toolbarName && output.push( '<span id="', toolbarId, '_label" class="cke_voice_label">', toolbarName, '</span>' );
+
+								output.push( '<span class="cke_toolbar_start"></span>' );
+
+								// Add the toolbar to the "editor.toolbox.toolbars"
+								// array.
+								var index = toolbars.push( toolbarObj ) - 1;
+
+								// Create the next/previous reference.
+								if ( index > 0 ) {
+									toolbarObj.previous = toolbars[ index - 1 ];
+									toolbarObj.previous.next = toolbarObj;
+								}
+							}
+
+							if ( canGroup ) {
+								if ( !groupStarted ) {
+									output.push( '<span class="cke_toolgroup" role="presentation">' );
+									groupStarted = 1;
+								}
+							} else if ( groupStarted ) {
+								output.push( '</span>' );
+								groupStarted = 0;
+							}
+
+							function addItem( item ) {
+								var itemObj = item.render( editor, output );
+								index = toolbarObj.items.push( itemObj ) - 1;
+
+								if ( index > 0 ) {
+									itemObj.previous = toolbarObj.items[ index - 1 ];
+									itemObj.previous.next = itemObj;
+								}
+
+								itemObj.toolbar = toolbarObj;
+								itemObj.onkey = itemKeystroke;
+
+								// Fix for #3052:
+								// Prevent JAWS from focusing the toolbar after document load.
+								itemObj.onfocus = function() {
+									if ( !editor.toolbox.focusCommandExecuted )
+										editor.focus();
+								};
+							}
+
+							if ( pendingSeparator ) {
+								addItem( pendingSeparator );
+								pendingSeparator = 0;
+							}
+
+							addItem( item );
+						}
+					}
+
+					if ( groupStarted ) {
+						output.push( '</span>' );
+						groupStarted = 0;
+						pendingSeparator = 0;
+					}
+
+					if ( toolbarObj )
+						output.push( '<span class="cke_toolbar_end"></span></span>' );
+				}
+
+				if ( editor.config.toolbarCanCollapse )
+					output.push( '</span>' );
+
+				// Not toolbar collapser for inline mode.
+				if ( editor.config.toolbarCanCollapse && editor.elementMode != CKEDITOR.ELEMENT_MODE_INLINE ) {
+					var collapserFn = CKEDITOR.tools.addFunction( function() {
+						editor.execCommand( 'toolbarCollapse' );
+					} );
+
+					editor.on( 'destroy', function() {
+						CKEDITOR.tools.removeFunction( collapserFn );
+					} );
+
+					editor.addCommand( 'toolbarCollapse', {
+						readOnly: 1,
+						exec: function( editor ) {
+							var collapser = editor.ui.space( 'toolbar_collapser' ),
+								toolbox = collapser.getPrevious(),
+								contents = editor.ui.space( 'contents' ),
+								toolboxContainer = toolbox.getParent(),
+								contentHeight = parseInt( contents.$.style.height, 10 ),
+								previousHeight = toolboxContainer.$.offsetHeight,
+								minClass = 'cke_toolbox_collapser_min',
+								collapsed = collapser.hasClass( minClass );
+
+							if ( !collapsed ) {
+								toolbox.hide();
+								collapser.addClass( minClass );
+								collapser.setAttribute( 'title', editor.lang.toolbar.toolbarExpand );
+							} else {
+								toolbox.show();
+								collapser.removeClass( minClass );
+								collapser.setAttribute( 'title', editor.lang.toolbar.toolbarCollapse );
+							}
+
+							// Update collapser symbol.
+							collapser.getFirst().setText( collapsed ? '\u25B2' : // BLACK UP-POINTING TRIANGLE
+							'\u25C0' ); // BLACK LEFT-POINTING TRIANGLE
+
+							var dy = toolboxContainer.$.offsetHeight - previousHeight;
+							contents.setStyle( 'height', ( contentHeight - dy ) + 'px' );
+
+							editor.fire( 'resize' );
+						},
+
+						modes: { wysiwyg: 1, source: 1 }
+					} );
+
+					editor.setKeystroke( CKEDITOR.ALT + ( CKEDITOR.env.ie || CKEDITOR.env.webkit ? 189 : 109 ) /*-*/, 'toolbarCollapse' );
+
+					output.push( '<a title="' + ( expanded ? editor.lang.toolbar.toolbarCollapse : editor.lang.toolbar.toolbarExpand )
+						+ '" id="' + editor.ui.spaceId( 'toolbar_collapser' )
+						+ '" tabIndex="-1" class="cke_toolbox_collapser' );
+
+					if ( !expanded )
+						output.push( ' cke_toolbox_collapser_min' );
+
+					output.push( '" onclick="CKEDITOR.tools.callFunction(' + collapserFn + ')">', '<span class="cke_arrow">&#9650;</span>', // BLACK UP-POINTING TRIANGLE
+						'</a>' );
+				}
+
+				output.push( '</span>' );
+				event.data.html += output.join( '' );
+			} );
+
+			editor.on( 'destroy', function() {
+
+				if ( this.toolbox )
+				{
+					var toolbars,
+						index = 0,
+						i, items, instance;
+					toolbars = this.toolbox.toolbars;
+					for ( ; index < toolbars.length; index++ ) {
+						items = toolbars[ index ].items;
+						for ( i = 0; i < items.length; i++ ) {
+							instance = items[ i ];
+							if ( instance.clickFn )
+								CKEDITOR.tools.removeFunction( instance.clickFn );
+							if ( instance.keyDownFn )
+								CKEDITOR.tools.removeFunction( instance.keyDownFn );
+						}
+					}
+				}
+			} );
+
+			// Manage editor focus  when navigating the toolbar.
+			editor.on( 'uiReady', function() {
+				var toolbox = editor.ui.space( 'toolbox' );
+				toolbox && editor.focusManager.add( toolbox, 1 );
+			} );
+
+			editor.addCommand( 'toolbarFocus', commands.toolbarFocus );
+			editor.setKeystroke( CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' );
+
+			editor.ui.add( '-', CKEDITOR.UI_SEPARATOR, {} );
+			editor.ui.addHandler( CKEDITOR.UI_SEPARATOR, {
+				create: function() {
+					return {
+						render: function( editor, output ) {
+							output.push( '<span class="cke_toolbar_separator" role="separator"></span>' );
+							return {};
+						}
+					};
+				}
+			} );
+		}
+	} );
+
+	function getToolbarConfig( editor ) {
+		var removeButtons = editor.config.removeButtons;
+
+		removeButtons = removeButtons && removeButtons.split( ',' );
+
+		function buildToolbarConfig() {
+
+			// Object containing all toolbar groups used by ui items.
+			var lookup = getItemDefinedGroups();
+
+			// Take the base for the new toolbar, which is basically a toolbar
+			// definition without items.
+			var toolbar = CKEDITOR.tools.clone( editor.config.toolbarGroups ) || getPrivateToolbarGroups( editor );
+
+			// Fill the toolbar groups with the available ui items.
+			for ( var i = 0; i < toolbar.length; i++ ) {
+				var toolbarGroup = toolbar[ i ];
+
+				// Skip toolbar break.
+				if ( toolbarGroup == '/' )
+					continue;
+				// Handle simply group name item.
+				else if ( typeof toolbarGroup == 'string' )
+					toolbarGroup = toolbar[ i ] = { name: toolbarGroup };
+
+				var items, subGroups = toolbarGroup.groups;
+
+				// Look for items that match sub groups.
+				if ( subGroups ) {
+					for ( var j = 0, sub; j < subGroups.length; j++ ) {
+						sub = subGroups[ j ];
+
+						// If any ui item is registered for this subgroup.
+						items = lookup[ sub ];
+						items && fillGroup( toolbarGroup, items );
+					}
+				}
+
+				// Add the main group items as well.
+				items = lookup[ toolbarGroup.name ];
+				items && fillGroup( toolbarGroup, items );
+			}
+
+			return toolbar;
+		}
+
+		// Returns an object containing all toolbar groups used by ui items.
+		function getItemDefinedGroups() {
+			var groups = {},
+				itemName, item, itemToolbar, group, order;
+
+			for ( itemName in editor.ui.items ) {
+				item = editor.ui.items[ itemName ];
+				itemToolbar = item.toolbar || 'others';
+				if ( itemToolbar ) {
+					// Break the toolbar property into its parts: "group_name[,order]".
+					itemToolbar = itemToolbar.split( ',' );
+					group = itemToolbar[ 0 ];
+					order = parseInt( itemToolbar[ 1 ] || -1, 10 );
+
+					// Initialize the group, if necessary.
+					groups[ group ] || ( groups[ group ] = [] );
+
+					// Push the data used to build the toolbar later.
+					groups[ group ].push( { name: itemName, order: order } );
+				}
+			}
+
+			// Put the items in the right order.
+			for ( group in groups ) {
+				groups[ group ] = groups[ group ].sort( function( a, b ) {
+					return a.order == b.order ? 0 :
+						b.order < 0 ? -1 :
+						a.order < 0 ? 1 :
+						a.order < b.order ? -1 :
+						1;
+				} );
+			}
+
+			return groups;
+		}
+
+		function fillGroup( toolbarGroup, uiItems ) {
+			if ( uiItems.length ) {
+				if ( toolbarGroup.items )
+					toolbarGroup.items.push( editor.ui.create( '-' ) );
+				else
+					toolbarGroup.items = [];
+
+				var item, name;
+				while ( ( item = uiItems.shift() ) ) {
+					name = typeof item == 'string' ? item : item.name;
+
+					// Ignore items that are configured to be removed.
+					if ( !removeButtons || CKEDITOR.tools.indexOf( removeButtons, name ) == -1 ) {
+						item = editor.ui.create( name );
+
+						if ( !item )
+							continue;
+
+						if ( !editor.addFeature( item ) )
+							continue;
+
+						toolbarGroup.items.push( item );
+					}
+				}
+			}
+		}
+
+		function populateToolbarConfig( config ) {
+			var toolbar = [],
+				i, group, newGroup;
+
+			for ( i = 0; i < config.length; ++i ) {
+				group = config[ i ];
+				newGroup = {};
+
+				if ( group == '/' )
+					toolbar.push( group );
+				else if ( CKEDITOR.tools.isArray( group ) ) {
+					fillGroup( newGroup, CKEDITOR.tools.clone( group ) );
+					toolbar.push( newGroup );
+				}
+				else if ( group.items ) {
+					fillGroup( newGroup, CKEDITOR.tools.clone( group.items ) );
+					newGroup.name = group.name;
+					toolbar.push( newGroup );
+				}
+			}
+
+			return toolbar;
+		}
+
+		var toolbar = editor.config.toolbar;
+
+		// If it is a string, return the relative "toolbar_name" config.
+		if ( typeof toolbar == 'string' )
+			toolbar = editor.config[ 'toolbar_' + toolbar ];
+
+		return ( editor.toolbar = toolbar ? populateToolbarConfig( toolbar ) : buildToolbarConfig() );
+	}
+
+	/**
+	 * Add toolbar group. See {@link CKEDITOR.config#toolbarGroups} for more details.
+	 *
+	 * **Note:** This method won't modify toolbar groups set explicitly by
+	 * {@link CKEDITOR.config#toolbarGroups}. It will extend only default setting.
+	 *
+	 * @param {String} name Group name.
+	 * @param {Number/String} previous Name of group after which this one
+	 * should be added or `0` if this group should be the first one.
+	 * @param {String} [subgroupOf] Name of parent group.
+	 * @member CKEDITOR.ui
+	 */
+	CKEDITOR.ui.prototype.addToolbarGroup = function( name, previous, subgroupOf ) {
+		// The toolbarGroups from the privates is the one we gonna use for automatic toolbar creation.
+		var toolbarGroups = getPrivateToolbarGroups( this.editor ),
+			atStart = previous === 0,
+			newGroup = { name: name };
+
+		if ( subgroupOf ) {
+			// Transform the subgroupOf name in the real subgroup object.
+			subgroupOf = CKEDITOR.tools.search( toolbarGroups, function( group ) {
+				return group.name == subgroupOf;
+			} );
+
+			if ( subgroupOf ) {
+				!subgroupOf.groups && ( subgroupOf.groups = [] ) ;
+
+				if ( previous ) {
+					// Search the "previous" item and add the new one after it.
+					previous = CKEDITOR.tools.indexOf( subgroupOf.groups, previous );
+					if ( previous >= 0 ) {
+						subgroupOf.groups.splice( previous + 1, 0, name );
+						return;
+					}
+				}
+
+				// If no previous found.
+
+				if ( atStart )
+					subgroupOf.groups.splice( 0, 0, name );
+				else
+					subgroupOf.groups.push(  name );
+				return;
+			} else {
+				// Ignore "previous" if subgroupOf has not been found.
+				previous = null;
+			}
+		}
+
+		if ( previous ) {
+			// Transform the "previous" name into its index.
+			previous = CKEDITOR.tools.indexOf( toolbarGroups, function( group ) {
+				return group.name == previous;
+			} );
+		}
+
+		if ( atStart )
+			toolbarGroups.splice( 0, 0, name );
+		else if ( typeof previous == 'number' )
+			toolbarGroups.splice( previous + 1, 0, newGroup );
+		else
+			toolbarGroups.push( name );
+	};
+
+	function getPrivateToolbarGroups( editor ) {
+		return editor._.toolbarGroups || ( editor._.toolbarGroups = [
+			{ name: 'document',	   groups: [ 'mode', 'document', 'doctools' ] },
+			{ name: 'clipboard',   groups: [ 'clipboard', 'undo' ] },
+			{ name: 'editing',     groups: [ 'find', 'selection', 'spellchecker' ] },
+			{ name: 'forms' },
+			'/',
+			{ name: 'basicstyles', groups: [ 'basicstyles', 'cleanup' ] },
+			{ name: 'paragraph',   groups: [ 'list', 'indent', 'blocks', 'align', 'bidi' ] },
+			{ name: 'links' },
+			{ name: 'insert' },
+			'/',
+			{ name: 'styles' },
+			{ name: 'colors' },
+			{ name: 'tools' },
+			{ name: 'others' },
+			{ name: 'about' }
+		] );
+	}
+} )();
+
+/**
+ * Separator UI element.
+ *
+ * @readonly
+ * @property {String} [='separator']
+ * @member CKEDITOR
+ */
+CKEDITOR.UI_SEPARATOR = 'separator';
+
+/**
+ * The "UI space" to which rendering the toolbar. For the default editor implementation,
+ * the recommended options are `'top'` and `'bottom'`.
+ *
+ *		config.toolbarLocation = 'bottom';
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.toolbarLocation = 'top';
+
+/**
+ * The toolbox (alias toolbar) definition. It is a toolbar name or an array of
+ * toolbars (strips), each one being also an array, containing a list of UI items.
+ *
+ * If set to `null`, generate toolbar automatically using all available buttons
+ * and {@link #toolbarGroups} as a toolbar groups layout.
+ *
+ *		// Defines a toolbar with only one strip containing the "Source" button, a
+ *		// separator and the "Bold" and "Italic" buttons.
+ *		config.toolbar = [
+ *			[ 'Source', '-', 'Bold', 'Italic' ]
+ *		];
+ *
+ *		// Similar to example the above, defines a "Basic" toolbar with only one strip containing three buttons.
+ *		// Note that this setting is composed by "toolbar_" added by the toolbar name, which in this case is called "Basic".
+ *		// This second part of the setting name can be anything. You must use this name in the CKEDITOR.config.toolbar setting,
+ *		// so you instruct the editor which toolbar_(name) setting to use.
+ *		config.toolbar_Basic = [
+ *			[ 'Source', '-', 'Bold', 'Italic' ]
+ *		];
+ *		// Load toolbar_Name where Name = Basic.
+ *		config.toolbar = 'Basic';
+ *
+ * @cfg {Array/String} [toolbar=null]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The toolbar groups definition.
+ *
+ * If toolbar layout isn't explicitly defined by {@link #toolbar} setting, then
+ * this setting is used to group all defined buttons (see {@link CKEDITOR.ui#addButton}).
+ * Buttons are associated with toolbar groups by `toolbar` property in their definition objects.
+ *
+ * New groups may be dynamically added during the editor and plugins initialization by
+ * {@link CKEDITOR.ui#addToolbarGroup}. Although only if default setting was used.
+ *
+ *		// Default setting.
+ *		config.toolbarGroups = [
+ *			{ name: 'document',	   groups: [ 'mode', 'document', 'doctools' ] },
+ *			{ name: 'clipboard',   groups: [ 'clipboard', 'undo' ] },
+ *			{ name: 'editing',     groups: [ 'find', 'selection', 'spellchecker' ] },
+ *			{ name: 'forms' },
+ *			'/',
+ *			{ name: 'basicstyles', groups: [ 'basicstyles', 'cleanup' ] },
+ *			{ name: 'paragraph',   groups: [ 'list', 'indent', 'blocks', 'align', 'bidi' ] },
+ *			{ name: 'links' },
+ *			{ name: 'insert' },
+ *			'/',
+ *			{ name: 'styles' },
+ *			{ name: 'colors' },
+ *			{ name: 'tools' },
+ *			{ name: 'others' },
+ *			{ name: 'about' }
+ *		];
+ *
+ * @cfg {Array} [toolbarGroups=see example]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Whether the toolbar can be collapsed by the user. If disabled, the collapser
+ * button will not be displayed.
+ *
+ *		config.toolbarCanCollapse = true;
+ *
+ * @cfg {Boolean} [toolbarCanCollapse=false]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Whether the toolbar must start expanded when the editor is loaded.
+ *
+ * Setting this option to `false` will affect toolbar only when
+ * {@link #toolbarCanCollapse} is set to `true`:
+ *
+ *		config.toolbarCanCollapse = true;
+ *		config.toolbarStartupExpanded = false;
+ *
+ * @cfg {Boolean} [toolbarStartupExpanded=true]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * When enabled, makes the arrow keys navigation cycle within the current
+ * toolbar group. Otherwise the arrows will move through all items available in
+ * the toolbar. The *TAB* key will still be used to quickly jump among the
+ * toolbar groups.
+ *
+ *		config.toolbarGroupCycling = false;
+ *
+ * @since 3.6
+ * @cfg {Boolean} [toolbarGroupCycling=true]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * List of toolbar button names that must not be rendered. This will work as
+ * well for non-button toolbar items, like the Font combos.
+ *
+ *		config.removeButtons = 'Underline,JustifyCenter';
+ *
+ * This configuration should not be overused, having
+ * {@link CKEDITOR.config#removePlugins} removing features from the editor. In
+ * some cases though, a single plugin may define a set of toolbar buttons and
+ * removeButtons may be useful when just a few of them are to be removed.
+ *
+ * @cfg {String} [removeButtons]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Toolbar definition used by the editor. It is crated from the
+ * {@link CKEDITOR.config#toolbar} if it is set or automatically
+ * based on {@link CKEDITOR.config#toolbarGroups}.
+ *
+ * @readonly
+ * @property {Object} toolbar
+ * @member CKEDITOR.editor
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/undo/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/undo/plugin.js
new file mode 100644
index 00000000..effb070b
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/undo/plugin.js
@@ -0,0 +1,738 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Undo/Redo system for saving a shapshot for document modification
+ *		and other recordable changes.
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'undo', {
+		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%
+		icons: 'redo,redo-rtl,undo,undo-rtl', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function( editor ) {
+			var undoManager = editor.undoManager = new UndoManager( editor );
+
+			var undoCommand = editor.addCommand( 'undo', {
+				exec: function() {
+					if ( undoManager.undo() ) {
+						editor.selectionChange();
+						this.fire( 'afterUndo' );
+					}
+				},
+				startDisabled: true,
+				canUndo: false
+			} );
+
+			var redoCommand = editor.addCommand( 'redo', {
+				exec: function() {
+					if ( undoManager.redo() ) {
+						editor.selectionChange();
+						this.fire( 'afterRedo' );
+					}
+				},
+				startDisabled: true,
+				canUndo: false
+			} );
+
+			editor.setKeystroke( [
+				[ CKEDITOR.CTRL + 90 /*Z*/, 'undo' ],
+				[ CKEDITOR.CTRL + 89 /*Y*/, 'redo' ],
+				[ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/, 'redo' ]
+			] );
+
+			undoManager.onChange = function() {
+				undoCommand.setState( undoManager.undoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+				redoCommand.setState( undoManager.redoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+			};
+
+			function recordCommand( event ) {
+				// If the command hasn't been marked to not support undo.
+				if ( undoManager.enabled && event.data.command.canUndo !== false )
+					undoManager.save();
+			}
+
+			// We'll save snapshots before and after executing a command.
+			editor.on( 'beforeCommandExec', recordCommand );
+			editor.on( 'afterCommandExec', recordCommand );
+
+			// Save snapshots before doing custom changes.
+			editor.on( 'saveSnapshot', function( evt ) {
+				undoManager.save( evt.data && evt.data.contentOnly );
+			} );
+
+			// Registering keydown on every document recreation.(#3844)
+			editor.on( 'contentDom', function() {
+				editor.editable().on( 'keydown', function( event ) {
+					var keystroke = event.data.getKey();
+
+					if ( keystroke == 8 /*Backspace*/ || keystroke == 46 /*Delete*/ )
+						undoManager.type( keystroke, 0 );
+				} );
+
+				editor.editable().on( 'keypress', function( event ) {
+					undoManager.type( event.data.getKey(), 1 );
+				} );
+			} );
+
+			// Always save an undo snapshot - the previous mode might have
+			// changed editor contents.
+			editor.on( 'beforeModeUnload', function() {
+				editor.mode == 'wysiwyg' && undoManager.save( true );
+			} );
+
+			function toggleUndoManager() {
+				undoManager.enabled = editor.readOnly ? false : editor.mode == 'wysiwyg';
+				undoManager.onChange();
+			}
+
+			// Make the undo manager available only in wysiwyg mode.
+			editor.on( 'mode', toggleUndoManager );
+
+			// Disable undo manager when in read-only mode.
+			editor.on( 'readOnly', toggleUndoManager );
+
+			if ( editor.ui.addButton ) {
+				editor.ui.addButton( 'Undo', {
+					label: editor.lang.undo.undo,
+					command: 'undo',
+					toolbar: 'undo,10'
+				} );
+
+				editor.ui.addButton( 'Redo', {
+					label: editor.lang.undo.redo,
+					command: 'redo',
+					toolbar: 'undo,20'
+				} );
+			}
+
+			/**
+			 * Resets the undo stack.
+			 *
+			 * @member CKEDITOR.editor
+			 */
+			editor.resetUndo = function() {
+				// Reset the undo stack.
+				undoManager.reset();
+
+				// Create the first image.
+				editor.fire( 'saveSnapshot' );
+			};
+
+			/**
+			 * Amends the top of the undo stack (last undo image) with the current DOM changes.
+			 *
+			 *		function() {
+			 *			editor.fire( 'saveSnapshot' );
+			 *			editor.document.body.append(...);
+			 *			// Makes new changes following the last undo snapshot a part of it.
+			 *			editor.fire( 'updateSnapshot' );
+			 *			..
+			 *		}
+			 *
+			 * @event updateSnapshot
+			 * @member CKEDITOR.editor
+ 			 * @param {CKEDITOR.editor} editor This editor instance.
+			 */
+			editor.on( 'updateSnapshot', function() {
+				if ( undoManager.currentImage )
+					undoManager.update();
+			} );
+
+			/**
+			 * Locks the undo manager to prevent any save/update operations.
+			 *
+			 * It is convenient to lock the undo manager before performing DOM operations
+			 * that should not be recored (e.g. auto paragraphing).
+			 *
+			 * See {@link CKEDITOR.plugins.undo.UndoManager#lock} for more details.
+			 *
+			 * **Note:** In order to unlock the undo manager, {@link #unlockSnapshot} has to be fired
+			 * the same number of times that `lockSnapshot` has been fired.
+			 *
+			 * @since 4.0
+			 * @event lockSnapshot
+			 * @member CKEDITOR.editor
+ 			 * @param {CKEDITOR.editor} editor This editor instance.
+			 * @param data
+			 * @param {Boolean} [data.dontUpdate] When set to `true` the last snapshot will not be updated
+			 * with the current contents and selection. Read more in the {@link CKEDITOR.plugins.undo.UndoManager#lock} method.
+			 */
+			editor.on( 'lockSnapshot', function( evt ) {
+				undoManager.lock( evt.data && evt.data.dontUpdate );
+			} );
+
+			/**
+			 * Unlocks the undo manager and updates the latest snapshot.
+			 *
+			 * @since 4.0
+			 * @event unlockSnapshot
+			 * @member CKEDITOR.editor
+ 			 * @param {CKEDITOR.editor} editor This editor instance.
+			 */
+			editor.on( 'unlockSnapshot', undoManager.unlock, undoManager );
+		}
+	} );
+
+	CKEDITOR.plugins.undo = {};
+
+	/**
+	 * Undoes the snapshot which represents the current document status.
+	 *
+	 * @private
+	 * @class CKEDITOR.plugins.undo.Image
+	 * @constructor Creates an Image class instance.
+	 * @param {CKEDITOR.editor} editor The editor instance on which the image is created.
+	 * @param {Boolean} [contentsOnly] If set to `true` image will contain only contents, without selection.
+	 */
+	var Image = CKEDITOR.plugins.undo.Image = function( editor, contentsOnly ) {
+			this.editor = editor;
+
+			editor.fire( 'beforeUndoImage' );
+
+			var contents = editor.getSnapshot();
+
+			// In IE, we need to remove the expando attributes.
+			if ( CKEDITOR.env.ie && contents )
+				contents = contents.replace( /\s+data-cke-expando=".*?"/g, '' );
+
+			this.contents = contents;
+
+			if ( !contentsOnly ) {
+				var selection = contents && editor.getSelection();
+				this.bookmarks = selection && selection.createBookmarks2( true );
+			}
+
+			editor.fire( 'afterUndoImage' );
+		};
+
+	// Attributes that browser may changing them when setting via innerHTML.
+	var protectedAttrs = /\b(?:href|src|name)="[^"]*?"/gi;
+
+	Image.prototype = {
+		equalsContent: function( otherImage ) {
+			var thisContents = this.contents,
+				otherContents = otherImage.contents;
+
+			// For IE6/7 : Comparing only the protected attribute values but not the original ones.(#4522)
+			if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) ) {
+				thisContents = thisContents.replace( protectedAttrs, '' );
+				otherContents = otherContents.replace( protectedAttrs, '' );
+			}
+
+			if ( thisContents != otherContents )
+				return false;
+
+			return true;
+		},
+
+		equalsSelection: function( otherImage ) {
+			var bookmarksA = this.bookmarks,
+				bookmarksB = otherImage.bookmarks;
+
+			if ( bookmarksA || bookmarksB ) {
+				if ( !bookmarksA || !bookmarksB || bookmarksA.length != bookmarksB.length )
+					return false;
+
+				for ( var i = 0; i < bookmarksA.length; i++ ) {
+					var bookmarkA = bookmarksA[ i ],
+						bookmarkB = bookmarksB[ i ];
+
+					if ( bookmarkA.startOffset != bookmarkB.startOffset || bookmarkA.endOffset != bookmarkB.endOffset || !CKEDITOR.tools.arrayCompare( bookmarkA.start, bookmarkB.start ) || !CKEDITOR.tools.arrayCompare( bookmarkA.end, bookmarkB.end ) )
+						return false;
+				}
+			}
+
+			return true;
+		}
+	};
+
+	/**
+	 * Main logic for the Redo/Undo feature.
+	 *
+	 * **Note:** This class is not accessible from the global scope.
+	 *
+	 * @private
+	 * @class CKEDITOR.plugins.undo.UndoManager
+	 * @constructor Creates an UndoManager class instance.
+	 * @param {CKEDITOR.editor} editor
+	 */
+	function UndoManager( editor ) {
+		this.editor = editor;
+
+		// Reset the undo stack.
+		this.reset();
+	}
+
+	UndoManager.prototype = {
+		/**
+		 * When `locked` property is not `null`, the undo manager is locked, so
+		 * operations like `save` or `update` are forbidden.
+		 *
+		 * The manager can be locked/unlocked by the {@link #lock} and {@link #unlock} methods.
+		 *
+		 * @private
+		 * @property {Object} [locked=null]
+		 */
+
+		/**
+		 * Handles keystroke support for the undo manager. It is called whenever a keystroke that
+		 * can change the editor contents is pressed.
+		 *
+		 * @param {Number} keystroke The key code.
+		 * @param {Boolean} isCharacter If `true`, it is a character ('a', '1', '&', ...). Otherwise it is the remove key (*Delete* or *Backspace*).
+		 */
+		type: function( keystroke, isCharacter ) {
+			// Create undo snap for every different modifier key.
+			var modifierSnapshot = ( !isCharacter && keystroke != this.lastKeystroke );
+
+			// Create undo snap on the following cases:
+			// 1. Just start to type .
+			// 2. Typing some content after a modifier.
+			// 3. Typing some content after make a visible selection.
+			var startedTyping = !this.typing || ( isCharacter && !this.wasCharacter );
+
+			var editor = this.editor;
+
+			if ( startedTyping || modifierSnapshot ) {
+				var beforeTypeImage = new Image( editor ),
+					beforeTypeCount = this.snapshots.length;
+
+				// Use setTimeout, so we give the necessary time to the
+				// browser to insert the character into the DOM.
+				CKEDITOR.tools.setTimeout( function() {
+					var currentSnapshot = editor.getSnapshot();
+
+					// In IE, we need to remove the expando attributes.
+					if ( CKEDITOR.env.ie )
+						currentSnapshot = currentSnapshot.replace( /\s+data-cke-expando=".*?"/g, '' );
+
+					// If changes have taken place, while not been captured yet (#8459),
+					// compensate the snapshot.
+					if ( beforeTypeImage.contents != currentSnapshot && beforeTypeCount == this.snapshots.length ) {
+						// It's safe to now indicate typing state.
+						this.typing = true;
+
+						// This's a special save, with specified snapshot
+						// and without auto 'fireChange'.
+						if ( !this.save( false, beforeTypeImage, false ) )
+							// Drop future snapshots.
+							this.snapshots.splice( this.index + 1, this.snapshots.length - this.index - 1 );
+
+						this.hasUndo = true;
+						this.hasRedo = false;
+
+						this.typesCount = 1;
+						this.modifiersCount = 1;
+
+						this.onChange();
+					}
+				}, 0, this );
+			}
+
+			this.lastKeystroke = keystroke;
+			this.wasCharacter = isCharacter;
+
+			// Create undo snap after typed too much (over 25 times).
+			if ( !isCharacter ) {
+				this.typesCount = 0;
+				this.modifiersCount++;
+
+				if ( this.modifiersCount > 25 ) {
+					this.save( false, null, false );
+					this.modifiersCount = 1;
+				} else {
+					setTimeout( function() {
+						editor.fire( 'change' );
+					}, 0 );
+				}
+			} else {
+				this.modifiersCount = 0;
+				this.typesCount++;
+
+				if ( this.typesCount > 25 ) {
+					this.save( false, null, false );
+					this.typesCount = 1;
+				} else {
+					setTimeout( function() {
+						editor.fire( 'change' );
+					}, 0 );
+				}
+			}
+
+		},
+
+		/**
+		 * Resets the undo stack.
+		 */
+		reset: function() {
+			// Remember last pressed key.
+			this.lastKeystroke = 0;
+
+			// Stack for all the undo and redo snapshots, they're always created/removed
+			// in consistency.
+			this.snapshots = [];
+
+			// Current snapshot history index.
+			this.index = -1;
+
+			this.limit = this.editor.config.undoStackSize || 20;
+
+			this.currentImage = null;
+
+			this.hasUndo = false;
+			this.hasRedo = false;
+			this.locked = null;
+
+			this.resetType();
+		},
+
+		/**
+		 * Resets all typing variables.
+		 *
+		 * @see #type
+		 */
+		resetType: function() {
+			this.typing = false;
+			delete this.lastKeystroke;
+			this.typesCount = 0;
+			this.modifiersCount = 0;
+		},
+
+		fireChange: function() {
+			this.hasUndo = !!this.getNextImage( true );
+			this.hasRedo = !!this.getNextImage( false );
+			// Reset typing
+			this.resetType();
+			this.onChange();
+		},
+
+		/**
+		 * Saves a snapshot of the document image for later retrieval.
+		 */
+		save: function( onContentOnly, image, autoFireChange ) {
+			// Do not change snapshots stack when locked.
+			if ( this.locked )
+				return false;
+
+			var snapshots = this.snapshots;
+
+			// Get a content image.
+			if ( !image )
+				image = new Image( this.editor );
+
+			// Do nothing if it was not possible to retrieve an image.
+			if ( image.contents === false )
+				return false;
+
+			// Check if this is a duplicate. In such case, do nothing.
+			if ( this.currentImage ) {
+				if ( image.equalsContent( this.currentImage ) ) {
+					if ( onContentOnly )
+						return false;
+
+					if ( image.equalsSelection( this.currentImage ) )
+						return false;
+				} else
+					this.editor.fire( 'change' );
+
+			}
+
+			// Drop future snapshots.
+			snapshots.splice( this.index + 1, snapshots.length - this.index - 1 );
+
+			// If we have reached the limit, remove the oldest one.
+			if ( snapshots.length == this.limit )
+				snapshots.shift();
+
+			// Add the new image, updating the current index.
+			this.index = snapshots.push( image ) - 1;
+
+			this.currentImage = image;
+
+			if ( autoFireChange !== false )
+				this.fireChange();
+			return true;
+		},
+
+		restoreImage: function( image ) {
+			// Bring editor focused to restore selection.
+			var editor = this.editor,
+				sel;
+
+			if ( image.bookmarks ) {
+				editor.focus();
+				// Retrieve the selection beforehand. (#8324)
+				sel = editor.getSelection();
+			}
+
+			// Start transaction - do not allow any mutations to the
+			// snapshots stack done when selecting bookmarks (much probably
+			// by selectionChange listener).
+			this.locked = 1;
+
+			this.editor.loadSnapshot( image.contents );
+
+			if ( image.bookmarks )
+				sel.selectBookmarks( image.bookmarks );
+			else if ( CKEDITOR.env.ie ) {
+				// IE BUG: If I don't set the selection to *somewhere* after setting
+				// document contents, then IE would create an empty paragraph at the bottom
+				// the next time the document is modified.
+				var $range = this.editor.document.getBody().$.createTextRange();
+				$range.collapse( true );
+				$range.select();
+			}
+
+			this.locked = 0;
+
+			this.index = image.index;
+			this.currentImage = this.snapshots[ this.index ];
+
+			// Update current image with the actual editor
+			// content, since actualy content may differ from
+			// the original snapshot due to dom change. (#4622)
+			this.update();
+			this.fireChange();
+
+			editor.fire( 'change' );
+		},
+
+		// Get the closest available image.
+		getNextImage: function( isUndo ) {
+			var snapshots = this.snapshots,
+				currentImage = this.currentImage,
+				image, i;
+
+			if ( currentImage ) {
+				if ( isUndo ) {
+					for ( i = this.index - 1; i >= 0; i-- ) {
+						image = snapshots[ i ];
+						if ( !currentImage.equalsContent( image ) ) {
+							image.index = i;
+							return image;
+						}
+					}
+				} else {
+					for ( i = this.index + 1; i < snapshots.length; i++ ) {
+						image = snapshots[ i ];
+						if ( !currentImage.equalsContent( image ) ) {
+							image.index = i;
+							return image;
+						}
+					}
+				}
+			}
+
+			return null;
+		},
+
+		/**
+		 * Checks the current redo state.
+		 *
+		 * @returns {Boolean} Whether the document has a previous state to retrieve.
+		 */
+		redoable: function() {
+			return this.enabled && this.hasRedo;
+		},
+
+		/**
+		 * Checks the current undo state.
+		 *
+		 * @returns {Boolean} Whether the document has a future state to restore.
+		 */
+		undoable: function() {
+			return this.enabled && this.hasUndo;
+		},
+
+		/**
+		 * Performs undo on current index.
+		 */
+		undo: function() {
+			if ( this.undoable() ) {
+				this.save( true );
+
+				var image = this.getNextImage( true );
+				if ( image )
+					return this.restoreImage( image ), true;
+			}
+
+			return false;
+		},
+
+		/**
+		 * Performs redo on current index.
+		 */
+		redo: function() {
+			if ( this.redoable() ) {
+				// Try to save. If no changes have been made, the redo stack
+				// will not change, so it will still be redoable.
+				this.save( true );
+
+				// If instead we had changes, we can't redo anymore.
+				if ( this.redoable() ) {
+					var image = this.getNextImage( false );
+					if ( image )
+						return this.restoreImage( image ), true;
+				}
+			}
+
+			return false;
+		},
+
+		/**
+		 * Updates the last snapshot of the undo stack with the current editor content.
+		 *
+		 * @param {CKEDITOR.plugins.undo.Image} [newImage] The image which will replace the current one.
+		 * If not set defaults to image taken from editor.
+		 */
+		update: function( newImage ) {
+			// Do not change snapshots stack is locked.
+			if ( this.locked )
+				return;
+
+			if ( !newImage )
+				newImage = new Image( this.editor );
+
+			var i = this.index,
+				snapshots = this.snapshots;
+
+			// Find all previous snapshots made for the same content (which differ
+			// only by selection) and replace all of them with the current image.
+			while ( i > 0 && this.currentImage.equalsContent( snapshots[ i - 1 ] ) )
+				i -= 1;
+
+			snapshots.splice( i, this.index - i + 1, newImage );
+			this.index = i;
+			this.currentImage = newImage;
+		},
+
+		/**
+		 * Locks the snapshot stack to prevent any save/update operations and when necessary,
+		 * updates the tip of the snapshot stack with the DOM changes introduced during the
+		 * locked period, after the {@link #unlock} method is called.
+		 *
+		 * It is mainly used to ensure any DOM operations that should not be recorded
+		 * (e.g. auto paragraphing) are not added to the stack.
+		 *
+		 * **Note:** For every `lock` call you must call {@link #unlock} once to unlock the undo manager.
+		 *
+		 * @since 4.0
+		 * @param {Boolean} [dontUpdate] When set to `true`, the last snapshot will not be updated
+		 * with current contents and selection. By default, if undo manager was up to date when the lock started,
+		 * the last snapshot will be updated to the current state when unlocking. This means that all changes
+		 * done during the lock will be merged into the previous snapshot or the next one. Use this option to gain
+		 * more control over this behavior. For example, it is possible to group changes done during the lock into
+		 * a separate snapshot.
+		 */
+		lock: function( dontUpdate ) {
+			if ( !this.locked ) {
+				if ( dontUpdate )
+					this.locked = { level: 1 };
+				else {
+					// Make a contents image. Don't include bookmarks, because:
+					// * we don't compare them,
+					// * there's a chance that DOM has been changed since
+					// locked (e.g. fake) selection was made, so createBookmark2 could fail.
+					// http://dev.ckeditor.com/ticket/11027#comment:3
+					var imageBefore = new Image( this.editor, true );
+
+					// If current editor content matches the tip of snapshot stack,
+					// the stack tip must be updated by unlock, to include any changes made
+					// during this period.
+					var matchedTip = this.currentImage && this.currentImage.equalsContent( imageBefore );
+
+					this.locked = { update: matchedTip ? imageBefore : null, level: 1 };
+				}
+			}
+			// Increase the level of lock.
+			else
+				this.locked.level++;
+		},
+
+		/**
+		 * Unlocks the snapshot stack and checks to amend the last snapshot.
+		 *
+		 * See {@link #lock} for more details.
+		 *
+		 * @since 4.0
+		 */
+		unlock: function() {
+			if ( this.locked ) {
+				// Decrease level of lock and check if equals 0, what means that undoM is completely unlocked.
+				if ( !--this.locked.level ) {
+					var updateImage = this.locked.update,
+						newImage = updateImage && new Image( this.editor, true );
+
+					this.locked = null;
+
+					if ( updateImage && !updateImage.equalsContent( newImage ) )
+						this.update();
+				}
+			}
+		}
+	};
+} )();
+
+/**
+ * The number of undo steps to be saved. The higher value is set, the more
+ * memory is used for it.
+ *
+ *		config.undoStackSize = 50;
+ *
+ * @cfg {Number} [undoStackSize=20]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Fired when the editor is about to save an undo snapshot. This event can be
+ * fired by plugins and customizations to make the editor save undo snapshots.
+ *
+ * @event saveSnapshot
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
+
+/**
+ * Fired before an undo image is to be taken. An undo image represents the
+ * editor state at some point. It is saved into the undo store, so the editor is
+ * able to recover the editor state on undo and redo operations.
+ *
+ * @since 3.5.3
+ * @event beforeUndoImage
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @see CKEDITOR.editor#afterUndoImage
+ */
+
+/**
+ * Fired after an undo image is taken. An undo image represents the
+ * editor state at some point. It is saved into the undo store, so the editor is
+ * able to recover the editor state on undo and redo operations.
+ *
+ * @since 3.5.3
+ * @event afterUndoImage
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @see CKEDITOR.editor#beforeUndoImage
+ */
+
+/**
+ * Fired when the content of the editor is changed.
+ *
+ * Due to performance reasons, it is not verified if the content really changed.
+ * The editor instead watches several editing actions that usually result in
+ * changes. This event may thus in some cases be fired when no changes happen
+ * or may even get fired twice.
+ *
+ * If it is important not to get the change event too often, you should compare the
+ * previous and the current editor content inside the event listener.
+ *
+ * @since 4.2
+ * @event change
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/plugins/wysiwygarea/plugin.js b/lam/templates/lib/extra/ckeditor/plugins/wysiwygarea/plugin.js
new file mode 100644
index 00000000..0b843a85
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/plugins/wysiwygarea/plugin.js
@@ -0,0 +1,653 @@
+/**
+ * @license Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview The "wysiwygarea" plugin. It registers the "wysiwyg" editing
+ *		mode, which handles the main editing area space.
+ */
+
+( function() {
+	CKEDITOR.plugins.add( 'wysiwygarea', {
+		init: function( editor ) {
+			if ( editor.config.fullPage ) {
+				editor.addFeature( {
+					allowedContent: 'html head title; style [media,type]; body (*)[id]; meta link [*]',
+					requiredContent: 'body'
+				} );
+			}
+
+			editor.addMode( 'wysiwyg', function( callback ) {
+				var src = 'document.open();' +
+					// In IE, the document domain must be set any time we call document.open().
+					( CKEDITOR.env.ie ? '(' + CKEDITOR.tools.fixDomain + ')();' : '' ) +
+					'document.close();';
+
+				// With IE, the custom domain has to be taken care at first,
+				// for other browers, the 'src' attribute should be left empty to
+				// trigger iframe's 'load' event.
+				src = CKEDITOR.env.air ? 'javascript:void(0)' : CKEDITOR.env.ie ? 'javascript:void(function(){' + encodeURIComponent( src ) + '}())'
+					:
+					'';
+
+				var iframe = CKEDITOR.dom.element.createFromHtml( '<iframe src="' + src + '" frameBorder="0"></iframe>' );
+				iframe.setStyles( { width: '100%', height: '100%' } );
+				iframe.addClass( 'cke_wysiwyg_frame cke_reset' );
+
+				var contentSpace = editor.ui.space( 'contents' );
+				contentSpace.append( iframe );
+
+
+				// Asynchronous iframe loading is only required in IE>8 and Gecko (other reasons probably).
+				// Do not use it on WebKit as it'll break the browser-back navigation.
+				var useOnloadEvent = CKEDITOR.env.ie || CKEDITOR.env.gecko;
+				if ( useOnloadEvent )
+					iframe.on( 'load', onLoad );
+
+				var frameLabel = editor.title,
+					frameDesc = editor.lang.common.editorHelp;
+
+				if ( frameLabel ) {
+					if ( CKEDITOR.env.ie )
+						frameLabel += ', ' + frameDesc;
+
+					iframe.setAttribute( 'title', frameLabel );
+				}
+
+				var labelId = CKEDITOR.tools.getNextId(),
+					desc = CKEDITOR.dom.element.createFromHtml( '<span id="' + labelId + '" class="cke_voice_label">' + frameDesc + '</span>' );
+
+				contentSpace.append( desc, 1 );
+
+				// Remove the ARIA description.
+				editor.on( 'beforeModeUnload', function( evt ) {
+					evt.removeListener();
+					desc.remove();
+				} );
+
+				iframe.setAttributes( {
+					'aria-describedby': labelId,
+					tabIndex: editor.tabIndex,
+					allowTransparency: 'true'
+				} );
+
+				// Execute onLoad manually for all non IE||Gecko browsers.
+				!useOnloadEvent && onLoad();
+
+				if ( CKEDITOR.env.webkit ) {
+					// Webkit: iframe size doesn't auto fit well. (#7360)
+					var onResize = function() {
+						// Hide the iframe to get real size of the holder. (#8941)
+						contentSpace.setStyle( 'width', '100%' );
+
+						iframe.hide();
+						iframe.setSize( 'width', contentSpace.getSize( 'width' ) );
+						contentSpace.removeStyle( 'width' );
+						iframe.show();
+					};
+
+					iframe.setCustomData( 'onResize', onResize );
+
+					CKEDITOR.document.getWindow().on( 'resize', onResize );
+				}
+
+				editor.fire( 'ariaWidget', iframe );
+
+				function onLoad( evt ) {
+					evt && evt.removeListener();
+					editor.editable( new framedWysiwyg( editor, iframe.$.contentWindow.document.body ) );
+					editor.setData( editor.getData( 1 ), callback );
+				}
+			} );
+		}
+	} );
+
+	function onDomReady( win ) {
+		var editor = this.editor,
+			doc = win.document,
+			body = doc.body;
+
+		// Remove helper scripts from the DOM.
+		var script = doc.getElementById( 'cke_actscrpt' );
+		script && script.parentNode.removeChild( script );
+		script = doc.getElementById( 'cke_shimscrpt' );
+		script && script.parentNode.removeChild( script );
+
+		if ( CKEDITOR.env.gecko ) {
+			// Force Gecko to change contentEditable from false to true on domReady
+			// (because it's previously set to true on iframe's body creation).
+			// Otherwise del/backspace and some other editable features will be broken in Fx <4
+			// See: #107 and https://bugzilla.mozilla.org/show_bug.cgi?id=440916
+			body.contentEditable = false;
+
+			// Remove any leading <br> which is between the <body> and the comment.
+			// This one fixes Firefox 3.6 bug: the browser inserts a leading <br>
+			// on document.write if the body has contenteditable="true".
+			if ( CKEDITOR.env.version < 20000 ) {
+				body.innerHTML = body.innerHTML.replace( /^.*<!-- cke-content-start -->/, '' );
+
+				// The above hack messes up the selection in FF36.
+				// To clean this up, manually select collapsed range that
+				// starts within the body.
+				setTimeout( function() {
+					var range = new CKEDITOR.dom.range( new CKEDITOR.dom.document( doc ) );
+					range.setStart( new CKEDITOR.dom.node( body ), 0 );
+					editor.getSelection().selectRanges( [ range ] );
+				}, 0 );
+			}
+		}
+
+		body.contentEditable = true;
+
+		if ( CKEDITOR.env.ie ) {
+			// Don't display the focus border.
+			body.hideFocus = true;
+
+			// Disable and re-enable the body to avoid IE from
+			// taking the editing focus at startup. (#141 / #523)
+			body.disabled = true;
+			body.removeAttribute( 'disabled' );
+		}
+
+		delete this._.isLoadingData;
+
+		// Play the magic to alter element reference to the reloaded one.
+		this.$ = body;
+
+		doc = new CKEDITOR.dom.document( doc );
+
+		this.setup();
+
+		if ( CKEDITOR.env.ie ) {
+			doc.getDocumentElement().addClass( doc.$.compatMode );
+
+			// Prevent IE from leaving new paragraph after deleting all contents in body. (#6966)
+			editor.config.enterMode != CKEDITOR.ENTER_P && this.attachListener( doc, 'selectionchange', function() {
+				var body = doc.getBody(),
+					sel = editor.getSelection(),
+					range = sel && sel.getRanges()[ 0 ];
+
+				if ( range && body.getHtml().match( /^<p>(?:&nbsp;|<br>)<\/p>$/i ) && range.startContainer.equals( body ) ) {
+					// Avoid the ambiguity from a real user cursor position.
+					setTimeout( function() {
+						range = editor.getSelection().getRanges()[ 0 ];
+						if ( !range.startContainer.equals( 'body' ) ) {
+							body.getFirst().remove( 1 );
+							range.moveToElementEditEnd( body );
+							range.select();
+						}
+					}, 0 );
+				}
+			} );
+		}
+
+		// Fix problem with cursor not appearing in Webkit and IE11+ when clicking below the body (#10945, #10906).
+		// Fix for older IEs (8-10 and QM) is placed inside selection.js.
+		if ( CKEDITOR.env.webkit || ( CKEDITOR.env.ie && CKEDITOR.env.version > 10 ) ) {
+			doc.getDocumentElement().on( 'mousedown', function( evt ) {
+				if ( evt.data.getTarget().is( 'html' ) ) {
+					// IE needs this timeout. Webkit does not, but it does not cause problems too.
+					setTimeout( function() {
+						editor.editable().focus();
+					} );
+				}
+			} );
+		}
+
+		// ## START : disableNativeTableHandles and disableObjectResizing settings.
+
+		// Enable dragging of position:absolute elements in IE.
+		try {
+			editor.document.$.execCommand( '2D-position', false, true );
+		} catch ( e ) {}
+
+		// IE, Opera and Safari may not support it and throw errors.
+		try {
+			editor.document.$.execCommand( 'enableInlineTableEditing', false, !editor.config.disableNativeTableHandles );
+		} catch ( e ) {}
+
+		if ( editor.config.disableObjectResizing ) {
+			try {
+				this.getDocument().$.execCommand( 'enableObjectResizing', false, false );
+			} catch ( e ) {
+				// For browsers in which the above method failed, we can cancel the resizing on the fly (#4208)
+				this.attachListener( this, CKEDITOR.env.ie ? 'resizestart' : 'resize', function( evt ) {
+					evt.data.preventDefault();
+				} );
+			}
+		}
+
+		if ( CKEDITOR.env.gecko || CKEDITOR.env.ie && editor.document.$.compatMode == 'CSS1Compat' ) {
+			this.attachListener( this, 'keydown', function( evt ) {
+				var keyCode = evt.data.getKeystroke();
+
+				// PageUp OR PageDown
+				if ( keyCode == 33 || keyCode == 34 ) {
+					// PageUp/PageDown scrolling is broken in document
+					// with standard doctype, manually fix it. (#4736)
+					if ( CKEDITOR.env.ie ) {
+						setTimeout( function() {
+							editor.getSelection().scrollIntoView();
+						}, 0 );
+					}
+					// Page up/down cause editor selection to leak
+					// outside of editable thus we try to intercept
+					// the behavior, while it affects only happen
+					// when editor contents are not overflowed. (#7955)
+					else if ( editor.window.$.innerHeight > this.$.offsetHeight ) {
+						var range = editor.createRange();
+						range[ keyCode == 33 ? 'moveToElementEditStart' : 'moveToElementEditEnd' ]( this );
+						range.select();
+						evt.data.preventDefault();
+					}
+				}
+			} );
+		}
+
+		if ( CKEDITOR.env.ie ) {
+			// [IE] Iframe will still keep the selection when blurred, if
+			// focus is moved onto a non-editing host, e.g. link or button, but
+			// it becomes a problem for the object type selection, since the resizer
+			// handler attached on it will mark other part of the UI, especially
+			// for the dialog. (#8157)
+			// [IE<8 & Opera] Even worse For old IEs, the cursor will not vanish even if
+			// the selection has been moved to another text input in some cases. (#4716)
+			//
+			// Now the range restore is disabled, so we simply force IE to clean
+			// up the selection before blur.
+			this.attachListener( doc, 'blur', function() {
+				// Error proof when the editor is not visible. (#6375)
+				try {
+					doc.$.selection.empty();
+				} catch ( er ) {}
+			} );
+		}
+
+		// ## END
+
+
+		var title = editor.document.getElementsByTag( 'title' ).getItem( 0 );
+		title.data( 'cke-title', editor.document.$.title );
+
+		// [IE] JAWS will not recognize the aria label we used on the iframe
+		// unless the frame window title string is used as the voice label,
+		// backup the original one and restore it on output.
+		if ( CKEDITOR.env.ie )
+			editor.document.$.title = this._.docTitle;
+
+		CKEDITOR.tools.setTimeout( function() {
+			editor.fire( 'contentDom' );
+
+			if ( this._.isPendingFocus ) {
+				editor.focus();
+				this._.isPendingFocus = false;
+			}
+
+			setTimeout( function() {
+				editor.fire( 'dataReady' );
+			}, 0 );
+
+			// IE BUG: IE might have rendered the iframe with invisible contents.
+			// (#3623). Push some inconsequential CSS style changes to force IE to
+			// refresh it.
+			//
+			// Also, for some unknown reasons, short timeouts (e.g. 100ms) do not
+			// fix the problem. :(
+			if ( CKEDITOR.env.ie ) {
+				setTimeout( function() {
+					if ( editor.document ) {
+						var $body = editor.document.$.body;
+						$body.runtimeStyle.marginBottom = '0px';
+						$body.runtimeStyle.marginBottom = '';
+					}
+				}, 1000 );
+			}
+		}, 0, this );
+	}
+
+	var framedWysiwyg = CKEDITOR.tools.createClass( {
+		$: function( editor ) {
+			this.base.apply( this, arguments );
+
+			this._.frameLoadedHandler = CKEDITOR.tools.addFunction( function( win ) {
+				// Avoid opening design mode in a frame window thread,
+				// which will cause host page scrolling.(#4397)
+				CKEDITOR.tools.setTimeout( onDomReady, 0, this, win );
+			}, this );
+
+			this._.docTitle = this.getWindow().getFrame().getAttribute( 'title' );
+		},
+
+		base: CKEDITOR.editable,
+
+		proto: {
+			setData: function( data, isSnapshot ) {
+				var editor = this.editor;
+
+				if ( isSnapshot ) {
+					this.setHtml( data );
+					// Fire dataReady for the consistency with inline editors
+					// and because it makes sense. (#10370)
+					editor.fire( 'dataReady' );
+				}
+				else {
+					this._.isLoadingData = true;
+					editor._.dataStore = { id: 1 };
+
+					var config = editor.config,
+						fullPage = config.fullPage,
+						docType = config.docType;
+
+					// Build the additional stuff to be included into <head>.
+					var headExtra = CKEDITOR.tools.buildStyleHtml( iframeCssFixes() )
+						                .replace( /<style>/, '<style data-cke-temp="1">' );
+
+					if ( !fullPage )
+						headExtra += CKEDITOR.tools.buildStyleHtml( editor.config.contentsCss );
+
+					var baseTag = config.baseHref ? '<base href="' + config.baseHref + '" data-cke-temp="1" />' : '';
+
+					if ( fullPage ) {
+						// Search and sweep out the doctype declaration.
+						data = data.replace( /<!DOCTYPE[^>]*>/i, function( match ) {
+							editor.docType = docType = match;
+							return '';
+						} ).replace( /<\?xml\s[^\?]*\?>/i, function( match ) {
+							editor.xmlDeclaration = match;
+							return '';
+						} );
+					}
+
+					// Get the HTML version of the data.
+					data = editor.dataProcessor.toHtml( data );
+
+					if ( fullPage ) {
+						// Check if the <body> tag is available.
+						if ( !( /<body[\s|>]/ ).test( data ) )
+							data = '<body>' + data;
+
+						// Check if the <html> tag is available.
+						if ( !( /<html[\s|>]/ ).test( data ) )
+							data = '<html>' + data + '</html>';
+
+						// Check if the <head> tag is available.
+						if ( !( /<head[\s|>]/ ).test( data ) )
+							data = data.replace( /<html[^>]*>/, '$&<head><title></title></head>' );
+						else if ( !( /<title[\s|>]/ ).test( data ) )
+							data = data.replace( /<head[^>]*>/, '$&<title></title>' );
+
+						// The base must be the first tag in the HEAD, e.g. to get relative
+						// links on styles.
+						baseTag && ( data = data.replace( /<head>/, '$&' + baseTag ) );
+
+						// Inject the extra stuff into <head>.
+						// Attention: do not change it before testing it well. (V2)
+						// This is tricky... if the head ends with <meta ... content type>,
+						// Firefox will break. But, it works if we place our extra stuff as
+						// the last elements in the HEAD.
+						data = data.replace( /<\/head\s*>/, headExtra + '$&' );
+
+						// Add the DOCTYPE back to it.
+						data = docType + data;
+					} else {
+						data = config.docType +
+							'<html dir="' + config.contentsLangDirection + '"' +
+								' lang="' + ( config.contentsLanguage || editor.langCode ) + '">' +
+							'<head>' +
+								'<title>' + this._.docTitle + '</title>' +
+								baseTag +
+								headExtra +
+							'</head>' +
+							'<body' + ( config.bodyId ? ' id="' + config.bodyId + '"' : '' ) +
+								( config.bodyClass ? ' class="' + config.bodyClass + '"' : '' ) +
+							'>' +
+								data +
+							'</body>' +
+							'</html>';
+					}
+
+					if ( CKEDITOR.env.gecko ) {
+						// Hack to make Fx put cursor at the start of doc on fresh focus.
+						data = data.replace( /<body/, '<body contenteditable="true" ' );
+
+						// Another hack which is used by onDomReady to remove a leading
+						// <br> which is inserted by Firefox 3.6 when document.write is called.
+						// This additional <br> is present because of contenteditable="true"
+						if ( CKEDITOR.env.version < 20000 )
+							data = data.replace( /<body[^>]*>/, '$&<!-- cke-content-start -->'  );
+					}
+
+					// The script that launches the bootstrap logic on 'domReady', so the document
+					// is fully editable even before the editing iframe is fully loaded (#4455).
+					var bootstrapCode =
+						'<script id="cke_actscrpt" type="text/javascript"' + ( CKEDITOR.env.ie ? ' defer="defer" ' : '' ) + '>' +
+							'var wasLoaded=0;' +	// It must be always set to 0 as it remains as a window property.
+							'function onload(){' +
+								'if(!wasLoaded)' +	// FF3.6 calls onload twice when editor.setData. Stop that.
+									'window.parent.CKEDITOR.tools.callFunction(' + this._.frameLoadedHandler + ',window);' +
+								'wasLoaded=1;' +
+							'}' +
+							( CKEDITOR.env.ie ? 'onload();' : 'document.addEventListener("DOMContentLoaded", onload, false );' ) +
+						'</script>';
+
+					// For IE<9 add support for HTML5's elements.
+					// Note: this code must not be deferred.
+					if ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 ) {
+						bootstrapCode +=
+							'<script id="cke_shimscrpt">' +
+								'window.parent.CKEDITOR.tools.enableHtml5Elements(document)' +
+							'</script>';
+					}
+
+					data = data.replace( /(?=\s*<\/(:?head)>)/, bootstrapCode );
+
+					// Current DOM will be deconstructed by document.write, cleanup required.
+					this.clearCustomData();
+					this.clearListeners();
+
+					editor.fire( 'contentDomUnload' );
+
+					var doc = this.getDocument();
+
+					// Work around Firefox bug - error prune when called from XUL (#320),
+					// defer it thanks to the async nature of this method.
+					try { doc.write( data ); } catch ( e ) {
+						setTimeout( function() { doc.write( data ); }, 0 );
+					}
+				}
+			},
+
+			getData: function( isSnapshot ) {
+				if ( isSnapshot )
+					return this.getHtml();
+				else {
+					var editor = this.editor,
+						config = editor.config,
+						fullPage = config.fullPage,
+						docType = fullPage && editor.docType,
+						xmlDeclaration = fullPage && editor.xmlDeclaration,
+						doc = this.getDocument();
+
+					var data = fullPage ? doc.getDocumentElement().getOuterHtml() : doc.getBody().getHtml();
+
+					// BR at the end of document is bogus node for Mozilla. (#5293).
+					// Prevent BRs from disappearing from the end of the content
+					// while enterMode is ENTER_BR (#10146).
+					if ( CKEDITOR.env.gecko && config.enterMode != CKEDITOR.ENTER_BR )
+						data = data.replace( /<br>(?=\s*(:?$|<\/body>))/, '' );
+
+					data = editor.dataProcessor.toDataFormat( data );
+
+					if ( xmlDeclaration )
+						data = xmlDeclaration + '\n' + data;
+					if ( docType )
+						data = docType + '\n' + data;
+
+					return data;
+				}
+			},
+
+			focus: function() {
+				if ( this._.isLoadingData )
+					this._.isPendingFocus = true;
+				else
+					framedWysiwyg.baseProto.focus.call( this );
+			},
+
+			detach: function() {
+				var editor = this.editor,
+					doc = editor.document,
+					iframe = editor.window.getFrame();
+
+				framedWysiwyg.baseProto.detach.call( this );
+
+				// Memory leak proof.
+				this.clearCustomData();
+				doc.getDocumentElement().clearCustomData();
+				iframe.clearCustomData();
+				CKEDITOR.tools.removeFunction( this._.frameLoadedHandler );
+
+				var onResize = iframe.removeCustomData( 'onResize' );
+				onResize && onResize.removeListener();
+
+				// IE BUG: When destroying editor DOM with the selection remains inside
+				// editing area would break IE7/8's selection system, we have to put the editing
+				// iframe offline first. (#3812 and #5441)
+				iframe.remove();
+			}
+		}
+	} );
+
+	// DOM modification here should not bother dirty flag.(#4385)
+	function restoreDirty( editor ) {
+		if ( !editor.checkDirty() )
+			setTimeout( function() {
+			editor.resetDirty();
+		}, 0 );
+	}
+
+	function iframeCssFixes() {
+		var css = [];
+
+		// IE>=8 stricts mode doesn't have 'contentEditable' in effect
+		// on element unless it has layout. (#5562)
+		if ( CKEDITOR.document.$.documentMode >= 8 ) {
+			css.push( 'html.CSS1Compat [contenteditable=false]{min-height:0 !important}' );
+
+			var selectors = [];
+
+			for ( var tag in CKEDITOR.dtd.$removeEmpty )
+				selectors.push( 'html.CSS1Compat ' + tag + '[contenteditable=false]' );
+
+			css.push( selectors.join( ',' ) + '{display:inline-block}' );
+		}
+		// Set the HTML style to 100% to have the text cursor in affect (#6341)
+		else if ( CKEDITOR.env.gecko ) {
+			css.push( 'html{height:100% !important}' );
+			css.push( 'img:-moz-broken{-moz-force-broken-image-icon:1;min-width:24px;min-height:24px}' );
+		}
+
+		// #6341: The text cursor must be set on the editor area.
+		// #6632: Avoid having "text" shape of cursor in IE7 scrollbars.
+		css.push( 'html{cursor:text;*cursor:auto}' );
+
+		// Use correct cursor for these elements
+		css.push( 'img,input,textarea{cursor:default}' );
+
+		return css.join( '\n' );
+	}
+} )();
+
+/**
+ * Disables the ability of resize objects (image and tables) in the editing area.
+ *
+ *		config.disableObjectResizing = true;
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.disableObjectResizing = false;
+
+/**
+ * Disables the "table tools" offered natively by the browser (currently
+ * Firefox only) to make quick table editing operations, like adding or
+ * deleting rows and columns.
+ *
+ *		config.disableNativeTableHandles = false;
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.disableNativeTableHandles = true;
+
+/**
+ * Disables the built-in words spell checker if browser provides one.
+ *
+ * **Note:** Although word suggestions provided by browsers (natively) will
+ * not appear in CKEditor's default context menu,
+ * users can always reach the native context menu by holding the
+ * *Ctrl* key when right-clicking if {@link #browserContextMenuOnCtrl}
+ * is enabled or you're simply not using the context menu plugin.
+ *
+ *		config.disableNativeSpellChecker = false;
+ *
+ * @cfg
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.disableNativeSpellChecker = true;
+
+/**
+ * The CSS file(s) to be used to apply style to the contents. It should
+ * reflect the CSS used in the final pages where the contents are to be
+ * used.
+ *
+ *		config.contentsCss = '/css/mysitestyles.css';
+ *		config.contentsCss = ['/css/mysitestyles.css', '/css/anotherfile.css'];
+ *
+ * @cfg {String/Array} [contentsCss=CKEDITOR.getUrl( 'contents.css' )]
+ * @member CKEDITOR.config
+ */
+CKEDITOR.config.contentsCss = CKEDITOR.getUrl( 'contents.css' );
+
+/**
+ * Language code of  the writting language which is used to author the editor
+ * contents.
+ *
+ *		config.contentsLanguage = 'fr';
+ *
+ * @cfg {String} [contentsLanguage=same value with editor's UI language]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * The base href URL used to resolve relative and absolute URLs in the
+ * editor content.
+ *
+ *		config.baseHref = 'http://www.example.com/path/';
+ *
+ * @cfg {String} [baseHref='']
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Whether automatically create wrapping blocks around inline contents inside document body,
+ * this helps to ensure the integrality of the block enter mode.
+ *
+ * **Note:** Changing the default value might introduce unpredictable usability issues.
+ *
+ *		config.autoParagraph = false;
+ *
+ * @since 3.6
+ * @cfg {Boolean} [autoParagraph=true]
+ * @member CKEDITOR.config
+ */
+
+/**
+ * Fired when some elements are added to the document.
+ *
+ * @event ariaWidget
+ * @member CKEDITOR.editor
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {CKEDITOR.dom.element} data The element being added.
+ */
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog.css
new file mode 100644
index 00000000..31152d4c
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie.css
new file mode 100644
index 00000000..359d4574
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{padding-right:2px}.cke_rtl div.cke_dialog_ui_input_text,.cke_rtl div.cke_dialog_ui_input_password{padding-left:2px}.cke_rtl div.cke_dialog_ui_input_text{padding-right:1px}.cke_rtl .cke_dialog_ui_vbox_child,.cke_rtl .cke_dialog_ui_hbox_child,.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_last{padding-right:2px!important}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie7.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie7.css
new file mode 100644
index 00000000..3973bd10
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie7.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{padding-right:2px}.cke_rtl div.cke_dialog_ui_input_text,.cke_rtl div.cke_dialog_ui_input_password{padding-left:2px}.cke_rtl div.cke_dialog_ui_input_text{padding-right:1px}.cke_rtl .cke_dialog_ui_vbox_child,.cke_rtl .cke_dialog_ui_hbox_child,.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_last{padding-right:2px!important}.cke_dialog_title{margin-bottom:22px}.cke_single_page .cke_dialog_title{margin-bottom:10px}.cke_single_page .cke_dialog_footer{margin-top:22px}.cke_dialog_footer .cke_resizer{margin-top:27px}.cke_dialog_tabs{top:33px}.cke_dialog_footer_buttons{position:static;margin-top:7px;margin-right:24px}.cke_rtl .cke_dialog_footer_buttons{margin-right:0;margin-left:24px}.cke_rtl .cke_dialog_close_button{margin-top:0;position:absolute;left:10px;top:5px}span.cke_dialog_ui_buttonm{margin:2px 0}.cke_dialog_ui_checkbox_input,.cke_dialog_ui_ratio_input,.cke_btn_reset,.cke_btn_locked,.cke_btn_unlocked{border:1px solid transparent!important}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{position:absolute}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{height:14px;position:relative}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie8.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie8.css
new file mode 100644
index 00000000..ddbd6012
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_ie8.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{padding-right:2px}.cke_rtl div.cke_dialog_ui_input_text,.cke_rtl div.cke_dialog_ui_input_password{padding-left:2px}.cke_rtl div.cke_dialog_ui_input_text{padding-right:1px}.cke_rtl .cke_dialog_ui_vbox_child,.cke_rtl .cke_dialog_ui_hbox_child,.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_last{padding-right:2px!important}.cke_rtl .cke_dialog_footer_buttons td{padding-left:2px}.cke_rtl .cke_dialog_close_button{left:8px}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog_iequirks.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_iequirks.css
new file mode 100644
index 00000000..04ba2ee5
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_iequirks.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{padding-right:2px}.cke_rtl div.cke_dialog_ui_input_text,.cke_rtl div.cke_dialog_ui_input_password{padding-left:2px}.cke_rtl div.cke_dialog_ui_input_text{padding-right:1px}.cke_rtl .cke_dialog_ui_vbox_child,.cke_rtl .cke_dialog_ui_hbox_child,.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_last{padding-right:2px!important}.cke_dialog_title{margin-bottom:22px}.cke_dialog_page_contents{position:absolute}.cke_single_page .cke_dialog_title{margin-bottom:10px}.cke_dialog_close_button{top:27px;background-image:url(images/sprites_ie6.png)}.cke_dialog_footer .cke_resizer{margin-top:27px}.cke_dialog_tabs{display:block;top:33px;margin-top:33px}.cke_rtl .cke_dialog_ui_labeled_content{_width:95%}a.cke_dialog_ui_button{background:0;padding:0}a.cke_dialog_ui_button span{width:70px;padding:5px 15px;text-align:center;color:#3b3b1f;background:#53d9f0 none;display:inline-block;cursor:default}a.cke_dialog_ui_button_ok span{background-image:none;background-color:#b8e834;margin-right:0}a.cke_dialog_ui_button_cancel span{background-image:none;background-color:#f65d20;margin-right:0}a.cke_dialog_ui_button:hover span,a.cke_dialog_ui_button:focus span,a.cke_dialog_ui_button:active span{background-image:none;background:#f7a922}div.cke_dialog_ui_input_password,textarea.cke_dialog_ui_input_textarea{width:99%}.cke_dialog_ui_checkbox_input,.cke_dialog_ui_ratio_input,.cke_btn_reset,.cke_btn_locked,.cke_btn_unlocked{border:1px solid red!important;filter:chroma(color=red)}.cke_dialog_ui_focused,.cke_btn_over{border:1px dotted #696969!important}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/dialog_opera.css b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_opera.css
new file mode 100644
index 00000000..538f321a
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/dialog_opera.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;border:solid 1px #ddd;padding:5px;background-color:#fff;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:14px;padding:3px 3px 8px;cursor:move;position:relative;border-bottom:1px solid #eee}.cke_dialog_contents{background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;overflow:auto;padding:17px 10px 5px 10px;-moz-border-radius-topleft:5px;-moz-border-radius-topright:5px;-webkit-border-top-left-radius:5px;-webkit-border-top-right-radius:5px;border-top-left-radius:5px;border-top-right-radius:5px;margin-top:22px}.cke_dialog_contents_body{overflow:auto;padding:17px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;background-color:#ebebeb;border:solid 1px #fff;border-bottom:0;-moz-border-radius-bottomleft:5px;-moz-border-radius-bottomright:5px;-webkit-border-bottom-left-radius:5px;-webkit-border-bottom-right-radius:5px;border-bottom-left-radius:5px;border-bottom-right-radius:5px}.cke_rtl .cke_dialog_footer{text-align:left}.cke_dialog_footer .cke_resizer{margin-top:24px}.cke_dialog_footer .cke_resizer_ltr{border-right-color:#ccc}.cke_dialog_footer .cke_resizer_rtl{border-left-color:#ccc}.cke_hc .cke_dialog_footer .cke_resizer{margin-bottom:1px}.cke_hc .cke_dialog_footer .cke_resizer_ltr{margin-right:1px}.cke_hc .cke_dialog_footer .cke_resizer_rtl{margin-left:1px}.cke_dialog_tabs{height:23px;display:inline-block;margin-left:10px;margin-right:10px;margin-top:11px;position:absolute;z-index:2}.cke_rtl .cke_dialog_tabs{right:10px}a.cke_dialog_tab{background-image:url(images/sprites.png);background-repeat:repeat-x;background-position:0 -1323px;background-color:#ebebeb;height:14px;padding:4px 8px;display:inline-block;cursor:pointer}a.cke_dialog_tab:hover{background-color:#f1f1e3}.cke_hc a.cke_dialog_tab:hover{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_selected{background-position:0 -1279px;cursor:default}.cke_hc a.cke_dialog_tab_selected{padding:2px 6px!important;border-width:3px}a.cke_dialog_tab_disabled{color:#bababa;cursor:default}.cke_single_page .cke_dialog_tabs{display:none}.cke_single_page .cke_dialog_contents{padding-top:5px;margin-top:10px}.cke_dialog_close_button{background-image:url(images/sprites.png);background-repeat:no-repeat;background-position:0 -1022px;position:absolute;cursor:pointer;text-align:center;height:20px;width:20px;top:5px}.cke_dialog_close_button span{display:none}.cke_dialog_close_button:hover{background-position:0 -1045px}.cke_ltr .cke_dialog_close_button{right:10px}.cke_rtl .cke_dialog_close_button{left:10px}.cke_dialog_close_button{top:7px}div.cke_disabled .cke_dialog_ui_labeled_content *{background-color:#a0a0a0;cursor:default}.cke_dialog_ui_vbox table,.cke_dialog_ui_hbox table{margin:auto}.cke_dialog_ui_vbox_child{padding:5px 0}.cke_dialog_ui_hbox{width:100%}.cke_dialog_ui_hbox_first,.cke_dialog_ui_hbox_child,.cke_dialog_ui_hbox_last{vertical-align:top}.cke_ltr .cke_dialog_ui_hbox_first,.cke_ltr .cke_dialog_ui_hbox_child{padding-right:10px}.cke_rtl .cke_dialog_ui_hbox_first,.cke_rtl .cke_dialog_ui_hbox_child{padding-left:10px}input.cke_dialog_ui_input_text,input.cke_dialog_ui_input_password{background-color:white;border:0;padding:0;width:100%;height:14px}div.cke_dialog_ui_input_text,div.cke_dialog_ui_input_password{background-color:white;border:1px solid #a0a0a0;padding:1px 0}textarea.cke_dialog_ui_input_textarea{background-color:white;border:0;padding:0;width:100%;overflow:auto;resize:none}div.cke_dialog_ui_input_textarea{background-color:white;border:1px solid #a0a0a0;padding:1px 0}a.cke_dialog_ui_button{border-collapse:separate;cursor:default;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:transparent url(images/sprites.png) repeat-x scroll 0 -1069px;text-align:center;display:inline-block}.cke_dialog_footer_buttons a.cke_dialog_ui_button span{width:60px;padding:5px 20px 5px;display:inline-block}a.cke_dialog_ui_button_ok{background-position:0 -1144px}a.cke_dialog_ui_button_ok span{background:transparent url(images/sprites.png) no-repeat scroll right -1216px}.cke_rtl a.cke_dialog_ui_button_ok span{background-position:left -1216px}a.cke_dialog_ui_button_cancel{background-position:0 -1105px}a.cke_dialog_ui_button_cancel span{background:transparent url(images/sprites.png) no-repeat scroll right -1242px}.cke_rtl a.cke_dialog_ui_button_cancel span{background-position:left -1242px}span.cke_dialog_ui_button{padding:2px 10px;text-align:center;color:#222;display:inline-block;cursor:default;min-width:60px}a.cke_dialog_ui_button span.cke_disabled{border:#898980 1px solid;color:#5e5e55;background-color:#c5c5b3}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1180px}.cke_hc a.cke_dialog_ui_button:hover,.cke_hc a.cke_dialog_ui_button:focus,.cke_hc a.cke_dialog_ui_button:active{border-width:2px}.cke_dialog_footer_buttons{display:inline-table;margin:6px 12px 0 12px;width:auto;position:relative}.cke_dialog_footer_buttons span.cke_dialog_ui_button{text-align:center}select.cke_dialog_ui_input_select{border:1px solid #a0a0a0;background-color:white}.cke_dialog_ui_input_file{width:100%;height:25px}.cke_dialog .cke_dark_background{background-color:#eaead1}.cke_dialog .cke_light_background{background-color:#ffffbe}.cke_dialog .cke_centered{text-align:center}.cke_dialog a.cke_btn_reset{float:right;background-position:0 -32px;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:1px none;font-size:1px}.cke_rtl .cke_dialog a.cke_btn_reset{float:left}.cke_dialog a.cke_btn_locked,.cke_dialog a.cke_btn_unlocked{float:left;background-position:0 0;background-image:url(images/mini.gif);width:16px;height:16px;background-repeat:no-repeat;border:none 1px;font-size:1px}.cke_dialog a.cke_btn_locked .cke_icon{display:none}.cke_rtl .cke_dialog a.cke_btn_locked,.cke_rtl .cke_dialog a.cke_btn_unlocked{float:right}.cke_dialog a.cke_btn_unlocked{background-position:0 -16px;background-image:url(images/mini.gif)}.cke_dialog .cke_btn_over{border:outset 1px;cursor:pointer}.cke_dialog .ImagePreviewBox{border:2px ridge black;overflow:scroll;height:200px;width:300px;padding:2px;background-color:white}.cke_dialog .ImagePreviewBox table td{white-space:normal}.cke_dialog .ImagePreviewLoader{position:absolute;white-space:normal;overflow:hidden;height:160px;width:230px;margin:2px;padding:2px;opacity:.9;filter:alpha(opacity=90);background-color:#e4e4e4}.cke_dialog .FlashPreviewBox{white-space:normal;border:2px ridge black;overflow:auto;height:160px;width:390px;padding:2px;background-color:white}.cke_dialog .cke_pastetext{width:346px;height:170px}.cke_dialog .cke_pastetext textarea{width:340px;height:170px;resize:none}.cke_dialog iframe.cke_pasteframe{width:346px;height:130px;background-color:white;border:1px solid black}.cke_dialog .cke_hand{cursor:pointer}.cke_disabled{color:#a0a0a0}.cke_hc .cke_dialog_title,.cke_hc .cke_dialog_tabs,.cke_hc .cke_dialog_contents,.cke_hc .cke_dialog_footer{border-left:1px solid;border-right:1px solid}.cke_hc .cke_dialog_title{border-top:1px solid}.cke_hc .cke_dialog_footer{border-bottom:1px solid}.cke_hc .cke_dialog_close_button span{display:inline;cursor:pointer;font-weight:bold;position:relative;top:3px}.cke_dialog_body .cke_label{display:none}.cke_dialog_body label{display:inline;margin-bottom:auto;cursor:default}.cke_dialog_body label.cke_required{font-weight:bold}.cke_hc .cke_dialog_body .cke_label{display:inline;cursor:inherit}.cke_hc a.cke_btn_locked,.cke_hc a.cke_btn_unlocked,.cke_hc a.cke_btn_reset{border-style:solid;float:left;width:auto;height:auto;padding:0 2px}.cke_rtl.cke_hc a.cke_btn_locked,.cke_rtl.cke_hc a.cke_btn_unlocked,.cke_rtl.cke_hc a.cke_btn_reset{float:right}.cke_hc a.cke_btn_locked .cke_icon{display:inline}a.cke_smile img{border:2px solid #eaead1}a.cke_smile:focus img,a.cke_smile:active img,a.cke_smile:hover img{border-color:#c7c78f}.cke_hc .cke_dialog_tabs a,.cke_hc .cke_dialog_footer a{opacity:1.0;filter:alpha(opacity=100);border:1px solid white}.cke_hc .ImagePreviewBox{width:260px}.cke_dialog_contents a.colorChooser{display:block;margin-top:6px;margin-left:10px;width:80px}.cke_rtl .cke_dialog_contents a.colorChooser{margin-right:10px}.cke_dialog_ui_checkbox_input:focus,.cke_dialog_ui_radio_input:focus,.cke_dialog_ui_input_select:focus,.cke_btn_over{outline:1px dotted #696969}.cke_iframe_shim{display:block;position:absolute;top:0;left:0;z-index:-1;filter:alpha(opacity=0);width:100%;height:100%}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{padding-right:2px}.cke_rtl div.cke_dialog_ui_input_text,.cke_rtl div.cke_dialog_ui_input_password{padding-left:2px}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/editor.css b/lam/templates/lib/extra/ckeditor/skins/kama/editor.css
new file mode 100644
index 00000000..37008570
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/editor.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_reset{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none}.cke_reset_all,.cke_reset_all *{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none;border-collapse:collapse;font:normal normal normal 12px Arial,Helvetica,Tahoma,Verdana,Sans-Serif;color:#000;text-align:left;white-space:nowrap;cursor:auto}.cke_reset_all .cke_rtl *{text-align:right}.cke_reset_all iframe{vertical-align:inherit}.cke_reset_all textarea{white-space:pre}.cke_reset_all textarea,.cke_reset_all input[type="text"],.cke_reset_all input[type="password"]{cursor:text}.cke_reset_all textarea[disabled],.cke_reset_all input[type="text"][disabled],.cke_reset_all input[type="password"][disabled]{cursor:default}.cke_reset_all fieldset{padding:10px;border:2px groove #e0dfe3}.cke_reset_all select{box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box}.cke_chrome{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;border:1px solid #d3d3d3;padding:5px}.cke_hc.cke_chrome{padding:2px}.cke_inner{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;-webkit-touch-callout:none;border-radius:5px;background:#d3d3d3 url(images/sprites.png) repeat-x 0 -1950px;background:-webkit-gradient(linear,0 -15,0 40,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-webkit-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-o-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-ms-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:linear-gradient(top,#fff -15px,#d3d3d3 40px);padding:5px}.cke_float{background:#fff}.cke_float .cke_inner{padding-bottom:0}.cke_hc .cke_contents{border:1px solid black}.cke_top,.cke_contents,.cke_bottom{display:block;overflow:hidden}.cke_top{white-space:normal}.cke_browser_ios .cke_contents{overflow-y:auto;-webkit-overflow-scrolling:touch}.cke_resizer{width:0;height:0;overflow:hidden;border-width:12px 12px 0 12px;border-color:transparent #efefef transparent transparent;border-style:dashed solid dashed dashed;margin:10px 0 0;font-size:0;float:right;vertical-align:bottom;cursor:se-resize;opacity:.8}.cke_resizer_ltr{margin-left:-12px}.cke_resizer_rtl{float:left;border-color:transparent transparent transparent #efefef;border-style:dashed dashed dashed solid;margin-right:-12px;cursor:sw-resize}.cke_hc .cke_resizer{width:10px;height:10px;border:1px solid #fff;margin-left:0}.cke_hc .cke_resizer_rtl{margin-right:0}.cke_wysiwyg_div{display:block;height:100%;overflow:auto;padding:0 8px;outline-style:none;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.cke_panel{visibility:visible;border:1px solid #8f8f73;background-color:#fff;width:120px;height:100px;overflow:hidden;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.cke_menu_panel{padding:2px;margin:0}.cke_combopanel{border:1px solid #8f8f73;-moz-border-radius-topleft:0;-webkit-border-top-left-radius:0;border-top-left-radius:0;width:150px;height:170px}.cke_panel_frame{width:100%;height:100%;font-family:Arial,Verdana,sans-serif;font-size:12px;overflow:auto;overflow-x:hidden}.cke_panel_container{overflow-y:auto;overflow-x:hidden}.cke_panel_list{list-style-type:none;margin:3px;padding:0;white-space:nowrap}.cke_panel_listItem{margin:0}.cke_panel_listItem a{padding:2px;display:block;border:1px solid #fff;color:inherit!important;text-decoration:none;overflow:hidden;text-overflow:ellipsis}* html .cke_panel_listItem a{width:100%;color:#000}*:first-child+html .cke_panel_listItem a{color:#000}.cke_panel_listItem.cke_selected a{border:1px solid #ccc;background-color:#e9f5ff}.cke_panel_listItem a:hover,.cke_panel_listItem a:focus,.cke_panel_listItem a:active{border-color:#316ac5;background-color:#dff1ff}.cke_hc .cke_panel_listItem.cke_selected a,.cke_hc .cke_panel_listItem a:hover,.cke_hc .cke_panel_listItem a:focus,.cke_hc .cke_panel_listItem a:active{border-width:3px;padding:0}.cke_panel_grouptitle{font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif;font-weight:bold;white-space:nowrap;background-color:#dcdcdc;color:#000;margin:0;padding:3px}.cke_panel_listItem p,.cke_panel_listItem h1,.cke_panel_listItem h2,.cke_panel_listItem h3,.cke_panel_listItem h4,.cke_panel_listItem h5,.cke_panel_listItem h6,.cke_panel_listItem pre{margin-top:3px;margin-bottom:3px}.cke_colorblock{padding:3px;font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif}.cke_colorblock,.cke_colorblock a{text-decoration:none;color:#000}span.cke_colorbox{width:10px;height:10px;border:#808080 1px solid;float:left}.cke_rtl span.cke_colorbox{float:right}a.cke_colorbox{border:#fff 1px solid;padding:2px;float:left;width:12px;height:12px}.cke_rtl a.cke_colorbox{float:right}a:hover.cke_colorbox,a:focus.cke_colorbox,a:active.cke_colorbox{border:#316ac5 1px solid;background-color:#dff1ff}a.cke_colorauto,a.cke_colormore{border:#fff 1px solid;padding:2px;display:block;cursor:pointer}a:hover.cke_colorauto,a:hover.cke_colormore,a:focus.cke_colorauto,a:focus.cke_colormore,a:active.cke_colorauto,a:active.cke_colormore{border:#316ac5 1px solid;background-color:#dff1ff}.cke_toolbar{float:left}.cke_rtl .cke_toolbar{float:right}.cke_toolgroup{-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;float:left;margin:0 6px 5px 0;padding:2px;background:url(images/sprites.png) repeat-x 0 -500px;background:-webkit-gradient(linear,0 0,0 100,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff,#d3d3d3 100px);background:-webkit-linear-gradient(top,#fff,#d3d3d3 100px);background:-o-linear-gradient(top,#fff,#d3d3d3 100px);background:-ms-linear-gradient(top,#fff,#d3d3d3 100px);background:linear-gradient(top,#fff,#d3d3d3 100px)}.cke_hc .cke_toolgroup{padding-right:0;margin-right:4px}.cke_rtl .cke_toolgroup{float:right;margin-left:6px;margin-right:0}.cke_rtl.cke_hc .cke_toolgroup{padding-left:0;margin-left:4px}a.cke_button{display:inline-block;height:18px;padding:2px 4px;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;outline:0;cursor:default;float:left;border:0}.cke_rtl .cke_button{float:right}.cke_hc .cke_button{border:1px solid black;padding:3px 5px;margin:-2px 4px 0 -2px}.cke_rtl.cke_hc .cke_button{margin:-2px -2px 0 4px}.cke_button_on{background-color:#a3d7ff}.cke_hc .cke_button_on{border-width:3px;padding:1px 3px}.cke_button_off{opacity:.7}.cke_button_disabled{opacity:.3}a.cke_button_on:hover,a.cke_button_on:focus,a.cke_button_on:active{background-color:#86caff}.cke_hc a.cke_button:hover{background:black}a.cke_button_off:hover,a.cke_button_off:focus,a.cke_button_off:active{background-color:#dff1ff;opacity:1}.cke_button_icon{cursor:inherit;background-repeat:no-repeat;margin-top:1px;width:16px;height:16px;float:left;display:inline-block}.cke_rtl .cke_button_icon{float:right}.cke_hc .cke_button_icon{display:none}.cke_button_label{display:none;padding-left:3px;margin-top:1px;line-height:16px;vertical-align:middle;float:left;cursor:default}.cke_hc .cke_button_label{padding:0;display:inline-block}.cke_rtl .cke_button_label{padding-right:3px;padding-left:0;float:right}.cke_button_arrow{display:inline-block;margin:7px 0 0 1px;width:0;height:0;border-width:3px;border-color:#2f2f2f transparent transparent transparent;border-style:solid dashed dashed dashed;cursor:default;vertical-align:middle}.cke_rtl .cke_button_arrow{margin-right:5px;margin-left:0}.cke_hc .cke_button_arrow{font-size:10px;margin:0 -2px 0 3px;width:auto;border:0}.cke_rtl.cke_hc .cke_button_arrow{margin:0 3px 0 -2px}.cke_toolbar_separator{float:left;border-left:solid 1px #d3d3d3;margin:3px 2px 0;height:16px}.cke_rtl .cke_toolbar_separator{border-right:solid 1px #d3d3d3;border-left:0;float:right}.cke_hc .cke_toolbar_separator{margin-left:0;width:3px}.cke_rtl.cke_hc .cke_toolbar_separator{margin:3px 0 0 2px}.cke_toolbar_break{display:block;clear:left}.cke_rtl .cke_toolbar_break{clear:right}.cke_toolbox_collapser{width:12px;height:11px;float:right;border:1px outset #d3d3d3;margin:11px 0 0;font-size:0;cursor:default;text-align:center}.cke_toolbox_collapser.cke_toolbox_collapser_min{margin:0 2px 4px}.cke_rtl .cke_toolbox_collapser{float:left}.cke_hc .cke_toolbox_collapser{border-width:1px}.cke_toolbox_collapser .cke_arrow{display:inline-block;height:0;width:0;font-size:0;border-width:3px;border-style:solid;border-color:transparent transparent #2f2f2f}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin:4px 2px 0 0;border-color:#2f2f2f transparent transparent}.cke_hc .cke_toolbox_collapser .cke_arrow{font-size:8px;width:auto;border:0;margin-top:0;margin-right:2px}.cke_menubutton{display:block}.cke_menuitem span{cursor:default}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3;display:block}.cke_hc .cke_menubutton:hover,.cke_hc .cke_menubutton:focus,.cke_hc .cke_menubutton:active{border:2px solid}.cke_menubutton_inner{display:table-row}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:table-cell}.cke_menubutton_icon{background-color:#d3d3d3;opacity:.70;filter:alpha(opacity=70);padding:4px}.cke_hc .cke_menubutton_icon{height:16px;width:0;padding:4px 0}.cke_menubutton:hover .cke_menubutton_icon,.cke_menubutton:focus .cke_menubutton_icon,.cke_menubutton:active .cke_menubutton_icon{background-color:#9d9d9d}.cke_menubutton_disabled:hover .cke_menubutton_icon,.cke_menubutton_disabled:focus .cke_menubutton_icon,.cke_menubutton_disabled:active .cke_menubutton_icon{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_label{padding:0 5px;background-color:transparent;width:100%;vertical-align:middle}.cke_menubutton_disabled .cke_menubutton_label{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_on{border:1px solid #ccc;background-color:#e9f5ff}.cke_menubutton_on .cke_menubutton_icon{padding-right:3px}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3}.cke_menubutton_on:hover,.cke_menubutton_on:focus,.cke_menubutton_on:active{border-color:#316ac5;background-color:#dff1ff}.cke_panel_frame .cke_menubutton_label{display:none}.cke_menuseparator{background-color:#d3d3d3;height:2px;filter:alpha(opacity=70);opacity:.70}.cke_menuarrow{background-image:url(images/sprites.png);background-position:0 -1400px;background-repeat:no-repeat;padding:0 5px}.cke_rtl .cke_menuarrow{background-image:url(images/sprites.png);background-position:7px -1380px;background-repeat:no-repeat}.cke_menuarrow span{display:none}.cke_hc .cke_menuarrow span{vertical-align:middle;display:inline}.cke_combo{display:inline-block;float:left}.cke_rtl .cke_combo{float:right}.cke_combo_label{display:none;float:left;line-height:26px;vertical-align:top;margin-right:5px;filter:alpha(opacity = 70);opacity:.7}.cke_rtl .cke_combo_label{float:right;margin-left:5px;margin-right:0}.cke_combo_button{display:inline-block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:url(images/sprites.png) 0 -100px repeat-x;float:left;padding:2px 4px 2px 6px;height:22px;margin:0 5px 5px 0;background:-moz-linear-gradient(bottom,#fff,#d3d3d3 100px);background:-webkit-gradient(linear,left bottom,left -100,from(#fff),to(#d3d3d3))}.cke_combo_off .cke_combo_button:hover,.cke_combo_off .cke_combo_button:focus,.cke_combo_off .cke_combo_button:active{background:#dff1ff;outline:0}.cke_rtl .cke_combo_button{float:right;margin-left:5px;margin-right:0}.cke_hc .cke_combo_button{border:1px solid black;padding:1px 3px 1px 3px}.cke_hc .cke_rtl .cke_combo_button{border:1px solid black}.cke_combo_text{line-height:24px;text-overflow:ellipsis;overflow:hidden;color:#666;float:left;cursor:default;width:60px}.cke_rtl .cke_combo_text{float:right;text-align:right}.cke_combo_inlinelabel{font-style:italic;opacity:.70}.cke_combo_off .cke_combo_button:hover .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:active .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:focus .cke_combo_inlinelabel{opacity:1}.cke_combo_open{cursor:default;display:inline-block;font-size:0;height:19px;line-height:17px;margin:1px 3px;width:5px}.cke_combo_arrow{margin:9px 0 0;float:left;opacity:.70;height:0;width:0;font-size:0;border-left:3px solid transparent;border-right:3px solid transparent;border-top:3px solid #2f2f2f}.cke_hc .cke_combo_arrow{font-size:10px;width:auto;border:0;margin-top:4px}.cke_combo_disabled .cke_combo_inlinelabel,.cke_combo_disabled .cke_combo_open{opacity:.3}.cke_path{margin-top:5px;float:left}.cke_path_item,.cke_path_empty{display:inline-block;float:left;padding:1px 4px 0;color:#60676a;cursor:default;text-decoration:none;outline:0;border:0}.cke_rtl .cke_path,.cke_rtl .cke_path_item,.cke_rtl .cke_path_empty{float:right}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{background-color:#efefef;opacity:.7;color:#000}.cke_button__source_label,.cke_button__sourcedialog_label{display:inline}.cke_combo__fontsize .cke_combo_text{width:30px}.cke_combopanel__fontsize{width:120px}.cke_source{font-family:'Courier New',Monospace;font-size:small;background-color:#fff;white-space:pre}.cke_wysiwyg_frame,.cke_wysiwyg_div{background-color:#fff}.cke_chrome{visibility:inherit}.cke_voice_label{display:none}legend.cke_voice_label{display:none}.cke_button__about_icon {background: url(icons.png) no-repeat 0 -0px !important;}.cke_button__bold_icon {background: url(icons.png) no-repeat 0 -24px !important;}.cke_button__italic_icon {background: url(icons.png) no-repeat 0 -48px !important;}.cke_button__strike_icon {background: url(icons.png) no-repeat 0 -72px !important;}.cke_button__subscript_icon {background: url(icons.png) no-repeat 0 -96px !important;}.cke_button__superscript_icon {background: url(icons.png) no-repeat 0 -120px !important;}.cke_button__underline_icon {background: url(icons.png) no-repeat 0 -144px !important;}.cke_button__blockquote_icon {background: url(icons.png) no-repeat 0 -168px !important;}.cke_rtl .cke_button__copy_icon, .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -192px !important;}.cke_ltr .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -216px !important;}.cke_rtl .cke_button__cut_icon, .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -240px !important;}.cke_ltr .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -264px !important;}.cke_rtl .cke_button__paste_icon, .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -288px !important;}.cke_ltr .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -312px !important;}.cke_button__horizontalrule_icon {background: url(icons.png) no-repeat 0 -336px !important;}.cke_button__image_icon {background: url(icons.png) no-repeat 0 -360px !important;}.cke_rtl .cke_button__indent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -384px !important;}.cke_ltr .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -408px !important;}.cke_rtl .cke_button__outdent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -432px !important;}.cke_ltr .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -456px !important;}.cke_rtl .cke_button__anchor_icon, .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -480px !important;}.cke_ltr .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -504px !important;}.cke_button__link_icon {background: url(icons.png) no-repeat 0 -528px !important;}.cke_button__unlink_icon {background: url(icons.png) no-repeat 0 -552px !important;}.cke_rtl .cke_button__bulletedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -576px !important;}.cke_ltr .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -600px !important;}.cke_rtl .cke_button__numberedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -624px !important;}.cke_ltr .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -648px !important;}.cke_button__maximize_icon {background: url(icons.png) no-repeat 0 -672px !important;}.cke_rtl .cke_button__pastetext_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -696px !important;}.cke_ltr .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -720px !important;}.cke_rtl .cke_button__pastefromword_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -744px !important;}.cke_ltr .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -768px !important;}.cke_button__removeformat_icon {background: url(icons.png) no-repeat 0 -792px !important;}.cke_rtl .cke_button__source_icon, .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons.png) no-repeat 0 -816px !important;}.cke_ltr .cke_button__source_icon {background: url(icons.png) no-repeat 0 -840px !important;}.cke_button__specialchar_icon {background: url(icons.png) no-repeat 0 -864px !important;}.cke_button__scayt_icon {background: url(icons.png) no-repeat 0 -888px !important;}.cke_button__table_icon {background: url(icons.png) no-repeat 0 -912px !important;}.cke_rtl .cke_button__redo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -936px !important;}.cke_ltr .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -960px !important;}.cke_rtl .cke_button__undo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -984px !important;}.cke_ltr .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -1008px !important;}.cke_button__spellchecker_icon {background: url(icons.png) no-repeat 0 -1032px !important;}.cke_hidpi .cke_button__about_icon {background: url(icons_hidpi.png) no-repeat 0 -0px !important;}.cke_hidpi .cke_button__bold_icon {background: url(icons_hidpi.png) no-repeat 0 -32px !important;}.cke_hidpi .cke_button__italic_icon {background: url(icons_hidpi.png) no-repeat 0 -64px !important;}.cke_hidpi .cke_button__strike_icon {background: url(icons_hidpi.png) no-repeat 0 -96px !important;}.cke_hidpi .cke_button__subscript_icon {background: url(icons_hidpi.png) no-repeat 0 -128px !important;}.cke_hidpi .cke_button__superscript_icon {background: url(icons_hidpi.png) no-repeat 0 -160px !important;}.cke_hidpi .cke_button__underline_icon {background: url(icons_hidpi.png) no-repeat 0 -192px !important;}.cke_hidpi .cke_button__blockquote_icon {background: url(icons_hidpi.png) no-repeat 0 -224px !important;}.cke_rtl.cke_hidpi .cke_button__copy_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -256px !important;}.cke_hidpi .cke_ltr .cke_button__copy_icon,.cke_ltr.cke_hidpi .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -288px !important;}.cke_rtl.cke_hidpi .cke_button__cut_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -320px !important;}.cke_hidpi .cke_ltr .cke_button__cut_icon,.cke_ltr.cke_hidpi .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -352px !important;}.cke_rtl.cke_hidpi .cke_button__paste_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -384px !important;}.cke_hidpi .cke_ltr .cke_button__paste_icon,.cke_ltr.cke_hidpi .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -416px !important;}.cke_hidpi .cke_button__horizontalrule_icon {background: url(icons_hidpi.png) no-repeat 0 -448px !important;}.cke_hidpi .cke_button__image_icon {background: url(icons_hidpi.png) no-repeat 0 -480px !important;}.cke_rtl.cke_hidpi .cke_button__indent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -512px !important;}.cke_hidpi .cke_ltr .cke_button__indent_icon,.cke_ltr.cke_hidpi .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -544px !important;}.cke_rtl.cke_hidpi .cke_button__outdent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -576px !important;}.cke_hidpi .cke_ltr .cke_button__outdent_icon,.cke_ltr.cke_hidpi .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -608px !important;}.cke_rtl.cke_hidpi .cke_button__anchor_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -640px !important;}.cke_hidpi .cke_ltr .cke_button__anchor_icon,.cke_ltr.cke_hidpi .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -672px !important;}.cke_hidpi .cke_button__link_icon {background: url(icons_hidpi.png) no-repeat 0 -704px !important;}.cke_hidpi .cke_button__unlink_icon {background: url(icons_hidpi.png) no-repeat 0 -736px !important;}.cke_rtl.cke_hidpi .cke_button__bulletedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -768px !important;}.cke_hidpi .cke_ltr .cke_button__bulletedlist_icon,.cke_ltr.cke_hidpi .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -800px !important;}.cke_rtl.cke_hidpi .cke_button__numberedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -832px !important;}.cke_hidpi .cke_ltr .cke_button__numberedlist_icon,.cke_ltr.cke_hidpi .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -864px !important;}.cke_hidpi .cke_button__maximize_icon {background: url(icons_hidpi.png) no-repeat 0 -896px !important;}.cke_rtl.cke_hidpi .cke_button__pastetext_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -928px !important;}.cke_hidpi .cke_ltr .cke_button__pastetext_icon,.cke_ltr.cke_hidpi .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -960px !important;}.cke_rtl.cke_hidpi .cke_button__pastefromword_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -992px !important;}.cke_hidpi .cke_ltr .cke_button__pastefromword_icon,.cke_ltr.cke_hidpi .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -1024px !important;}.cke_hidpi .cke_button__removeformat_icon {background: url(icons_hidpi.png) no-repeat 0 -1056px !important;}.cke_rtl.cke_hidpi .cke_button__source_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1088px !important;}.cke_hidpi .cke_ltr .cke_button__source_icon,.cke_ltr.cke_hidpi .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1120px !important;}.cke_hidpi .cke_button__specialchar_icon {background: url(icons_hidpi.png) no-repeat 0 -1152px !important;}.cke_hidpi .cke_button__scayt_icon {background: url(icons_hidpi.png) no-repeat 0 -1184px !important;}.cke_hidpi .cke_button__table_icon {background: url(icons_hidpi.png) no-repeat 0 -1216px !important;}.cke_rtl.cke_hidpi .cke_button__redo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1248px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1280px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1312px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1344px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png) no-repeat 0 -1376px !important;}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie.css b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie.css
new file mode 100644
index 00000000..c652a1b9
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_reset{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none}.cke_reset_all,.cke_reset_all *{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none;border-collapse:collapse;font:normal normal normal 12px Arial,Helvetica,Tahoma,Verdana,Sans-Serif;color:#000;text-align:left;white-space:nowrap;cursor:auto}.cke_reset_all .cke_rtl *{text-align:right}.cke_reset_all iframe{vertical-align:inherit}.cke_reset_all textarea{white-space:pre}.cke_reset_all textarea,.cke_reset_all input[type="text"],.cke_reset_all input[type="password"]{cursor:text}.cke_reset_all textarea[disabled],.cke_reset_all input[type="text"][disabled],.cke_reset_all input[type="password"][disabled]{cursor:default}.cke_reset_all fieldset{padding:10px;border:2px groove #e0dfe3}.cke_reset_all select{box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box}.cke_chrome{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;border:1px solid #d3d3d3;padding:5px}.cke_hc.cke_chrome{padding:2px}.cke_inner{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;-webkit-touch-callout:none;border-radius:5px;background:#d3d3d3 url(images/sprites.png) repeat-x 0 -1950px;background:-webkit-gradient(linear,0 -15,0 40,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-webkit-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-o-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-ms-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:linear-gradient(top,#fff -15px,#d3d3d3 40px);padding:5px}.cke_float{background:#fff}.cke_float .cke_inner{padding-bottom:0}.cke_hc .cke_contents{border:1px solid black}.cke_top,.cke_contents,.cke_bottom{display:block;overflow:hidden}.cke_top{white-space:normal}.cke_browser_ios .cke_contents{overflow-y:auto;-webkit-overflow-scrolling:touch}.cke_resizer{width:0;height:0;overflow:hidden;border-width:12px 12px 0 12px;border-color:transparent #efefef transparent transparent;border-style:dashed solid dashed dashed;margin:10px 0 0;font-size:0;float:right;vertical-align:bottom;cursor:se-resize;opacity:.8}.cke_resizer_ltr{margin-left:-12px}.cke_resizer_rtl{float:left;border-color:transparent transparent transparent #efefef;border-style:dashed dashed dashed solid;margin-right:-12px;cursor:sw-resize}.cke_hc .cke_resizer{width:10px;height:10px;border:1px solid #fff;margin-left:0}.cke_hc .cke_resizer_rtl{margin-right:0}.cke_wysiwyg_div{display:block;height:100%;overflow:auto;padding:0 8px;outline-style:none;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.cke_panel{visibility:visible;border:1px solid #8f8f73;background-color:#fff;width:120px;height:100px;overflow:hidden;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.cke_menu_panel{padding:2px;margin:0}.cke_combopanel{border:1px solid #8f8f73;-moz-border-radius-topleft:0;-webkit-border-top-left-radius:0;border-top-left-radius:0;width:150px;height:170px}.cke_panel_frame{width:100%;height:100%;font-family:Arial,Verdana,sans-serif;font-size:12px;overflow:auto;overflow-x:hidden}.cke_panel_container{overflow-y:auto;overflow-x:hidden}.cke_panel_list{list-style-type:none;margin:3px;padding:0;white-space:nowrap}.cke_panel_listItem{margin:0}.cke_panel_listItem a{padding:2px;display:block;border:1px solid #fff;color:inherit!important;text-decoration:none;overflow:hidden;text-overflow:ellipsis}* html .cke_panel_listItem a{width:100%;color:#000}*:first-child+html .cke_panel_listItem a{color:#000}.cke_panel_listItem.cke_selected a{border:1px solid #ccc;background-color:#e9f5ff}.cke_panel_listItem a:hover,.cke_panel_listItem a:focus,.cke_panel_listItem a:active{border-color:#316ac5;background-color:#dff1ff}.cke_hc .cke_panel_listItem.cke_selected a,.cke_hc .cke_panel_listItem a:hover,.cke_hc .cke_panel_listItem a:focus,.cke_hc .cke_panel_listItem a:active{border-width:3px;padding:0}.cke_panel_grouptitle{font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif;font-weight:bold;white-space:nowrap;background-color:#dcdcdc;color:#000;margin:0;padding:3px}.cke_panel_listItem p,.cke_panel_listItem h1,.cke_panel_listItem h2,.cke_panel_listItem h3,.cke_panel_listItem h4,.cke_panel_listItem h5,.cke_panel_listItem h6,.cke_panel_listItem pre{margin-top:3px;margin-bottom:3px}.cke_colorblock{padding:3px;font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif}.cke_colorblock,.cke_colorblock a{text-decoration:none;color:#000}span.cke_colorbox{width:10px;height:10px;border:#808080 1px solid;float:left}.cke_rtl span.cke_colorbox{float:right}a.cke_colorbox{border:#fff 1px solid;padding:2px;float:left;width:12px;height:12px}.cke_rtl a.cke_colorbox{float:right}a:hover.cke_colorbox,a:focus.cke_colorbox,a:active.cke_colorbox{border:#316ac5 1px solid;background-color:#dff1ff}a.cke_colorauto,a.cke_colormore{border:#fff 1px solid;padding:2px;display:block;cursor:pointer}a:hover.cke_colorauto,a:hover.cke_colormore,a:focus.cke_colorauto,a:focus.cke_colormore,a:active.cke_colorauto,a:active.cke_colormore{border:#316ac5 1px solid;background-color:#dff1ff}.cke_toolbar{float:left}.cke_rtl .cke_toolbar{float:right}.cke_toolgroup{-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;float:left;margin:0 6px 5px 0;padding:2px;background:url(images/sprites.png) repeat-x 0 -500px;background:-webkit-gradient(linear,0 0,0 100,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff,#d3d3d3 100px);background:-webkit-linear-gradient(top,#fff,#d3d3d3 100px);background:-o-linear-gradient(top,#fff,#d3d3d3 100px);background:-ms-linear-gradient(top,#fff,#d3d3d3 100px);background:linear-gradient(top,#fff,#d3d3d3 100px)}.cke_hc .cke_toolgroup{padding-right:0;margin-right:4px}.cke_rtl .cke_toolgroup{float:right;margin-left:6px;margin-right:0}.cke_rtl.cke_hc .cke_toolgroup{padding-left:0;margin-left:4px}a.cke_button{display:inline-block;height:18px;padding:2px 4px;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;outline:0;cursor:default;float:left;border:0}.cke_rtl .cke_button{float:right}.cke_hc .cke_button{border:1px solid black;padding:3px 5px;margin:-2px 4px 0 -2px}.cke_rtl.cke_hc .cke_button{margin:-2px -2px 0 4px}.cke_button_on{background-color:#a3d7ff}.cke_hc .cke_button_on{border-width:3px;padding:1px 3px}.cke_button_off{opacity:.7}.cke_button_disabled{opacity:.3}a.cke_button_on:hover,a.cke_button_on:focus,a.cke_button_on:active{background-color:#86caff}.cke_hc a.cke_button:hover{background:black}a.cke_button_off:hover,a.cke_button_off:focus,a.cke_button_off:active{background-color:#dff1ff;opacity:1}.cke_button_icon{cursor:inherit;background-repeat:no-repeat;margin-top:1px;width:16px;height:16px;float:left;display:inline-block}.cke_rtl .cke_button_icon{float:right}.cke_hc .cke_button_icon{display:none}.cke_button_label{display:none;padding-left:3px;margin-top:1px;line-height:16px;vertical-align:middle;float:left;cursor:default}.cke_hc .cke_button_label{padding:0;display:inline-block}.cke_rtl .cke_button_label{padding-right:3px;padding-left:0;float:right}.cke_button_arrow{display:inline-block;margin:7px 0 0 1px;width:0;height:0;border-width:3px;border-color:#2f2f2f transparent transparent transparent;border-style:solid dashed dashed dashed;cursor:default;vertical-align:middle}.cke_rtl .cke_button_arrow{margin-right:5px;margin-left:0}.cke_hc .cke_button_arrow{font-size:10px;margin:0 -2px 0 3px;width:auto;border:0}.cke_rtl.cke_hc .cke_button_arrow{margin:0 3px 0 -2px}.cke_toolbar_separator{float:left;border-left:solid 1px #d3d3d3;margin:3px 2px 0;height:16px}.cke_rtl .cke_toolbar_separator{border-right:solid 1px #d3d3d3;border-left:0;float:right}.cke_hc .cke_toolbar_separator{margin-left:0;width:3px}.cke_rtl.cke_hc .cke_toolbar_separator{margin:3px 0 0 2px}.cke_toolbar_break{display:block;clear:left}.cke_rtl .cke_toolbar_break{clear:right}.cke_toolbox_collapser{width:12px;height:11px;float:right;border:1px outset #d3d3d3;margin:11px 0 0;font-size:0;cursor:default;text-align:center}.cke_toolbox_collapser.cke_toolbox_collapser_min{margin:0 2px 4px}.cke_rtl .cke_toolbox_collapser{float:left}.cke_hc .cke_toolbox_collapser{border-width:1px}.cke_toolbox_collapser .cke_arrow{display:inline-block;height:0;width:0;font-size:0;border-width:3px;border-style:solid;border-color:transparent transparent #2f2f2f}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin:4px 2px 0 0;border-color:#2f2f2f transparent transparent}.cke_hc .cke_toolbox_collapser .cke_arrow{font-size:8px;width:auto;border:0;margin-top:0;margin-right:2px}.cke_menubutton{display:block}.cke_menuitem span{cursor:default}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3;display:block}.cke_hc .cke_menubutton:hover,.cke_hc .cke_menubutton:focus,.cke_hc .cke_menubutton:active{border:2px solid}.cke_menubutton_inner{display:table-row}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:table-cell}.cke_menubutton_icon{background-color:#d3d3d3;opacity:.70;filter:alpha(opacity=70);padding:4px}.cke_hc .cke_menubutton_icon{height:16px;width:0;padding:4px 0}.cke_menubutton:hover .cke_menubutton_icon,.cke_menubutton:focus .cke_menubutton_icon,.cke_menubutton:active .cke_menubutton_icon{background-color:#9d9d9d}.cke_menubutton_disabled:hover .cke_menubutton_icon,.cke_menubutton_disabled:focus .cke_menubutton_icon,.cke_menubutton_disabled:active .cke_menubutton_icon{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_label{padding:0 5px;background-color:transparent;width:100%;vertical-align:middle}.cke_menubutton_disabled .cke_menubutton_label{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_on{border:1px solid #ccc;background-color:#e9f5ff}.cke_menubutton_on .cke_menubutton_icon{padding-right:3px}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3}.cke_menubutton_on:hover,.cke_menubutton_on:focus,.cke_menubutton_on:active{border-color:#316ac5;background-color:#dff1ff}.cke_panel_frame .cke_menubutton_label{display:none}.cke_menuseparator{background-color:#d3d3d3;height:2px;filter:alpha(opacity=70);opacity:.70}.cke_menuarrow{background-image:url(images/sprites.png);background-position:0 -1400px;background-repeat:no-repeat;padding:0 5px}.cke_rtl .cke_menuarrow{background-image:url(images/sprites.png);background-position:7px -1380px;background-repeat:no-repeat}.cke_menuarrow span{display:none}.cke_hc .cke_menuarrow span{vertical-align:middle;display:inline}.cke_combo{display:inline-block;float:left}.cke_rtl .cke_combo{float:right}.cke_combo_label{display:none;float:left;line-height:26px;vertical-align:top;margin-right:5px;filter:alpha(opacity = 70);opacity:.7}.cke_rtl .cke_combo_label{float:right;margin-left:5px;margin-right:0}.cke_combo_button{display:inline-block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:url(images/sprites.png) 0 -100px repeat-x;float:left;padding:2px 4px 2px 6px;height:22px;margin:0 5px 5px 0;background:-moz-linear-gradient(bottom,#fff,#d3d3d3 100px);background:-webkit-gradient(linear,left bottom,left -100,from(#fff),to(#d3d3d3))}.cke_combo_off .cke_combo_button:hover,.cke_combo_off .cke_combo_button:focus,.cke_combo_off .cke_combo_button:active{background:#dff1ff;outline:0}.cke_rtl .cke_combo_button{float:right;margin-left:5px;margin-right:0}.cke_hc .cke_combo_button{border:1px solid black;padding:1px 3px 1px 3px}.cke_hc .cke_rtl .cke_combo_button{border:1px solid black}.cke_combo_text{line-height:24px;text-overflow:ellipsis;overflow:hidden;color:#666;float:left;cursor:default;width:60px}.cke_rtl .cke_combo_text{float:right;text-align:right}.cke_combo_inlinelabel{font-style:italic;opacity:.70}.cke_combo_off .cke_combo_button:hover .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:active .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:focus .cke_combo_inlinelabel{opacity:1}.cke_combo_open{cursor:default;display:inline-block;font-size:0;height:19px;line-height:17px;margin:1px 3px;width:5px}.cke_combo_arrow{margin:9px 0 0;float:left;opacity:.70;height:0;width:0;font-size:0;border-left:3px solid transparent;border-right:3px solid transparent;border-top:3px solid #2f2f2f}.cke_hc .cke_combo_arrow{font-size:10px;width:auto;border:0;margin-top:4px}.cke_combo_disabled .cke_combo_inlinelabel,.cke_combo_disabled .cke_combo_open{opacity:.3}.cke_path{margin-top:5px;float:left}.cke_path_item,.cke_path_empty{display:inline-block;float:left;padding:1px 4px 0;color:#60676a;cursor:default;text-decoration:none;outline:0;border:0}.cke_rtl .cke_path,.cke_rtl .cke_path_item,.cke_rtl .cke_path_empty{float:right}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{background-color:#efefef;opacity:.7;color:#000}.cke_button__source_label,.cke_button__sourcedialog_label{display:inline}.cke_combo__fontsize .cke_combo_text{width:30px}.cke_combopanel__fontsize{width:120px}.cke_source{font-family:'Courier New',Monospace;font-size:small;background-color:#fff;white-space:pre}.cke_wysiwyg_frame,.cke_wysiwyg_div{background-color:#fff}.cke_chrome{visibility:inherit}.cke_voice_label{display:none}legend.cke_voice_label{display:none}.cke_button_off{filter:alpha(opacity = 70)}.cke_button_on{filter:alpha(opacity = 100)}.cke_button_disabled{filter:alpha(opacity = 30)}.cke_button_off:hover,.cke_button_off:focus,.cke_button_off:active{filter:alpha(opacity = 100)}.cke_hc .cke_button_arrow{margin-top:5px}.cke_combo_inlinelabel{filter:alpha(opacity = 70)}.cke_combo_button_off:hover .cke_combo_inlinelabel{filter:alpha(opacity = 100)}.cke_combo_button_disabled .cke_combo_inlinelabel,.cke_combo_button_disabled .cke_combo_open{filter:alpha(opacity = 30)}.cke_toolbox_collapser{border:2px outset #efefef}.cke_toolbox_collapser .cke_arrow{margin:0 1px 1px 1px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin-left:2px}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{filter:alpha(opacity = 70)}.cke_resizer{filter:alpha(opacity = 80)}.cke_hc .cke_resizer{filter:none;font-size:28px}.cke_menuarrow{position:absolute;right:2px}.cke_rtl .cke_menuarrow{position:absolute;left:2px}.cke_rtl .cke_dialog_footer_buttons .cke_dialog_ui_hbox_first{padding-left:10px!important}.cke_button__about_icon {background: url(icons.png) no-repeat 0 -0px !important;}.cke_button__bold_icon {background: url(icons.png) no-repeat 0 -24px !important;}.cke_button__italic_icon {background: url(icons.png) no-repeat 0 -48px !important;}.cke_button__strike_icon {background: url(icons.png) no-repeat 0 -72px !important;}.cke_button__subscript_icon {background: url(icons.png) no-repeat 0 -96px !important;}.cke_button__superscript_icon {background: url(icons.png) no-repeat 0 -120px !important;}.cke_button__underline_icon {background: url(icons.png) no-repeat 0 -144px !important;}.cke_button__blockquote_icon {background: url(icons.png) no-repeat 0 -168px !important;}.cke_rtl .cke_button__copy_icon, .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -192px !important;}.cke_ltr .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -216px !important;}.cke_rtl .cke_button__cut_icon, .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -240px !important;}.cke_ltr .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -264px !important;}.cke_rtl .cke_button__paste_icon, .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -288px !important;}.cke_ltr .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -312px !important;}.cke_button__horizontalrule_icon {background: url(icons.png) no-repeat 0 -336px !important;}.cke_button__image_icon {background: url(icons.png) no-repeat 0 -360px !important;}.cke_rtl .cke_button__indent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -384px !important;}.cke_ltr .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -408px !important;}.cke_rtl .cke_button__outdent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -432px !important;}.cke_ltr .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -456px !important;}.cke_rtl .cke_button__anchor_icon, .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -480px !important;}.cke_ltr .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -504px !important;}.cke_button__link_icon {background: url(icons.png) no-repeat 0 -528px !important;}.cke_button__unlink_icon {background: url(icons.png) no-repeat 0 -552px !important;}.cke_rtl .cke_button__bulletedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -576px !important;}.cke_ltr .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -600px !important;}.cke_rtl .cke_button__numberedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -624px !important;}.cke_ltr .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -648px !important;}.cke_button__maximize_icon {background: url(icons.png) no-repeat 0 -672px !important;}.cke_rtl .cke_button__pastetext_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -696px !important;}.cke_ltr .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -720px !important;}.cke_rtl .cke_button__pastefromword_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -744px !important;}.cke_ltr .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -768px !important;}.cke_button__removeformat_icon {background: url(icons.png) no-repeat 0 -792px !important;}.cke_rtl .cke_button__source_icon, .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons.png) no-repeat 0 -816px !important;}.cke_ltr .cke_button__source_icon {background: url(icons.png) no-repeat 0 -840px !important;}.cke_button__specialchar_icon {background: url(icons.png) no-repeat 0 -864px !important;}.cke_button__scayt_icon {background: url(icons.png) no-repeat 0 -888px !important;}.cke_button__table_icon {background: url(icons.png) no-repeat 0 -912px !important;}.cke_rtl .cke_button__redo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -936px !important;}.cke_ltr .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -960px !important;}.cke_rtl .cke_button__undo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -984px !important;}.cke_ltr .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -1008px !important;}.cke_button__spellchecker_icon {background: url(icons.png) no-repeat 0 -1032px !important;}.cke_hidpi .cke_button__about_icon {background: url(icons_hidpi.png) no-repeat 0 -0px !important;}.cke_hidpi .cke_button__bold_icon {background: url(icons_hidpi.png) no-repeat 0 -32px !important;}.cke_hidpi .cke_button__italic_icon {background: url(icons_hidpi.png) no-repeat 0 -64px !important;}.cke_hidpi .cke_button__strike_icon {background: url(icons_hidpi.png) no-repeat 0 -96px !important;}.cke_hidpi .cke_button__subscript_icon {background: url(icons_hidpi.png) no-repeat 0 -128px !important;}.cke_hidpi .cke_button__superscript_icon {background: url(icons_hidpi.png) no-repeat 0 -160px !important;}.cke_hidpi .cke_button__underline_icon {background: url(icons_hidpi.png) no-repeat 0 -192px !important;}.cke_hidpi .cke_button__blockquote_icon {background: url(icons_hidpi.png) no-repeat 0 -224px !important;}.cke_rtl.cke_hidpi .cke_button__copy_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -256px !important;}.cke_hidpi .cke_ltr .cke_button__copy_icon,.cke_ltr.cke_hidpi .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -288px !important;}.cke_rtl.cke_hidpi .cke_button__cut_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -320px !important;}.cke_hidpi .cke_ltr .cke_button__cut_icon,.cke_ltr.cke_hidpi .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -352px !important;}.cke_rtl.cke_hidpi .cke_button__paste_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -384px !important;}.cke_hidpi .cke_ltr .cke_button__paste_icon,.cke_ltr.cke_hidpi .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -416px !important;}.cke_hidpi .cke_button__horizontalrule_icon {background: url(icons_hidpi.png) no-repeat 0 -448px !important;}.cke_hidpi .cke_button__image_icon {background: url(icons_hidpi.png) no-repeat 0 -480px !important;}.cke_rtl.cke_hidpi .cke_button__indent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -512px !important;}.cke_hidpi .cke_ltr .cke_button__indent_icon,.cke_ltr.cke_hidpi .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -544px !important;}.cke_rtl.cke_hidpi .cke_button__outdent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -576px !important;}.cke_hidpi .cke_ltr .cke_button__outdent_icon,.cke_ltr.cke_hidpi .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -608px !important;}.cke_rtl.cke_hidpi .cke_button__anchor_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -640px !important;}.cke_hidpi .cke_ltr .cke_button__anchor_icon,.cke_ltr.cke_hidpi .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -672px !important;}.cke_hidpi .cke_button__link_icon {background: url(icons_hidpi.png) no-repeat 0 -704px !important;}.cke_hidpi .cke_button__unlink_icon {background: url(icons_hidpi.png) no-repeat 0 -736px !important;}.cke_rtl.cke_hidpi .cke_button__bulletedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -768px !important;}.cke_hidpi .cke_ltr .cke_button__bulletedlist_icon,.cke_ltr.cke_hidpi .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -800px !important;}.cke_rtl.cke_hidpi .cke_button__numberedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -832px !important;}.cke_hidpi .cke_ltr .cke_button__numberedlist_icon,.cke_ltr.cke_hidpi .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -864px !important;}.cke_hidpi .cke_button__maximize_icon {background: url(icons_hidpi.png) no-repeat 0 -896px !important;}.cke_rtl.cke_hidpi .cke_button__pastetext_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -928px !important;}.cke_hidpi .cke_ltr .cke_button__pastetext_icon,.cke_ltr.cke_hidpi .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -960px !important;}.cke_rtl.cke_hidpi .cke_button__pastefromword_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -992px !important;}.cke_hidpi .cke_ltr .cke_button__pastefromword_icon,.cke_ltr.cke_hidpi .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -1024px !important;}.cke_hidpi .cke_button__removeformat_icon {background: url(icons_hidpi.png) no-repeat 0 -1056px !important;}.cke_rtl.cke_hidpi .cke_button__source_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1088px !important;}.cke_hidpi .cke_ltr .cke_button__source_icon,.cke_ltr.cke_hidpi .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1120px !important;}.cke_hidpi .cke_button__specialchar_icon {background: url(icons_hidpi.png) no-repeat 0 -1152px !important;}.cke_hidpi .cke_button__scayt_icon {background: url(icons_hidpi.png) no-repeat 0 -1184px !important;}.cke_hidpi .cke_button__table_icon {background: url(icons_hidpi.png) no-repeat 0 -1216px !important;}.cke_rtl.cke_hidpi .cke_button__redo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1248px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1280px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1312px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1344px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png) no-repeat 0 -1376px !important;}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie7.css b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie7.css
new file mode 100644
index 00000000..e3745e7e
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie7.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_reset{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none}.cke_reset_all,.cke_reset_all *{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none;border-collapse:collapse;font:normal normal normal 12px Arial,Helvetica,Tahoma,Verdana,Sans-Serif;color:#000;text-align:left;white-space:nowrap;cursor:auto}.cke_reset_all .cke_rtl *{text-align:right}.cke_reset_all iframe{vertical-align:inherit}.cke_reset_all textarea{white-space:pre}.cke_reset_all textarea,.cke_reset_all input[type="text"],.cke_reset_all input[type="password"]{cursor:text}.cke_reset_all textarea[disabled],.cke_reset_all input[type="text"][disabled],.cke_reset_all input[type="password"][disabled]{cursor:default}.cke_reset_all fieldset{padding:10px;border:2px groove #e0dfe3}.cke_reset_all select{box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box}.cke_chrome{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;border:1px solid #d3d3d3;padding:5px}.cke_hc.cke_chrome{padding:2px}.cke_inner{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;-webkit-touch-callout:none;border-radius:5px;background:#d3d3d3 url(images/sprites.png) repeat-x 0 -1950px;background:-webkit-gradient(linear,0 -15,0 40,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-webkit-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-o-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-ms-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:linear-gradient(top,#fff -15px,#d3d3d3 40px);padding:5px}.cke_float{background:#fff}.cke_float .cke_inner{padding-bottom:0}.cke_hc .cke_contents{border:1px solid black}.cke_top,.cke_contents,.cke_bottom{display:block;overflow:hidden}.cke_top{white-space:normal}.cke_browser_ios .cke_contents{overflow-y:auto;-webkit-overflow-scrolling:touch}.cke_resizer{width:0;height:0;overflow:hidden;border-width:12px 12px 0 12px;border-color:transparent #efefef transparent transparent;border-style:dashed solid dashed dashed;margin:10px 0 0;font-size:0;float:right;vertical-align:bottom;cursor:se-resize;opacity:.8}.cke_resizer_ltr{margin-left:-12px}.cke_resizer_rtl{float:left;border-color:transparent transparent transparent #efefef;border-style:dashed dashed dashed solid;margin-right:-12px;cursor:sw-resize}.cke_hc .cke_resizer{width:10px;height:10px;border:1px solid #fff;margin-left:0}.cke_hc .cke_resizer_rtl{margin-right:0}.cke_wysiwyg_div{display:block;height:100%;overflow:auto;padding:0 8px;outline-style:none;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.cke_panel{visibility:visible;border:1px solid #8f8f73;background-color:#fff;width:120px;height:100px;overflow:hidden;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.cke_menu_panel{padding:2px;margin:0}.cke_combopanel{border:1px solid #8f8f73;-moz-border-radius-topleft:0;-webkit-border-top-left-radius:0;border-top-left-radius:0;width:150px;height:170px}.cke_panel_frame{width:100%;height:100%;font-family:Arial,Verdana,sans-serif;font-size:12px;overflow:auto;overflow-x:hidden}.cke_panel_container{overflow-y:auto;overflow-x:hidden}.cke_panel_list{list-style-type:none;margin:3px;padding:0;white-space:nowrap}.cke_panel_listItem{margin:0}.cke_panel_listItem a{padding:2px;display:block;border:1px solid #fff;color:inherit!important;text-decoration:none;overflow:hidden;text-overflow:ellipsis}* html .cke_panel_listItem a{width:100%;color:#000}*:first-child+html .cke_panel_listItem a{color:#000}.cke_panel_listItem.cke_selected a{border:1px solid #ccc;background-color:#e9f5ff}.cke_panel_listItem a:hover,.cke_panel_listItem a:focus,.cke_panel_listItem a:active{border-color:#316ac5;background-color:#dff1ff}.cke_hc .cke_panel_listItem.cke_selected a,.cke_hc .cke_panel_listItem a:hover,.cke_hc .cke_panel_listItem a:focus,.cke_hc .cke_panel_listItem a:active{border-width:3px;padding:0}.cke_panel_grouptitle{font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif;font-weight:bold;white-space:nowrap;background-color:#dcdcdc;color:#000;margin:0;padding:3px}.cke_panel_listItem p,.cke_panel_listItem h1,.cke_panel_listItem h2,.cke_panel_listItem h3,.cke_panel_listItem h4,.cke_panel_listItem h5,.cke_panel_listItem h6,.cke_panel_listItem pre{margin-top:3px;margin-bottom:3px}.cke_colorblock{padding:3px;font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif}.cke_colorblock,.cke_colorblock a{text-decoration:none;color:#000}span.cke_colorbox{width:10px;height:10px;border:#808080 1px solid;float:left}.cke_rtl span.cke_colorbox{float:right}a.cke_colorbox{border:#fff 1px solid;padding:2px;float:left;width:12px;height:12px}.cke_rtl a.cke_colorbox{float:right}a:hover.cke_colorbox,a:focus.cke_colorbox,a:active.cke_colorbox{border:#316ac5 1px solid;background-color:#dff1ff}a.cke_colorauto,a.cke_colormore{border:#fff 1px solid;padding:2px;display:block;cursor:pointer}a:hover.cke_colorauto,a:hover.cke_colormore,a:focus.cke_colorauto,a:focus.cke_colormore,a:active.cke_colorauto,a:active.cke_colormore{border:#316ac5 1px solid;background-color:#dff1ff}.cke_toolbar{float:left}.cke_rtl .cke_toolbar{float:right}.cke_toolgroup{-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;float:left;margin:0 6px 5px 0;padding:2px;background:url(images/sprites.png) repeat-x 0 -500px;background:-webkit-gradient(linear,0 0,0 100,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff,#d3d3d3 100px);background:-webkit-linear-gradient(top,#fff,#d3d3d3 100px);background:-o-linear-gradient(top,#fff,#d3d3d3 100px);background:-ms-linear-gradient(top,#fff,#d3d3d3 100px);background:linear-gradient(top,#fff,#d3d3d3 100px)}.cke_hc .cke_toolgroup{padding-right:0;margin-right:4px}.cke_rtl .cke_toolgroup{float:right;margin-left:6px;margin-right:0}.cke_rtl.cke_hc .cke_toolgroup{padding-left:0;margin-left:4px}a.cke_button{display:inline-block;height:18px;padding:2px 4px;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;outline:0;cursor:default;float:left;border:0}.cke_rtl .cke_button{float:right}.cke_hc .cke_button{border:1px solid black;padding:3px 5px;margin:-2px 4px 0 -2px}.cke_rtl.cke_hc .cke_button{margin:-2px -2px 0 4px}.cke_button_on{background-color:#a3d7ff}.cke_hc .cke_button_on{border-width:3px;padding:1px 3px}.cke_button_off{opacity:.7}.cke_button_disabled{opacity:.3}a.cke_button_on:hover,a.cke_button_on:focus,a.cke_button_on:active{background-color:#86caff}.cke_hc a.cke_button:hover{background:black}a.cke_button_off:hover,a.cke_button_off:focus,a.cke_button_off:active{background-color:#dff1ff;opacity:1}.cke_button_icon{cursor:inherit;background-repeat:no-repeat;margin-top:1px;width:16px;height:16px;float:left;display:inline-block}.cke_rtl .cke_button_icon{float:right}.cke_hc .cke_button_icon{display:none}.cke_button_label{display:none;padding-left:3px;margin-top:1px;line-height:16px;vertical-align:middle;float:left;cursor:default}.cke_hc .cke_button_label{padding:0;display:inline-block}.cke_rtl .cke_button_label{padding-right:3px;padding-left:0;float:right}.cke_button_arrow{display:inline-block;margin:7px 0 0 1px;width:0;height:0;border-width:3px;border-color:#2f2f2f transparent transparent transparent;border-style:solid dashed dashed dashed;cursor:default;vertical-align:middle}.cke_rtl .cke_button_arrow{margin-right:5px;margin-left:0}.cke_hc .cke_button_arrow{font-size:10px;margin:0 -2px 0 3px;width:auto;border:0}.cke_rtl.cke_hc .cke_button_arrow{margin:0 3px 0 -2px}.cke_toolbar_separator{float:left;border-left:solid 1px #d3d3d3;margin:3px 2px 0;height:16px}.cke_rtl .cke_toolbar_separator{border-right:solid 1px #d3d3d3;border-left:0;float:right}.cke_hc .cke_toolbar_separator{margin-left:0;width:3px}.cke_rtl.cke_hc .cke_toolbar_separator{margin:3px 0 0 2px}.cke_toolbar_break{display:block;clear:left}.cke_rtl .cke_toolbar_break{clear:right}.cke_toolbox_collapser{width:12px;height:11px;float:right;border:1px outset #d3d3d3;margin:11px 0 0;font-size:0;cursor:default;text-align:center}.cke_toolbox_collapser.cke_toolbox_collapser_min{margin:0 2px 4px}.cke_rtl .cke_toolbox_collapser{float:left}.cke_hc .cke_toolbox_collapser{border-width:1px}.cke_toolbox_collapser .cke_arrow{display:inline-block;height:0;width:0;font-size:0;border-width:3px;border-style:solid;border-color:transparent transparent #2f2f2f}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin:4px 2px 0 0;border-color:#2f2f2f transparent transparent}.cke_hc .cke_toolbox_collapser .cke_arrow{font-size:8px;width:auto;border:0;margin-top:0;margin-right:2px}.cke_menubutton{display:block}.cke_menuitem span{cursor:default}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3;display:block}.cke_hc .cke_menubutton:hover,.cke_hc .cke_menubutton:focus,.cke_hc .cke_menubutton:active{border:2px solid}.cke_menubutton_inner{display:table-row}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:table-cell}.cke_menubutton_icon{background-color:#d3d3d3;opacity:.70;filter:alpha(opacity=70);padding:4px}.cke_hc .cke_menubutton_icon{height:16px;width:0;padding:4px 0}.cke_menubutton:hover .cke_menubutton_icon,.cke_menubutton:focus .cke_menubutton_icon,.cke_menubutton:active .cke_menubutton_icon{background-color:#9d9d9d}.cke_menubutton_disabled:hover .cke_menubutton_icon,.cke_menubutton_disabled:focus .cke_menubutton_icon,.cke_menubutton_disabled:active .cke_menubutton_icon{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_label{padding:0 5px;background-color:transparent;width:100%;vertical-align:middle}.cke_menubutton_disabled .cke_menubutton_label{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_on{border:1px solid #ccc;background-color:#e9f5ff}.cke_menubutton_on .cke_menubutton_icon{padding-right:3px}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3}.cke_menubutton_on:hover,.cke_menubutton_on:focus,.cke_menubutton_on:active{border-color:#316ac5;background-color:#dff1ff}.cke_panel_frame .cke_menubutton_label{display:none}.cke_menuseparator{background-color:#d3d3d3;height:2px;filter:alpha(opacity=70);opacity:.70}.cke_menuarrow{background-image:url(images/sprites.png);background-position:0 -1400px;background-repeat:no-repeat;padding:0 5px}.cke_rtl .cke_menuarrow{background-image:url(images/sprites.png);background-position:7px -1380px;background-repeat:no-repeat}.cke_menuarrow span{display:none}.cke_hc .cke_menuarrow span{vertical-align:middle;display:inline}.cke_combo{display:inline-block;float:left}.cke_rtl .cke_combo{float:right}.cke_combo_label{display:none;float:left;line-height:26px;vertical-align:top;margin-right:5px;filter:alpha(opacity = 70);opacity:.7}.cke_rtl .cke_combo_label{float:right;margin-left:5px;margin-right:0}.cke_combo_button{display:inline-block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:url(images/sprites.png) 0 -100px repeat-x;float:left;padding:2px 4px 2px 6px;height:22px;margin:0 5px 5px 0;background:-moz-linear-gradient(bottom,#fff,#d3d3d3 100px);background:-webkit-gradient(linear,left bottom,left -100,from(#fff),to(#d3d3d3))}.cke_combo_off .cke_combo_button:hover,.cke_combo_off .cke_combo_button:focus,.cke_combo_off .cke_combo_button:active{background:#dff1ff;outline:0}.cke_rtl .cke_combo_button{float:right;margin-left:5px;margin-right:0}.cke_hc .cke_combo_button{border:1px solid black;padding:1px 3px 1px 3px}.cke_hc .cke_rtl .cke_combo_button{border:1px solid black}.cke_combo_text{line-height:24px;text-overflow:ellipsis;overflow:hidden;color:#666;float:left;cursor:default;width:60px}.cke_rtl .cke_combo_text{float:right;text-align:right}.cke_combo_inlinelabel{font-style:italic;opacity:.70}.cke_combo_off .cke_combo_button:hover .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:active .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:focus .cke_combo_inlinelabel{opacity:1}.cke_combo_open{cursor:default;display:inline-block;font-size:0;height:19px;line-height:17px;margin:1px 3px;width:5px}.cke_combo_arrow{margin:9px 0 0;float:left;opacity:.70;height:0;width:0;font-size:0;border-left:3px solid transparent;border-right:3px solid transparent;border-top:3px solid #2f2f2f}.cke_hc .cke_combo_arrow{font-size:10px;width:auto;border:0;margin-top:4px}.cke_combo_disabled .cke_combo_inlinelabel,.cke_combo_disabled .cke_combo_open{opacity:.3}.cke_path{margin-top:5px;float:left}.cke_path_item,.cke_path_empty{display:inline-block;float:left;padding:1px 4px 0;color:#60676a;cursor:default;text-decoration:none;outline:0;border:0}.cke_rtl .cke_path,.cke_rtl .cke_path_item,.cke_rtl .cke_path_empty{float:right}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{background-color:#efefef;opacity:.7;color:#000}.cke_button__source_label,.cke_button__sourcedialog_label{display:inline}.cke_combo__fontsize .cke_combo_text{width:30px}.cke_combopanel__fontsize{width:120px}.cke_source{font-family:'Courier New',Monospace;font-size:small;background-color:#fff;white-space:pre}.cke_wysiwyg_frame,.cke_wysiwyg_div{background-color:#fff}.cke_chrome{visibility:inherit}.cke_voice_label{display:none}legend.cke_voice_label{display:none}.cke_button_off{filter:alpha(opacity = 70)}.cke_button_on{filter:alpha(opacity = 100)}.cke_button_disabled{filter:alpha(opacity = 30)}.cke_button_off:hover,.cke_button_off:focus,.cke_button_off:active{filter:alpha(opacity = 100)}.cke_hc .cke_button_arrow{margin-top:5px}.cke_combo_inlinelabel{filter:alpha(opacity = 70)}.cke_combo_button_off:hover .cke_combo_inlinelabel{filter:alpha(opacity = 100)}.cke_combo_button_disabled .cke_combo_inlinelabel,.cke_combo_button_disabled .cke_combo_open{filter:alpha(opacity = 30)}.cke_toolbox_collapser{border:2px outset #efefef}.cke_toolbox_collapser .cke_arrow{margin:0 1px 1px 1px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin-left:2px}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{filter:alpha(opacity = 70)}.cke_resizer{filter:alpha(opacity = 80)}.cke_hc .cke_resizer{filter:none;font-size:28px}.cke_menuarrow{position:absolute;right:2px}.cke_rtl .cke_menuarrow{position:absolute;left:2px}.cke_rtl .cke_dialog_footer_buttons .cke_dialog_ui_hbox_first{padding-left:10px!important}.cke_rtl .cke_toolgroup,.cke_rtl .cke_toolbar_separator,.cke_rtl .cke_button,.cke_rtl .cke_button *,.cke_rtl .cke_combo,.cke_rtl .cke_combo *,.cke_rtl .cke_path_item,.cke_rtl .cke_path_item *,.cke_rtl .cke_path_empty{float:none}.cke_rtl .cke_toolgroup,.cke_rtl .cke_toolbar_separator,.cke_rtl .cke_combo_button,.cke_rtl .cke_combo_button *,.cke_rtl .cke_button,.cke_rtl .cke_button_icon,{display:inline-block;vertical-align:top}.cke_toolbox{display:inline-block;padding-bottom:5px;height:100%}.cke_rtl .cke_toolbox{padding-bottom:0}.cke_toolbar{margin-bottom:5px}.cke_rtl .cke_toolbar{margin-bottom:0}.cke_toolgroup{height:22px}a.cke_button{float:none;vertical-align:top}.cke_toolbar_separator{display:inline-block;float:none;vertical-align:top}.cke_toolbox_collapser .cke_arrow{border-width:4px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{border-width:3px}.cke_rtl .cke_button_arrow{padding-top:8px;margin-right:2px}.cke_rtl .cke_combo_inlinelabel{display:table-cell;vertical-align:middle;padding-bottom:8px}.cke_menubutton{display:block;height:24px}.cke_menubutton_inner{display:block;position:relative}.cke_menubutton_icon{height:16px;width:16px}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:inline-block}.cke_menubutton_label{width:auto;vertical-align:top;line-height:24px;height:24px;margin:0 10px 0 0}.cke_menuarrow{width:3px;height:5px;padding:0;position:absolute;right:8px;top:11px;background-position:0 -1411px}.cke_rtl .cke_menubutton_icon{position:absolute;right:0;top:0}.cke_rtl .cke_menubutton_label{float:right;clear:both;margin:0 24px 0 10px}.cke_hc .cke_rtl .cke_menubutton_label{margin-right:0}.cke_rtl .cke_menuarrow{left:8px;right:auto;background-position:0 -1390px}.cke_hc .cke_menuarrow{top:5px;padding:0 5px}.cke_rtl input.cke_dialog_ui_input_text,.cke_rtl input.cke_dialog_ui_input_password{position:relative}.cke_wysiwyg_div{padding-top:0!important;padding-bottom:0!important}.cke_button__about_icon {background: url(icons.png) no-repeat 0 -0px !important;}.cke_button__bold_icon {background: url(icons.png) no-repeat 0 -24px !important;}.cke_button__italic_icon {background: url(icons.png) no-repeat 0 -48px !important;}.cke_button__strike_icon {background: url(icons.png) no-repeat 0 -72px !important;}.cke_button__subscript_icon {background: url(icons.png) no-repeat 0 -96px !important;}.cke_button__superscript_icon {background: url(icons.png) no-repeat 0 -120px !important;}.cke_button__underline_icon {background: url(icons.png) no-repeat 0 -144px !important;}.cke_button__blockquote_icon {background: url(icons.png) no-repeat 0 -168px !important;}.cke_rtl .cke_button__copy_icon, .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -192px !important;}.cke_ltr .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -216px !important;}.cke_rtl .cke_button__cut_icon, .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -240px !important;}.cke_ltr .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -264px !important;}.cke_rtl .cke_button__paste_icon, .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -288px !important;}.cke_ltr .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -312px !important;}.cke_button__horizontalrule_icon {background: url(icons.png) no-repeat 0 -336px !important;}.cke_button__image_icon {background: url(icons.png) no-repeat 0 -360px !important;}.cke_rtl .cke_button__indent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -384px !important;}.cke_ltr .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -408px !important;}.cke_rtl .cke_button__outdent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -432px !important;}.cke_ltr .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -456px !important;}.cke_rtl .cke_button__anchor_icon, .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -480px !important;}.cke_ltr .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -504px !important;}.cke_button__link_icon {background: url(icons.png) no-repeat 0 -528px !important;}.cke_button__unlink_icon {background: url(icons.png) no-repeat 0 -552px !important;}.cke_rtl .cke_button__bulletedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -576px !important;}.cke_ltr .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -600px !important;}.cke_rtl .cke_button__numberedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -624px !important;}.cke_ltr .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -648px !important;}.cke_button__maximize_icon {background: url(icons.png) no-repeat 0 -672px !important;}.cke_rtl .cke_button__pastetext_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -696px !important;}.cke_ltr .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -720px !important;}.cke_rtl .cke_button__pastefromword_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -744px !important;}.cke_ltr .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -768px !important;}.cke_button__removeformat_icon {background: url(icons.png) no-repeat 0 -792px !important;}.cke_rtl .cke_button__source_icon, .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons.png) no-repeat 0 -816px !important;}.cke_ltr .cke_button__source_icon {background: url(icons.png) no-repeat 0 -840px !important;}.cke_button__specialchar_icon {background: url(icons.png) no-repeat 0 -864px !important;}.cke_button__scayt_icon {background: url(icons.png) no-repeat 0 -888px !important;}.cke_button__table_icon {background: url(icons.png) no-repeat 0 -912px !important;}.cke_rtl .cke_button__redo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -936px !important;}.cke_ltr .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -960px !important;}.cke_rtl .cke_button__undo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -984px !important;}.cke_ltr .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -1008px !important;}.cke_button__spellchecker_icon {background: url(icons.png) no-repeat 0 -1032px !important;}.cke_hidpi .cke_button__about_icon {background: url(icons_hidpi.png) no-repeat 0 -0px !important;}.cke_hidpi .cke_button__bold_icon {background: url(icons_hidpi.png) no-repeat 0 -32px !important;}.cke_hidpi .cke_button__italic_icon {background: url(icons_hidpi.png) no-repeat 0 -64px !important;}.cke_hidpi .cke_button__strike_icon {background: url(icons_hidpi.png) no-repeat 0 -96px !important;}.cke_hidpi .cke_button__subscript_icon {background: url(icons_hidpi.png) no-repeat 0 -128px !important;}.cke_hidpi .cke_button__superscript_icon {background: url(icons_hidpi.png) no-repeat 0 -160px !important;}.cke_hidpi .cke_button__underline_icon {background: url(icons_hidpi.png) no-repeat 0 -192px !important;}.cke_hidpi .cke_button__blockquote_icon {background: url(icons_hidpi.png) no-repeat 0 -224px !important;}.cke_rtl.cke_hidpi .cke_button__copy_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -256px !important;}.cke_hidpi .cke_ltr .cke_button__copy_icon,.cke_ltr.cke_hidpi .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -288px !important;}.cke_rtl.cke_hidpi .cke_button__cut_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -320px !important;}.cke_hidpi .cke_ltr .cke_button__cut_icon,.cke_ltr.cke_hidpi .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -352px !important;}.cke_rtl.cke_hidpi .cke_button__paste_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -384px !important;}.cke_hidpi .cke_ltr .cke_button__paste_icon,.cke_ltr.cke_hidpi .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -416px !important;}.cke_hidpi .cke_button__horizontalrule_icon {background: url(icons_hidpi.png) no-repeat 0 -448px !important;}.cke_hidpi .cke_button__image_icon {background: url(icons_hidpi.png) no-repeat 0 -480px !important;}.cke_rtl.cke_hidpi .cke_button__indent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -512px !important;}.cke_hidpi .cke_ltr .cke_button__indent_icon,.cke_ltr.cke_hidpi .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -544px !important;}.cke_rtl.cke_hidpi .cke_button__outdent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -576px !important;}.cke_hidpi .cke_ltr .cke_button__outdent_icon,.cke_ltr.cke_hidpi .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -608px !important;}.cke_rtl.cke_hidpi .cke_button__anchor_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -640px !important;}.cke_hidpi .cke_ltr .cke_button__anchor_icon,.cke_ltr.cke_hidpi .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -672px !important;}.cke_hidpi .cke_button__link_icon {background: url(icons_hidpi.png) no-repeat 0 -704px !important;}.cke_hidpi .cke_button__unlink_icon {background: url(icons_hidpi.png) no-repeat 0 -736px !important;}.cke_rtl.cke_hidpi .cke_button__bulletedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -768px !important;}.cke_hidpi .cke_ltr .cke_button__bulletedlist_icon,.cke_ltr.cke_hidpi .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -800px !important;}.cke_rtl.cke_hidpi .cke_button__numberedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -832px !important;}.cke_hidpi .cke_ltr .cke_button__numberedlist_icon,.cke_ltr.cke_hidpi .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -864px !important;}.cke_hidpi .cke_button__maximize_icon {background: url(icons_hidpi.png) no-repeat 0 -896px !important;}.cke_rtl.cke_hidpi .cke_button__pastetext_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -928px !important;}.cke_hidpi .cke_ltr .cke_button__pastetext_icon,.cke_ltr.cke_hidpi .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -960px !important;}.cke_rtl.cke_hidpi .cke_button__pastefromword_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -992px !important;}.cke_hidpi .cke_ltr .cke_button__pastefromword_icon,.cke_ltr.cke_hidpi .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -1024px !important;}.cke_hidpi .cke_button__removeformat_icon {background: url(icons_hidpi.png) no-repeat 0 -1056px !important;}.cke_rtl.cke_hidpi .cke_button__source_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1088px !important;}.cke_hidpi .cke_ltr .cke_button__source_icon,.cke_ltr.cke_hidpi .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1120px !important;}.cke_hidpi .cke_button__specialchar_icon {background: url(icons_hidpi.png) no-repeat 0 -1152px !important;}.cke_hidpi .cke_button__scayt_icon {background: url(icons_hidpi.png) no-repeat 0 -1184px !important;}.cke_hidpi .cke_button__table_icon {background: url(icons_hidpi.png) no-repeat 0 -1216px !important;}.cke_rtl.cke_hidpi .cke_button__redo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1248px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1280px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1312px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1344px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png) no-repeat 0 -1376px !important;}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie8.css b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie8.css
new file mode 100644
index 00000000..5282ecaa
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/editor_ie8.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_reset{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none}.cke_reset_all,.cke_reset_all *{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none;border-collapse:collapse;font:normal normal normal 12px Arial,Helvetica,Tahoma,Verdana,Sans-Serif;color:#000;text-align:left;white-space:nowrap;cursor:auto}.cke_reset_all .cke_rtl *{text-align:right}.cke_reset_all iframe{vertical-align:inherit}.cke_reset_all textarea{white-space:pre}.cke_reset_all textarea,.cke_reset_all input[type="text"],.cke_reset_all input[type="password"]{cursor:text}.cke_reset_all textarea[disabled],.cke_reset_all input[type="text"][disabled],.cke_reset_all input[type="password"][disabled]{cursor:default}.cke_reset_all fieldset{padding:10px;border:2px groove #e0dfe3}.cke_reset_all select{box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box}.cke_chrome{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;border:1px solid #d3d3d3;padding:5px}.cke_hc.cke_chrome{padding:2px}.cke_inner{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;-webkit-touch-callout:none;border-radius:5px;background:#d3d3d3 url(images/sprites.png) repeat-x 0 -1950px;background:-webkit-gradient(linear,0 -15,0 40,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-webkit-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-o-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-ms-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:linear-gradient(top,#fff -15px,#d3d3d3 40px);padding:5px}.cke_float{background:#fff}.cke_float .cke_inner{padding-bottom:0}.cke_hc .cke_contents{border:1px solid black}.cke_top,.cke_contents,.cke_bottom{display:block;overflow:hidden}.cke_top{white-space:normal}.cke_browser_ios .cke_contents{overflow-y:auto;-webkit-overflow-scrolling:touch}.cke_resizer{width:0;height:0;overflow:hidden;border-width:12px 12px 0 12px;border-color:transparent #efefef transparent transparent;border-style:dashed solid dashed dashed;margin:10px 0 0;font-size:0;float:right;vertical-align:bottom;cursor:se-resize;opacity:.8}.cke_resizer_ltr{margin-left:-12px}.cke_resizer_rtl{float:left;border-color:transparent transparent transparent #efefef;border-style:dashed dashed dashed solid;margin-right:-12px;cursor:sw-resize}.cke_hc .cke_resizer{width:10px;height:10px;border:1px solid #fff;margin-left:0}.cke_hc .cke_resizer_rtl{margin-right:0}.cke_wysiwyg_div{display:block;height:100%;overflow:auto;padding:0 8px;outline-style:none;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.cke_panel{visibility:visible;border:1px solid #8f8f73;background-color:#fff;width:120px;height:100px;overflow:hidden;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.cke_menu_panel{padding:2px;margin:0}.cke_combopanel{border:1px solid #8f8f73;-moz-border-radius-topleft:0;-webkit-border-top-left-radius:0;border-top-left-radius:0;width:150px;height:170px}.cke_panel_frame{width:100%;height:100%;font-family:Arial,Verdana,sans-serif;font-size:12px;overflow:auto;overflow-x:hidden}.cke_panel_container{overflow-y:auto;overflow-x:hidden}.cke_panel_list{list-style-type:none;margin:3px;padding:0;white-space:nowrap}.cke_panel_listItem{margin:0}.cke_panel_listItem a{padding:2px;display:block;border:1px solid #fff;color:inherit!important;text-decoration:none;overflow:hidden;text-overflow:ellipsis}* html .cke_panel_listItem a{width:100%;color:#000}*:first-child+html .cke_panel_listItem a{color:#000}.cke_panel_listItem.cke_selected a{border:1px solid #ccc;background-color:#e9f5ff}.cke_panel_listItem a:hover,.cke_panel_listItem a:focus,.cke_panel_listItem a:active{border-color:#316ac5;background-color:#dff1ff}.cke_hc .cke_panel_listItem.cke_selected a,.cke_hc .cke_panel_listItem a:hover,.cke_hc .cke_panel_listItem a:focus,.cke_hc .cke_panel_listItem a:active{border-width:3px;padding:0}.cke_panel_grouptitle{font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif;font-weight:bold;white-space:nowrap;background-color:#dcdcdc;color:#000;margin:0;padding:3px}.cke_panel_listItem p,.cke_panel_listItem h1,.cke_panel_listItem h2,.cke_panel_listItem h3,.cke_panel_listItem h4,.cke_panel_listItem h5,.cke_panel_listItem h6,.cke_panel_listItem pre{margin-top:3px;margin-bottom:3px}.cke_colorblock{padding:3px;font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif}.cke_colorblock,.cke_colorblock a{text-decoration:none;color:#000}span.cke_colorbox{width:10px;height:10px;border:#808080 1px solid;float:left}.cke_rtl span.cke_colorbox{float:right}a.cke_colorbox{border:#fff 1px solid;padding:2px;float:left;width:12px;height:12px}.cke_rtl a.cke_colorbox{float:right}a:hover.cke_colorbox,a:focus.cke_colorbox,a:active.cke_colorbox{border:#316ac5 1px solid;background-color:#dff1ff}a.cke_colorauto,a.cke_colormore{border:#fff 1px solid;padding:2px;display:block;cursor:pointer}a:hover.cke_colorauto,a:hover.cke_colormore,a:focus.cke_colorauto,a:focus.cke_colormore,a:active.cke_colorauto,a:active.cke_colormore{border:#316ac5 1px solid;background-color:#dff1ff}.cke_toolbar{float:left}.cke_rtl .cke_toolbar{float:right}.cke_toolgroup{-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;float:left;margin:0 6px 5px 0;padding:2px;background:url(images/sprites.png) repeat-x 0 -500px;background:-webkit-gradient(linear,0 0,0 100,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff,#d3d3d3 100px);background:-webkit-linear-gradient(top,#fff,#d3d3d3 100px);background:-o-linear-gradient(top,#fff,#d3d3d3 100px);background:-ms-linear-gradient(top,#fff,#d3d3d3 100px);background:linear-gradient(top,#fff,#d3d3d3 100px)}.cke_hc .cke_toolgroup{padding-right:0;margin-right:4px}.cke_rtl .cke_toolgroup{float:right;margin-left:6px;margin-right:0}.cke_rtl.cke_hc .cke_toolgroup{padding-left:0;margin-left:4px}a.cke_button{display:inline-block;height:18px;padding:2px 4px;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;outline:0;cursor:default;float:left;border:0}.cke_rtl .cke_button{float:right}.cke_hc .cke_button{border:1px solid black;padding:3px 5px;margin:-2px 4px 0 -2px}.cke_rtl.cke_hc .cke_button{margin:-2px -2px 0 4px}.cke_button_on{background-color:#a3d7ff}.cke_hc .cke_button_on{border-width:3px;padding:1px 3px}.cke_button_off{opacity:.7}.cke_button_disabled{opacity:.3}a.cke_button_on:hover,a.cke_button_on:focus,a.cke_button_on:active{background-color:#86caff}.cke_hc a.cke_button:hover{background:black}a.cke_button_off:hover,a.cke_button_off:focus,a.cke_button_off:active{background-color:#dff1ff;opacity:1}.cke_button_icon{cursor:inherit;background-repeat:no-repeat;margin-top:1px;width:16px;height:16px;float:left;display:inline-block}.cke_rtl .cke_button_icon{float:right}.cke_hc .cke_button_icon{display:none}.cke_button_label{display:none;padding-left:3px;margin-top:1px;line-height:16px;vertical-align:middle;float:left;cursor:default}.cke_hc .cke_button_label{padding:0;display:inline-block}.cke_rtl .cke_button_label{padding-right:3px;padding-left:0;float:right}.cke_button_arrow{display:inline-block;margin:7px 0 0 1px;width:0;height:0;border-width:3px;border-color:#2f2f2f transparent transparent transparent;border-style:solid dashed dashed dashed;cursor:default;vertical-align:middle}.cke_rtl .cke_button_arrow{margin-right:5px;margin-left:0}.cke_hc .cke_button_arrow{font-size:10px;margin:0 -2px 0 3px;width:auto;border:0}.cke_rtl.cke_hc .cke_button_arrow{margin:0 3px 0 -2px}.cke_toolbar_separator{float:left;border-left:solid 1px #d3d3d3;margin:3px 2px 0;height:16px}.cke_rtl .cke_toolbar_separator{border-right:solid 1px #d3d3d3;border-left:0;float:right}.cke_hc .cke_toolbar_separator{margin-left:0;width:3px}.cke_rtl.cke_hc .cke_toolbar_separator{margin:3px 0 0 2px}.cke_toolbar_break{display:block;clear:left}.cke_rtl .cke_toolbar_break{clear:right}.cke_toolbox_collapser{width:12px;height:11px;float:right;border:1px outset #d3d3d3;margin:11px 0 0;font-size:0;cursor:default;text-align:center}.cke_toolbox_collapser.cke_toolbox_collapser_min{margin:0 2px 4px}.cke_rtl .cke_toolbox_collapser{float:left}.cke_hc .cke_toolbox_collapser{border-width:1px}.cke_toolbox_collapser .cke_arrow{display:inline-block;height:0;width:0;font-size:0;border-width:3px;border-style:solid;border-color:transparent transparent #2f2f2f}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin:4px 2px 0 0;border-color:#2f2f2f transparent transparent}.cke_hc .cke_toolbox_collapser .cke_arrow{font-size:8px;width:auto;border:0;margin-top:0;margin-right:2px}.cke_menubutton{display:block}.cke_menuitem span{cursor:default}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3;display:block}.cke_hc .cke_menubutton:hover,.cke_hc .cke_menubutton:focus,.cke_hc .cke_menubutton:active{border:2px solid}.cke_menubutton_inner{display:table-row}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:table-cell}.cke_menubutton_icon{background-color:#d3d3d3;opacity:.70;filter:alpha(opacity=70);padding:4px}.cke_hc .cke_menubutton_icon{height:16px;width:0;padding:4px 0}.cke_menubutton:hover .cke_menubutton_icon,.cke_menubutton:focus .cke_menubutton_icon,.cke_menubutton:active .cke_menubutton_icon{background-color:#9d9d9d}.cke_menubutton_disabled:hover .cke_menubutton_icon,.cke_menubutton_disabled:focus .cke_menubutton_icon,.cke_menubutton_disabled:active .cke_menubutton_icon{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_label{padding:0 5px;background-color:transparent;width:100%;vertical-align:middle}.cke_menubutton_disabled .cke_menubutton_label{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_on{border:1px solid #ccc;background-color:#e9f5ff}.cke_menubutton_on .cke_menubutton_icon{padding-right:3px}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3}.cke_menubutton_on:hover,.cke_menubutton_on:focus,.cke_menubutton_on:active{border-color:#316ac5;background-color:#dff1ff}.cke_panel_frame .cke_menubutton_label{display:none}.cke_menuseparator{background-color:#d3d3d3;height:2px;filter:alpha(opacity=70);opacity:.70}.cke_menuarrow{background-image:url(images/sprites.png);background-position:0 -1400px;background-repeat:no-repeat;padding:0 5px}.cke_rtl .cke_menuarrow{background-image:url(images/sprites.png);background-position:7px -1380px;background-repeat:no-repeat}.cke_menuarrow span{display:none}.cke_hc .cke_menuarrow span{vertical-align:middle;display:inline}.cke_combo{display:inline-block;float:left}.cke_rtl .cke_combo{float:right}.cke_combo_label{display:none;float:left;line-height:26px;vertical-align:top;margin-right:5px;filter:alpha(opacity = 70);opacity:.7}.cke_rtl .cke_combo_label{float:right;margin-left:5px;margin-right:0}.cke_combo_button{display:inline-block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:url(images/sprites.png) 0 -100px repeat-x;float:left;padding:2px 4px 2px 6px;height:22px;margin:0 5px 5px 0;background:-moz-linear-gradient(bottom,#fff,#d3d3d3 100px);background:-webkit-gradient(linear,left bottom,left -100,from(#fff),to(#d3d3d3))}.cke_combo_off .cke_combo_button:hover,.cke_combo_off .cke_combo_button:focus,.cke_combo_off .cke_combo_button:active{background:#dff1ff;outline:0}.cke_rtl .cke_combo_button{float:right;margin-left:5px;margin-right:0}.cke_hc .cke_combo_button{border:1px solid black;padding:1px 3px 1px 3px}.cke_hc .cke_rtl .cke_combo_button{border:1px solid black}.cke_combo_text{line-height:24px;text-overflow:ellipsis;overflow:hidden;color:#666;float:left;cursor:default;width:60px}.cke_rtl .cke_combo_text{float:right;text-align:right}.cke_combo_inlinelabel{font-style:italic;opacity:.70}.cke_combo_off .cke_combo_button:hover .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:active .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:focus .cke_combo_inlinelabel{opacity:1}.cke_combo_open{cursor:default;display:inline-block;font-size:0;height:19px;line-height:17px;margin:1px 3px;width:5px}.cke_combo_arrow{margin:9px 0 0;float:left;opacity:.70;height:0;width:0;font-size:0;border-left:3px solid transparent;border-right:3px solid transparent;border-top:3px solid #2f2f2f}.cke_hc .cke_combo_arrow{font-size:10px;width:auto;border:0;margin-top:4px}.cke_combo_disabled .cke_combo_inlinelabel,.cke_combo_disabled .cke_combo_open{opacity:.3}.cke_path{margin-top:5px;float:left}.cke_path_item,.cke_path_empty{display:inline-block;float:left;padding:1px 4px 0;color:#60676a;cursor:default;text-decoration:none;outline:0;border:0}.cke_rtl .cke_path,.cke_rtl .cke_path_item,.cke_rtl .cke_path_empty{float:right}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{background-color:#efefef;opacity:.7;color:#000}.cke_button__source_label,.cke_button__sourcedialog_label{display:inline}.cke_combo__fontsize .cke_combo_text{width:30px}.cke_combopanel__fontsize{width:120px}.cke_source{font-family:'Courier New',Monospace;font-size:small;background-color:#fff;white-space:pre}.cke_wysiwyg_frame,.cke_wysiwyg_div{background-color:#fff}.cke_chrome{visibility:inherit}.cke_voice_label{display:none}legend.cke_voice_label{display:none}.cke_button_off{filter:alpha(opacity = 70)}.cke_button_on{filter:alpha(opacity = 100)}.cke_button_disabled{filter:alpha(opacity = 30)}.cke_button_off:hover,.cke_button_off:focus,.cke_button_off:active{filter:alpha(opacity = 100)}.cke_hc .cke_button_arrow{margin-top:5px}.cke_combo_inlinelabel{filter:alpha(opacity = 70)}.cke_combo_button_off:hover .cke_combo_inlinelabel{filter:alpha(opacity = 100)}.cke_combo_button_disabled .cke_combo_inlinelabel,.cke_combo_button_disabled .cke_combo_open{filter:alpha(opacity = 30)}.cke_toolbox_collapser{border:2px outset #efefef}.cke_toolbox_collapser .cke_arrow{margin:0 1px 1px 1px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin-left:2px}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{filter:alpha(opacity = 70)}.cke_resizer{filter:alpha(opacity = 80)}.cke_hc .cke_resizer{filter:none;font-size:28px}.cke_menuarrow{position:absolute;right:2px}.cke_rtl .cke_menuarrow{position:absolute;left:2px}.cke_rtl .cke_dialog_footer_buttons .cke_dialog_ui_hbox_first{padding-left:10px!important}.cke_toolbox_collapser .cke_arrow{border-width:4px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{border-width:3px}.cke_button__about_icon {background: url(icons.png) no-repeat 0 -0px !important;}.cke_button__bold_icon {background: url(icons.png) no-repeat 0 -24px !important;}.cke_button__italic_icon {background: url(icons.png) no-repeat 0 -48px !important;}.cke_button__strike_icon {background: url(icons.png) no-repeat 0 -72px !important;}.cke_button__subscript_icon {background: url(icons.png) no-repeat 0 -96px !important;}.cke_button__superscript_icon {background: url(icons.png) no-repeat 0 -120px !important;}.cke_button__underline_icon {background: url(icons.png) no-repeat 0 -144px !important;}.cke_button__blockquote_icon {background: url(icons.png) no-repeat 0 -168px !important;}.cke_rtl .cke_button__copy_icon, .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -192px !important;}.cke_ltr .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -216px !important;}.cke_rtl .cke_button__cut_icon, .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -240px !important;}.cke_ltr .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -264px !important;}.cke_rtl .cke_button__paste_icon, .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -288px !important;}.cke_ltr .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -312px !important;}.cke_button__horizontalrule_icon {background: url(icons.png) no-repeat 0 -336px !important;}.cke_button__image_icon {background: url(icons.png) no-repeat 0 -360px !important;}.cke_rtl .cke_button__indent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -384px !important;}.cke_ltr .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -408px !important;}.cke_rtl .cke_button__outdent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -432px !important;}.cke_ltr .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -456px !important;}.cke_rtl .cke_button__anchor_icon, .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -480px !important;}.cke_ltr .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -504px !important;}.cke_button__link_icon {background: url(icons.png) no-repeat 0 -528px !important;}.cke_button__unlink_icon {background: url(icons.png) no-repeat 0 -552px !important;}.cke_rtl .cke_button__bulletedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -576px !important;}.cke_ltr .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -600px !important;}.cke_rtl .cke_button__numberedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -624px !important;}.cke_ltr .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -648px !important;}.cke_button__maximize_icon {background: url(icons.png) no-repeat 0 -672px !important;}.cke_rtl .cke_button__pastetext_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -696px !important;}.cke_ltr .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -720px !important;}.cke_rtl .cke_button__pastefromword_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -744px !important;}.cke_ltr .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -768px !important;}.cke_button__removeformat_icon {background: url(icons.png) no-repeat 0 -792px !important;}.cke_rtl .cke_button__source_icon, .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons.png) no-repeat 0 -816px !important;}.cke_ltr .cke_button__source_icon {background: url(icons.png) no-repeat 0 -840px !important;}.cke_button__specialchar_icon {background: url(icons.png) no-repeat 0 -864px !important;}.cke_button__scayt_icon {background: url(icons.png) no-repeat 0 -888px !important;}.cke_button__table_icon {background: url(icons.png) no-repeat 0 -912px !important;}.cke_rtl .cke_button__redo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -936px !important;}.cke_ltr .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -960px !important;}.cke_rtl .cke_button__undo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -984px !important;}.cke_ltr .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -1008px !important;}.cke_button__spellchecker_icon {background: url(icons.png) no-repeat 0 -1032px !important;}.cke_hidpi .cke_button__about_icon {background: url(icons_hidpi.png) no-repeat 0 -0px !important;}.cke_hidpi .cke_button__bold_icon {background: url(icons_hidpi.png) no-repeat 0 -32px !important;}.cke_hidpi .cke_button__italic_icon {background: url(icons_hidpi.png) no-repeat 0 -64px !important;}.cke_hidpi .cke_button__strike_icon {background: url(icons_hidpi.png) no-repeat 0 -96px !important;}.cke_hidpi .cke_button__subscript_icon {background: url(icons_hidpi.png) no-repeat 0 -128px !important;}.cke_hidpi .cke_button__superscript_icon {background: url(icons_hidpi.png) no-repeat 0 -160px !important;}.cke_hidpi .cke_button__underline_icon {background: url(icons_hidpi.png) no-repeat 0 -192px !important;}.cke_hidpi .cke_button__blockquote_icon {background: url(icons_hidpi.png) no-repeat 0 -224px !important;}.cke_rtl.cke_hidpi .cke_button__copy_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -256px !important;}.cke_hidpi .cke_ltr .cke_button__copy_icon,.cke_ltr.cke_hidpi .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -288px !important;}.cke_rtl.cke_hidpi .cke_button__cut_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -320px !important;}.cke_hidpi .cke_ltr .cke_button__cut_icon,.cke_ltr.cke_hidpi .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -352px !important;}.cke_rtl.cke_hidpi .cke_button__paste_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -384px !important;}.cke_hidpi .cke_ltr .cke_button__paste_icon,.cke_ltr.cke_hidpi .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -416px !important;}.cke_hidpi .cke_button__horizontalrule_icon {background: url(icons_hidpi.png) no-repeat 0 -448px !important;}.cke_hidpi .cke_button__image_icon {background: url(icons_hidpi.png) no-repeat 0 -480px !important;}.cke_rtl.cke_hidpi .cke_button__indent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -512px !important;}.cke_hidpi .cke_ltr .cke_button__indent_icon,.cke_ltr.cke_hidpi .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -544px !important;}.cke_rtl.cke_hidpi .cke_button__outdent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -576px !important;}.cke_hidpi .cke_ltr .cke_button__outdent_icon,.cke_ltr.cke_hidpi .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -608px !important;}.cke_rtl.cke_hidpi .cke_button__anchor_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -640px !important;}.cke_hidpi .cke_ltr .cke_button__anchor_icon,.cke_ltr.cke_hidpi .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -672px !important;}.cke_hidpi .cke_button__link_icon {background: url(icons_hidpi.png) no-repeat 0 -704px !important;}.cke_hidpi .cke_button__unlink_icon {background: url(icons_hidpi.png) no-repeat 0 -736px !important;}.cke_rtl.cke_hidpi .cke_button__bulletedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -768px !important;}.cke_hidpi .cke_ltr .cke_button__bulletedlist_icon,.cke_ltr.cke_hidpi .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -800px !important;}.cke_rtl.cke_hidpi .cke_button__numberedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -832px !important;}.cke_hidpi .cke_ltr .cke_button__numberedlist_icon,.cke_ltr.cke_hidpi .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -864px !important;}.cke_hidpi .cke_button__maximize_icon {background: url(icons_hidpi.png) no-repeat 0 -896px !important;}.cke_rtl.cke_hidpi .cke_button__pastetext_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -928px !important;}.cke_hidpi .cke_ltr .cke_button__pastetext_icon,.cke_ltr.cke_hidpi .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -960px !important;}.cke_rtl.cke_hidpi .cke_button__pastefromword_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -992px !important;}.cke_hidpi .cke_ltr .cke_button__pastefromword_icon,.cke_ltr.cke_hidpi .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -1024px !important;}.cke_hidpi .cke_button__removeformat_icon {background: url(icons_hidpi.png) no-repeat 0 -1056px !important;}.cke_rtl.cke_hidpi .cke_button__source_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1088px !important;}.cke_hidpi .cke_ltr .cke_button__source_icon,.cke_ltr.cke_hidpi .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1120px !important;}.cke_hidpi .cke_button__specialchar_icon {background: url(icons_hidpi.png) no-repeat 0 -1152px !important;}.cke_hidpi .cke_button__scayt_icon {background: url(icons_hidpi.png) no-repeat 0 -1184px !important;}.cke_hidpi .cke_button__table_icon {background: url(icons_hidpi.png) no-repeat 0 -1216px !important;}.cke_rtl.cke_hidpi .cke_button__redo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1248px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1280px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1312px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1344px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png) no-repeat 0 -1376px !important;}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/editor_iequirks.css b/lam/templates/lib/extra/ckeditor/skins/kama/editor_iequirks.css
new file mode 100644
index 00000000..c1473d8c
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/editor_iequirks.css
@@ -0,0 +1,5 @@
+/*
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.md or http://ckeditor.com/license
+*/
+.cke_reset{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none}.cke_reset_all,.cke_reset_all *{margin:0;padding:0;border:0;background:transparent;text-decoration:none;width:auto;height:auto;vertical-align:baseline;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;position:static;-webkit-transition:none;-moz-transition:none;-ms-transition:none;transition:none;border-collapse:collapse;font:normal normal normal 12px Arial,Helvetica,Tahoma,Verdana,Sans-Serif;color:#000;text-align:left;white-space:nowrap;cursor:auto}.cke_reset_all .cke_rtl *{text-align:right}.cke_reset_all iframe{vertical-align:inherit}.cke_reset_all textarea{white-space:pre}.cke_reset_all textarea,.cke_reset_all input[type="text"],.cke_reset_all input[type="password"]{cursor:text}.cke_reset_all textarea[disabled],.cke_reset_all input[type="text"][disabled],.cke_reset_all input[type="password"][disabled]{cursor:default}.cke_reset_all fieldset{padding:10px;border:2px groove #e0dfe3}.cke_reset_all select{box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box}.cke_chrome{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;border:1px solid #d3d3d3;padding:5px}.cke_hc.cke_chrome{padding:2px}.cke_inner{display:block;-moz-border-radius:5px;-webkit-border-radius:5px;-webkit-touch-callout:none;border-radius:5px;background:#d3d3d3 url(images/sprites.png) repeat-x 0 -1950px;background:-webkit-gradient(linear,0 -15,0 40,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-webkit-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-o-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:-ms-linear-gradient(top,#fff -15px,#d3d3d3 40px);background:linear-gradient(top,#fff -15px,#d3d3d3 40px);padding:5px}.cke_float{background:#fff}.cke_float .cke_inner{padding-bottom:0}.cke_hc .cke_contents{border:1px solid black}.cke_top,.cke_contents,.cke_bottom{display:block;overflow:hidden}.cke_top{white-space:normal}.cke_browser_ios .cke_contents{overflow-y:auto;-webkit-overflow-scrolling:touch}.cke_resizer{width:0;height:0;overflow:hidden;border-width:12px 12px 0 12px;border-color:transparent #efefef transparent transparent;border-style:dashed solid dashed dashed;margin:10px 0 0;font-size:0;float:right;vertical-align:bottom;cursor:se-resize;opacity:.8}.cke_resizer_ltr{margin-left:-12px}.cke_resizer_rtl{float:left;border-color:transparent transparent transparent #efefef;border-style:dashed dashed dashed solid;margin-right:-12px;cursor:sw-resize}.cke_hc .cke_resizer{width:10px;height:10px;border:1px solid #fff;margin-left:0}.cke_hc .cke_resizer_rtl{margin-right:0}.cke_wysiwyg_div{display:block;height:100%;overflow:auto;padding:0 8px;outline-style:none;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.cke_panel{visibility:visible;border:1px solid #8f8f73;background-color:#fff;width:120px;height:100px;overflow:hidden;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.cke_menu_panel{padding:2px;margin:0}.cke_combopanel{border:1px solid #8f8f73;-moz-border-radius-topleft:0;-webkit-border-top-left-radius:0;border-top-left-radius:0;width:150px;height:170px}.cke_panel_frame{width:100%;height:100%;font-family:Arial,Verdana,sans-serif;font-size:12px;overflow:auto;overflow-x:hidden}.cke_panel_container{overflow-y:auto;overflow-x:hidden}.cke_panel_list{list-style-type:none;margin:3px;padding:0;white-space:nowrap}.cke_panel_listItem{margin:0}.cke_panel_listItem a{padding:2px;display:block;border:1px solid #fff;color:inherit!important;text-decoration:none;overflow:hidden;text-overflow:ellipsis}* html .cke_panel_listItem a{width:100%;color:#000}*:first-child+html .cke_panel_listItem a{color:#000}.cke_panel_listItem.cke_selected a{border:1px solid #ccc;background-color:#e9f5ff}.cke_panel_listItem a:hover,.cke_panel_listItem a:focus,.cke_panel_listItem a:active{border-color:#316ac5;background-color:#dff1ff}.cke_hc .cke_panel_listItem.cke_selected a,.cke_hc .cke_panel_listItem a:hover,.cke_hc .cke_panel_listItem a:focus,.cke_hc .cke_panel_listItem a:active{border-width:3px;padding:0}.cke_panel_grouptitle{font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif;font-weight:bold;white-space:nowrap;background-color:#dcdcdc;color:#000;margin:0;padding:3px}.cke_panel_listItem p,.cke_panel_listItem h1,.cke_panel_listItem h2,.cke_panel_listItem h3,.cke_panel_listItem h4,.cke_panel_listItem h5,.cke_panel_listItem h6,.cke_panel_listItem pre{margin-top:3px;margin-bottom:3px}.cke_colorblock{padding:3px;font-size:11px;font-family:'Microsoft Sans Serif',Tahoma,Arial,Verdana,Sans-Serif}.cke_colorblock,.cke_colorblock a{text-decoration:none;color:#000}span.cke_colorbox{width:10px;height:10px;border:#808080 1px solid;float:left}.cke_rtl span.cke_colorbox{float:right}a.cke_colorbox{border:#fff 1px solid;padding:2px;float:left;width:12px;height:12px}.cke_rtl a.cke_colorbox{float:right}a:hover.cke_colorbox,a:focus.cke_colorbox,a:active.cke_colorbox{border:#316ac5 1px solid;background-color:#dff1ff}a.cke_colorauto,a.cke_colormore{border:#fff 1px solid;padding:2px;display:block;cursor:pointer}a:hover.cke_colorauto,a:hover.cke_colormore,a:focus.cke_colorauto,a:focus.cke_colormore,a:active.cke_colorauto,a:active.cke_colormore{border:#316ac5 1px solid;background-color:#dff1ff}.cke_toolbar{float:left}.cke_rtl .cke_toolbar{float:right}.cke_toolgroup{-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;float:left;margin:0 6px 5px 0;padding:2px;background:url(images/sprites.png) repeat-x 0 -500px;background:-webkit-gradient(linear,0 0,0 100,from(#fff),to(#d3d3d3));background:-moz-linear-gradient(top,#fff,#d3d3d3 100px);background:-webkit-linear-gradient(top,#fff,#d3d3d3 100px);background:-o-linear-gradient(top,#fff,#d3d3d3 100px);background:-ms-linear-gradient(top,#fff,#d3d3d3 100px);background:linear-gradient(top,#fff,#d3d3d3 100px)}.cke_hc .cke_toolgroup{padding-right:0;margin-right:4px}.cke_rtl .cke_toolgroup{float:right;margin-left:6px;margin-right:0}.cke_rtl.cke_hc .cke_toolgroup{padding-left:0;margin-left:4px}a.cke_button{display:inline-block;height:18px;padding:2px 4px;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;outline:0;cursor:default;float:left;border:0}.cke_rtl .cke_button{float:right}.cke_hc .cke_button{border:1px solid black;padding:3px 5px;margin:-2px 4px 0 -2px}.cke_rtl.cke_hc .cke_button{margin:-2px -2px 0 4px}.cke_button_on{background-color:#a3d7ff}.cke_hc .cke_button_on{border-width:3px;padding:1px 3px}.cke_button_off{opacity:.7}.cke_button_disabled{opacity:.3}a.cke_button_on:hover,a.cke_button_on:focus,a.cke_button_on:active{background-color:#86caff}.cke_hc a.cke_button:hover{background:black}a.cke_button_off:hover,a.cke_button_off:focus,a.cke_button_off:active{background-color:#dff1ff;opacity:1}.cke_button_icon{cursor:inherit;background-repeat:no-repeat;margin-top:1px;width:16px;height:16px;float:left;display:inline-block}.cke_rtl .cke_button_icon{float:right}.cke_hc .cke_button_icon{display:none}.cke_button_label{display:none;padding-left:3px;margin-top:1px;line-height:16px;vertical-align:middle;float:left;cursor:default}.cke_hc .cke_button_label{padding:0;display:inline-block}.cke_rtl .cke_button_label{padding-right:3px;padding-left:0;float:right}.cke_button_arrow{display:inline-block;margin:7px 0 0 1px;width:0;height:0;border-width:3px;border-color:#2f2f2f transparent transparent transparent;border-style:solid dashed dashed dashed;cursor:default;vertical-align:middle}.cke_rtl .cke_button_arrow{margin-right:5px;margin-left:0}.cke_hc .cke_button_arrow{font-size:10px;margin:0 -2px 0 3px;width:auto;border:0}.cke_rtl.cke_hc .cke_button_arrow{margin:0 3px 0 -2px}.cke_toolbar_separator{float:left;border-left:solid 1px #d3d3d3;margin:3px 2px 0;height:16px}.cke_rtl .cke_toolbar_separator{border-right:solid 1px #d3d3d3;border-left:0;float:right}.cke_hc .cke_toolbar_separator{margin-left:0;width:3px}.cke_rtl.cke_hc .cke_toolbar_separator{margin:3px 0 0 2px}.cke_toolbar_break{display:block;clear:left}.cke_rtl .cke_toolbar_break{clear:right}.cke_toolbox_collapser{width:12px;height:11px;float:right;border:1px outset #d3d3d3;margin:11px 0 0;font-size:0;cursor:default;text-align:center}.cke_toolbox_collapser.cke_toolbox_collapser_min{margin:0 2px 4px}.cke_rtl .cke_toolbox_collapser{float:left}.cke_hc .cke_toolbox_collapser{border-width:1px}.cke_toolbox_collapser .cke_arrow{display:inline-block;height:0;width:0;font-size:0;border-width:3px;border-style:solid;border-color:transparent transparent #2f2f2f}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin:4px 2px 0 0;border-color:#2f2f2f transparent transparent}.cke_hc .cke_toolbox_collapser .cke_arrow{font-size:8px;width:auto;border:0;margin-top:0;margin-right:2px}.cke_menubutton{display:block}.cke_menuitem span{cursor:default}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3;display:block}.cke_hc .cke_menubutton:hover,.cke_hc .cke_menubutton:focus,.cke_hc .cke_menubutton:active{border:2px solid}.cke_menubutton_inner{display:table-row}.cke_menubutton_icon,.cke_menubutton_label,.cke_menuarrow{display:table-cell}.cke_menubutton_icon{background-color:#d3d3d3;opacity:.70;filter:alpha(opacity=70);padding:4px}.cke_hc .cke_menubutton_icon{height:16px;width:0;padding:4px 0}.cke_menubutton:hover .cke_menubutton_icon,.cke_menubutton:focus .cke_menubutton_icon,.cke_menubutton:active .cke_menubutton_icon{background-color:#9d9d9d}.cke_menubutton_disabled:hover .cke_menubutton_icon,.cke_menubutton_disabled:focus .cke_menubutton_icon,.cke_menubutton_disabled:active .cke_menubutton_icon{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_label{padding:0 5px;background-color:transparent;width:100%;vertical-align:middle}.cke_menubutton_disabled .cke_menubutton_label{opacity:.3;filter:alpha(opacity=30)}.cke_menubutton_on{border:1px solid #ccc;background-color:#e9f5ff}.cke_menubutton_on .cke_menubutton_icon{padding-right:3px}.cke_menubutton:hover,.cke_menubutton:focus,.cke_menubutton:active{background-color:#d3d3d3}.cke_menubutton_on:hover,.cke_menubutton_on:focus,.cke_menubutton_on:active{border-color:#316ac5;background-color:#dff1ff}.cke_panel_frame .cke_menubutton_label{display:none}.cke_menuseparator{background-color:#d3d3d3;height:2px;filter:alpha(opacity=70);opacity:.70}.cke_menuarrow{background-image:url(images/sprites.png);background-position:0 -1400px;background-repeat:no-repeat;padding:0 5px}.cke_rtl .cke_menuarrow{background-image:url(images/sprites.png);background-position:7px -1380px;background-repeat:no-repeat}.cke_menuarrow span{display:none}.cke_hc .cke_menuarrow span{vertical-align:middle;display:inline}.cke_combo{display:inline-block;float:left}.cke_rtl .cke_combo{float:right}.cke_combo_label{display:none;float:left;line-height:26px;vertical-align:top;margin-right:5px;filter:alpha(opacity = 70);opacity:.7}.cke_rtl .cke_combo_label{float:right;margin-left:5px;margin-right:0}.cke_combo_button{display:inline-block;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px;background:url(images/sprites.png) 0 -100px repeat-x;float:left;padding:2px 4px 2px 6px;height:22px;margin:0 5px 5px 0;background:-moz-linear-gradient(bottom,#fff,#d3d3d3 100px);background:-webkit-gradient(linear,left bottom,left -100,from(#fff),to(#d3d3d3))}.cke_combo_off .cke_combo_button:hover,.cke_combo_off .cke_combo_button:focus,.cke_combo_off .cke_combo_button:active{background:#dff1ff;outline:0}.cke_rtl .cke_combo_button{float:right;margin-left:5px;margin-right:0}.cke_hc .cke_combo_button{border:1px solid black;padding:1px 3px 1px 3px}.cke_hc .cke_rtl .cke_combo_button{border:1px solid black}.cke_combo_text{line-height:24px;text-overflow:ellipsis;overflow:hidden;color:#666;float:left;cursor:default;width:60px}.cke_rtl .cke_combo_text{float:right;text-align:right}.cke_combo_inlinelabel{font-style:italic;opacity:.70}.cke_combo_off .cke_combo_button:hover .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:active .cke_combo_inlinelabel,.cke_combo_off .cke_combo_button:focus .cke_combo_inlinelabel{opacity:1}.cke_combo_open{cursor:default;display:inline-block;font-size:0;height:19px;line-height:17px;margin:1px 3px;width:5px}.cke_combo_arrow{margin:9px 0 0;float:left;opacity:.70;height:0;width:0;font-size:0;border-left:3px solid transparent;border-right:3px solid transparent;border-top:3px solid #2f2f2f}.cke_hc .cke_combo_arrow{font-size:10px;width:auto;border:0;margin-top:4px}.cke_combo_disabled .cke_combo_inlinelabel,.cke_combo_disabled .cke_combo_open{opacity:.3}.cke_path{margin-top:5px;float:left}.cke_path_item,.cke_path_empty{display:inline-block;float:left;padding:1px 4px 0;color:#60676a;cursor:default;text-decoration:none;outline:0;border:0}.cke_rtl .cke_path,.cke_rtl .cke_path_item,.cke_rtl .cke_path_empty{float:right}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{background-color:#efefef;opacity:.7;color:#000}.cke_button__source_label,.cke_button__sourcedialog_label{display:inline}.cke_combo__fontsize .cke_combo_text{width:30px}.cke_combopanel__fontsize{width:120px}.cke_source{font-family:'Courier New',Monospace;font-size:small;background-color:#fff;white-space:pre}.cke_wysiwyg_frame,.cke_wysiwyg_div{background-color:#fff}.cke_chrome{visibility:inherit}.cke_voice_label{display:none}legend.cke_voice_label{display:none}.cke_button_off{filter:alpha(opacity = 70)}.cke_button_on{filter:alpha(opacity = 100)}.cke_button_disabled{filter:alpha(opacity = 30)}.cke_button_off:hover,.cke_button_off:focus,.cke_button_off:active{filter:alpha(opacity = 100)}.cke_hc .cke_button_arrow{margin-top:5px}.cke_combo_inlinelabel{filter:alpha(opacity = 70)}.cke_combo_button_off:hover .cke_combo_inlinelabel{filter:alpha(opacity = 100)}.cke_combo_button_disabled .cke_combo_inlinelabel,.cke_combo_button_disabled .cke_combo_open{filter:alpha(opacity = 30)}.cke_toolbox_collapser{border:2px outset #efefef}.cke_toolbox_collapser .cke_arrow{margin:0 1px 1px 1px}.cke_toolbox_collapser.cke_toolbox_collapser_min .cke_arrow{margin-left:2px}a.cke_path_item:hover,a.cke_path_item:focus,a.cke_path_item:active{filter:alpha(opacity = 70)}.cke_resizer{filter:alpha(opacity = 80)}.cke_hc .cke_resizer{filter:none;font-size:28px}.cke_menuarrow{position:absolute;right:2px}.cke_rtl .cke_menuarrow{position:absolute;left:2px}.cke_rtl .cke_dialog_footer_buttons .cke_dialog_ui_hbox_first{padding-left:10px!important}.cke_top,.cke_contents,.cke_bottom{width:100%}.cke_rtl .cke_toolgroup,.cke_rtl .cke_toolbar_separator,.cke_rtl .cke_button,.cke_rtl .cke_button *,.cke_rtl .cke_combo,.cke_rtl .cke_combo *,.cke_rtl .cke_path_item,.cke_rtl .cke_path_item *{float:none}.cke_rtl .cke_toolbar_separator,.cke_rtl .cke_combo_button,.cke_rtl .cke_combo_button *,.cke_rtl .cke_button,.cke_rtl .cke_button_icon,.cke_rtl .cke_button_arrow{vertical-align:top;display:inline-block}.cke_toolgroup,.cke_combo_button,.cke_combo_arrow,.cke_button_arrow,.cke_toolbox_collapser,.cke_resizer{background-image:url(images/sprites_ie6.png)}.cke_toolgroup{background-color:#fff;display:inline-block;padding:2px}.cke_inner{padding-top:2px;background-color:#d3d3d3;background-image:none}.cke_toolbar{margin:2px 0}.cke_rtl .cke_toolbar{margin-bottom:-1px;margin-top:-1px}.cke_toolbar_separator{vertical-align:top}.cke_toolbox{width:100%;float:left;padding-bottom:4px}.cke_rtl .cke_toolbox{margin-top:2px;margin-bottom:-4px}.cke_combo_button{background-color:#fff}.cke_rtl .cke_combo_button{padding-right:6px;padding-left:0}.cke_combo_text{line-height:21px}.cke_ltr .cke_combo_open{margin-left:-3px}.cke_combo_arrow{background-position:2px -1467px;margin:2px 0 0;border:0;width:8px;height:13px}.cke_rtl .cke_button_arrow{background-position-x:0}.cke_toolbox_collapser .cke_arrow{display:block;visibility:hidden;font-size:0;color:transparent;border:0}.cke_button_arrow{background-position:2px -1467px;margin:0;border:0;width:8px;height:15px}.cke_ltr .cke_button_arrow{background-position:0 -1467px;margin-left:-3px}.cke_toolbox_collapser{background-position:3px -1367px}.cke_toolbox_collapser_min{background-position:4px -1387px;margin:2px 0 0}.cke_rtl .cke_toolbox_collapser_min{background-position:4px -1408px}.cke_resizer{background-position:0 -1427px;width:12px;height:12px;border:0;margin:9px 0 0;vertical-align:baseline}.cke_dialog_tabs{position:absolute;top:38px;left:0}.cke_dialog_body{clear:both;margin-top:20px}a.cke_dialog_ui_button{background:url(images/sprites.png) repeat_x 0 _ 1069px}a.cke_dialog_ui_button:hover,a.cke_dialog_ui_button:focus,a.cke_dialog_ui_button:active{background-position:0 -1179px}a.cke_dialog_ui_button_ok{background:url(images/sprites.png) repeat_x 0 _ 1144px}a.cke_dialog_ui_button_cancel{background:url(images/sprites.png) repeat_x 0 _ 1105px}a.cke_dialog_ui_button_ok span,a.cke_dialog_ui_button_cancel span{background-image:none}.cke_menubutton_label{height:25px}.cke_menuarrow{background-image:url(images/sprites_ie6.png)}.cke_menuitem .cke_icon,.cke_button_icon,.cke_menuitem .cke_disabled .cke_icon,.cke_button_disabled .cke_button_icon{filter:""}.cke_menuseparator{font-size:0}.cke_colorbox{font-size:0}.cke_source{white-space:normal}.cke_button__about_icon {background: url(icons.png) no-repeat 0 -0px !important;}.cke_button__bold_icon {background: url(icons.png) no-repeat 0 -24px !important;}.cke_button__italic_icon {background: url(icons.png) no-repeat 0 -48px !important;}.cke_button__strike_icon {background: url(icons.png) no-repeat 0 -72px !important;}.cke_button__subscript_icon {background: url(icons.png) no-repeat 0 -96px !important;}.cke_button__superscript_icon {background: url(icons.png) no-repeat 0 -120px !important;}.cke_button__underline_icon {background: url(icons.png) no-repeat 0 -144px !important;}.cke_button__blockquote_icon {background: url(icons.png) no-repeat 0 -168px !important;}.cke_rtl .cke_button__copy_icon, .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -192px !important;}.cke_ltr .cke_button__copy_icon {background: url(icons.png) no-repeat 0 -216px !important;}.cke_rtl .cke_button__cut_icon, .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -240px !important;}.cke_ltr .cke_button__cut_icon {background: url(icons.png) no-repeat 0 -264px !important;}.cke_rtl .cke_button__paste_icon, .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -288px !important;}.cke_ltr .cke_button__paste_icon {background: url(icons.png) no-repeat 0 -312px !important;}.cke_button__horizontalrule_icon {background: url(icons.png) no-repeat 0 -336px !important;}.cke_button__image_icon {background: url(icons.png) no-repeat 0 -360px !important;}.cke_rtl .cke_button__indent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -384px !important;}.cke_ltr .cke_button__indent_icon {background: url(icons.png) no-repeat 0 -408px !important;}.cke_rtl .cke_button__outdent_icon, .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -432px !important;}.cke_ltr .cke_button__outdent_icon {background: url(icons.png) no-repeat 0 -456px !important;}.cke_rtl .cke_button__anchor_icon, .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -480px !important;}.cke_ltr .cke_button__anchor_icon {background: url(icons.png) no-repeat 0 -504px !important;}.cke_button__link_icon {background: url(icons.png) no-repeat 0 -528px !important;}.cke_button__unlink_icon {background: url(icons.png) no-repeat 0 -552px !important;}.cke_rtl .cke_button__bulletedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -576px !important;}.cke_ltr .cke_button__bulletedlist_icon {background: url(icons.png) no-repeat 0 -600px !important;}.cke_rtl .cke_button__numberedlist_icon, .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -624px !important;}.cke_ltr .cke_button__numberedlist_icon {background: url(icons.png) no-repeat 0 -648px !important;}.cke_button__maximize_icon {background: url(icons.png) no-repeat 0 -672px !important;}.cke_rtl .cke_button__pastetext_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -696px !important;}.cke_ltr .cke_button__pastetext_icon {background: url(icons.png) no-repeat 0 -720px !important;}.cke_rtl .cke_button__pastefromword_icon, .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -744px !important;}.cke_ltr .cke_button__pastefromword_icon {background: url(icons.png) no-repeat 0 -768px !important;}.cke_button__removeformat_icon {background: url(icons.png) no-repeat 0 -792px !important;}.cke_rtl .cke_button__source_icon, .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons.png) no-repeat 0 -816px !important;}.cke_ltr .cke_button__source_icon {background: url(icons.png) no-repeat 0 -840px !important;}.cke_button__specialchar_icon {background: url(icons.png) no-repeat 0 -864px !important;}.cke_button__scayt_icon {background: url(icons.png) no-repeat 0 -888px !important;}.cke_button__table_icon {background: url(icons.png) no-repeat 0 -912px !important;}.cke_rtl .cke_button__redo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -936px !important;}.cke_ltr .cke_button__redo_icon {background: url(icons.png) no-repeat 0 -960px !important;}.cke_rtl .cke_button__undo_icon, .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -984px !important;}.cke_ltr .cke_button__undo_icon {background: url(icons.png) no-repeat 0 -1008px !important;}.cke_button__spellchecker_icon {background: url(icons.png) no-repeat 0 -1032px !important;}.cke_hidpi .cke_button__about_icon {background: url(icons_hidpi.png) no-repeat 0 -0px !important;}.cke_hidpi .cke_button__bold_icon {background: url(icons_hidpi.png) no-repeat 0 -32px !important;}.cke_hidpi .cke_button__italic_icon {background: url(icons_hidpi.png) no-repeat 0 -64px !important;}.cke_hidpi .cke_button__strike_icon {background: url(icons_hidpi.png) no-repeat 0 -96px !important;}.cke_hidpi .cke_button__subscript_icon {background: url(icons_hidpi.png) no-repeat 0 -128px !important;}.cke_hidpi .cke_button__superscript_icon {background: url(icons_hidpi.png) no-repeat 0 -160px !important;}.cke_hidpi .cke_button__underline_icon {background: url(icons_hidpi.png) no-repeat 0 -192px !important;}.cke_hidpi .cke_button__blockquote_icon {background: url(icons_hidpi.png) no-repeat 0 -224px !important;}.cke_rtl.cke_hidpi .cke_button__copy_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -256px !important;}.cke_hidpi .cke_ltr .cke_button__copy_icon,.cke_ltr.cke_hidpi .cke_button__copy_icon {background: url(icons_hidpi.png) no-repeat 0 -288px !important;}.cke_rtl.cke_hidpi .cke_button__cut_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -320px !important;}.cke_hidpi .cke_ltr .cke_button__cut_icon,.cke_ltr.cke_hidpi .cke_button__cut_icon {background: url(icons_hidpi.png) no-repeat 0 -352px !important;}.cke_rtl.cke_hidpi .cke_button__paste_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -384px !important;}.cke_hidpi .cke_ltr .cke_button__paste_icon,.cke_ltr.cke_hidpi .cke_button__paste_icon {background: url(icons_hidpi.png) no-repeat 0 -416px !important;}.cke_hidpi .cke_button__horizontalrule_icon {background: url(icons_hidpi.png) no-repeat 0 -448px !important;}.cke_hidpi .cke_button__image_icon {background: url(icons_hidpi.png) no-repeat 0 -480px !important;}.cke_rtl.cke_hidpi .cke_button__indent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -512px !important;}.cke_hidpi .cke_ltr .cke_button__indent_icon,.cke_ltr.cke_hidpi .cke_button__indent_icon {background: url(icons_hidpi.png) no-repeat 0 -544px !important;}.cke_rtl.cke_hidpi .cke_button__outdent_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -576px !important;}.cke_hidpi .cke_ltr .cke_button__outdent_icon,.cke_ltr.cke_hidpi .cke_button__outdent_icon {background: url(icons_hidpi.png) no-repeat 0 -608px !important;}.cke_rtl.cke_hidpi .cke_button__anchor_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -640px !important;}.cke_hidpi .cke_ltr .cke_button__anchor_icon,.cke_ltr.cke_hidpi .cke_button__anchor_icon {background: url(icons_hidpi.png) no-repeat 0 -672px !important;}.cke_hidpi .cke_button__link_icon {background: url(icons_hidpi.png) no-repeat 0 -704px !important;}.cke_hidpi .cke_button__unlink_icon {background: url(icons_hidpi.png) no-repeat 0 -736px !important;}.cke_rtl.cke_hidpi .cke_button__bulletedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -768px !important;}.cke_hidpi .cke_ltr .cke_button__bulletedlist_icon,.cke_ltr.cke_hidpi .cke_button__bulletedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -800px !important;}.cke_rtl.cke_hidpi .cke_button__numberedlist_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -832px !important;}.cke_hidpi .cke_ltr .cke_button__numberedlist_icon,.cke_ltr.cke_hidpi .cke_button__numberedlist_icon {background: url(icons_hidpi.png) no-repeat 0 -864px !important;}.cke_hidpi .cke_button__maximize_icon {background: url(icons_hidpi.png) no-repeat 0 -896px !important;}.cke_rtl.cke_hidpi .cke_button__pastetext_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -928px !important;}.cke_hidpi .cke_ltr .cke_button__pastetext_icon,.cke_ltr.cke_hidpi .cke_button__pastetext_icon {background: url(icons_hidpi.png) no-repeat 0 -960px !important;}.cke_rtl.cke_hidpi .cke_button__pastefromword_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -992px !important;}.cke_hidpi .cke_ltr .cke_button__pastefromword_icon,.cke_ltr.cke_hidpi .cke_button__pastefromword_icon {background: url(icons_hidpi.png) no-repeat 0 -1024px !important;}.cke_hidpi .cke_button__removeformat_icon {background: url(icons_hidpi.png) no-repeat 0 -1056px !important;}.cke_rtl.cke_hidpi .cke_button__source_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1088px !important;}.cke_hidpi .cke_ltr .cke_button__source_icon,.cke_ltr.cke_hidpi .cke_button__source_icon {background: url(icons_hidpi.png) no-repeat 0 -1120px !important;}.cke_hidpi .cke_button__specialchar_icon {background: url(icons_hidpi.png) no-repeat 0 -1152px !important;}.cke_hidpi .cke_button__scayt_icon {background: url(icons_hidpi.png) no-repeat 0 -1184px !important;}.cke_hidpi .cke_button__table_icon {background: url(icons_hidpi.png) no-repeat 0 -1216px !important;}.cke_rtl.cke_hidpi .cke_button__redo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1248px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png) no-repeat 0 -1280px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1312px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png) no-repeat 0 -1344px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png) no-repeat 0 -1376px !important;}
\ No newline at end of file
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/icons.png b/lam/templates/lib/extra/ckeditor/skins/kama/icons.png
new file mode 100644
index 00000000..e5ea6531
Binary files /dev/null and b/lam/templates/lib/extra/ckeditor/skins/kama/icons.png differ
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/icons_hidpi.png b/lam/templates/lib/extra/ckeditor/skins/kama/icons_hidpi.png
new file mode 100644
index 00000000..44f3af7a
Binary files /dev/null and b/lam/templates/lib/extra/ckeditor/skins/kama/icons_hidpi.png differ
diff --git a/lam/templates/lib/extra/ckeditor/skins/kama/readme.md b/lam/templates/lib/extra/ckeditor/skins/kama/readme.md
new file mode 100644
index 00000000..ac304db8
--- /dev/null
+++ b/lam/templates/lib/extra/ckeditor/skins/kama/readme.md
@@ -0,0 +1,40 @@
+"Kama" Skin
+====================
+
+"Kama" is the default skin of CKEditor 3.x.
+It's been ported to CKEditor 4 and fully featured.
+
+For more information about skins, please check the [CKEditor Skin SDK](http://docs.cksource.com/CKEditor_4.x/Skin_SDK)
+documentation.
+
+Directory Structure
+-------------------
+
+CSS parts:
+- **editor.css**: the main CSS file. It's simply loading several other files, for easier maintenance,
+- **mainui.css**: the file contains styles of entire editor outline structures,
+- **toolbar.css**: the file contains styles of the editor toolbar space (top),
+- **richcombo.css**: the file contains styles of the rich combo ui elements on toolbar,
+- **panel.css**: the file contains styles of the rich combo drop-down, it's not loaded
+until the first panel open up,
+- **elementspath.css**: the file contains styles of the editor elements path bar (bottom),
+- **menu.css**: the file contains styles of all editor menus including context menu and button drop-down,
+it's not loaded until the first menu open up,
+- **dialog.css**: the CSS files for the dialog UI, it's not loaded until the first dialog open,
+- **reset.css**: the file defines the basis of style resets among all editor UI spaces,
+- **preset.css**: the file defines the default styles of some UI elements reflecting the skin preference,
+- **editor_XYZ.css** and **dialog_XYZ.css**: browser specific CSS hacks.
+
+Other parts:
+- **skin.js**: the only JavaScript part of the skin that registers the skin, its browser specific files and its icons and defines the Chameleon feature,
+- **icons/**: contains all skin defined icons,
+- **images/**: contains a fill general used images.
+
+License
+-------
+
+Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
+
+Licensed under the terms of any of the following licenses at your choice: [GPL](http://www.gnu.org/licenses/gpl.html), [LGPL](http://www.gnu.org/licenses/lgpl.html) and [MPL](http://www.mozilla.org/MPL/MPL-1.1.html).
+
+See LICENSE.md for more information.