From 7adcb81e4f83f98c468889aaa5a85558ba88c770 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Isma=C3=ABl=20Bouya?= Date: Mon, 25 Jan 2016 17:45:33 +0100 Subject: Initial commit --- sources/core/_bootstrap.js | 74 + sources/core/ckeditor.js | 204 +++ sources/core/ckeditor_base.js | 314 ++++ sources/core/ckeditor_basic.js | 94 + sources/core/command.js | 275 +++ sources/core/commanddefinition.js | 148 ++ sources/core/config.js | 451 +++++ sources/core/creators/inline.js | 157 ++ sources/core/creators/themedui.js | 541 ++++++ sources/core/dataprocessor.js | 70 + sources/core/dom.js | 13 + sources/core/dom/comment.js | 53 + sources/core/dom/document.js | 326 ++++ sources/core/dom/documentfragment.js | 62 + sources/core/dom/domobject.js | 266 +++ sources/core/dom/element.js | 2107 +++++++++++++++++++++ sources/core/dom/elementpath.js | 251 +++ sources/core/dom/event.js | 208 +++ sources/core/dom/iterator.js | 565 ++++++ sources/core/dom/node.js | 897 +++++++++ sources/core/dom/nodelist.js | 43 + sources/core/dom/range.js | 2860 +++++++++++++++++++++++++++++ sources/core/dom/rangelist.js | 199 ++ sources/core/dom/text.js | 135 ++ sources/core/dom/walker.js | 652 +++++++ sources/core/dom/window.js | 95 + sources/core/dtd.js | 349 ++++ sources/core/editable.js | 3158 ++++++++++++++++++++++++++++++++ sources/core/editor.js | 1963 ++++++++++++++++++++ sources/core/editor_basic.js | 36 + sources/core/env.js | 361 ++++ sources/core/event.js | 389 ++++ sources/core/eventInfo.js | 115 ++ sources/core/filter.js | 2440 ++++++++++++++++++++++++ sources/core/focusmanager.js | 273 +++ sources/core/htmldataprocessor.js | 1036 +++++++++++ sources/core/htmlparser.js | 205 +++ sources/core/htmlparser/basicwriter.js | 152 ++ sources/core/htmlparser/cdata.js | 48 + sources/core/htmlparser/comment.js | 80 + sources/core/htmlparser/element.js | 536 ++++++ sources/core/htmlparser/filter.js | 407 ++++ sources/core/htmlparser/fragment.js | 646 +++++++ sources/core/htmlparser/node.js | 156 ++ sources/core/htmlparser/text.js | 70 + sources/core/keystrokehandler.js | 169 ++ sources/core/lang.js | 103 ++ sources/core/loader.js | 225 +++ sources/core/log.js | 127 ++ sources/core/plugindefinition.js | 177 ++ sources/core/plugins.js | 119 ++ sources/core/resourcemanager.js | 228 +++ sources/core/scriptloader.js | 203 ++ sources/core/selection.js | 2183 ++++++++++++++++++++++ sources/core/skin.js | 350 ++++ sources/core/style.js | 2089 +++++++++++++++++++++ sources/core/template.js | 68 + sources/core/tools.js | 1386 ++++++++++++++ sources/core/ui.js | 185 ++ 59 files changed, 31092 insertions(+) create mode 100644 sources/core/_bootstrap.js create mode 100644 sources/core/ckeditor.js create mode 100644 sources/core/ckeditor_base.js create mode 100644 sources/core/ckeditor_basic.js create mode 100644 sources/core/command.js create mode 100644 sources/core/commanddefinition.js create mode 100644 sources/core/config.js create mode 100644 sources/core/creators/inline.js create mode 100644 sources/core/creators/themedui.js create mode 100644 sources/core/dataprocessor.js create mode 100644 sources/core/dom.js create mode 100644 sources/core/dom/comment.js create mode 100644 sources/core/dom/document.js create mode 100644 sources/core/dom/documentfragment.js create mode 100644 sources/core/dom/domobject.js create mode 100644 sources/core/dom/element.js create mode 100644 sources/core/dom/elementpath.js create mode 100644 sources/core/dom/event.js create mode 100644 sources/core/dom/iterator.js create mode 100644 sources/core/dom/node.js create mode 100644 sources/core/dom/nodelist.js create mode 100644 sources/core/dom/range.js create mode 100644 sources/core/dom/rangelist.js create mode 100644 sources/core/dom/text.js create mode 100644 sources/core/dom/walker.js create mode 100644 sources/core/dom/window.js create mode 100644 sources/core/dtd.js create mode 100644 sources/core/editable.js create mode 100644 sources/core/editor.js create mode 100644 sources/core/editor_basic.js create mode 100644 sources/core/env.js create mode 100644 sources/core/event.js create mode 100644 sources/core/eventInfo.js create mode 100644 sources/core/filter.js create mode 100644 sources/core/focusmanager.js create mode 100644 sources/core/htmldataprocessor.js create mode 100644 sources/core/htmlparser.js create mode 100644 sources/core/htmlparser/basicwriter.js create mode 100644 sources/core/htmlparser/cdata.js create mode 100644 sources/core/htmlparser/comment.js create mode 100644 sources/core/htmlparser/element.js create mode 100644 sources/core/htmlparser/filter.js create mode 100644 sources/core/htmlparser/fragment.js create mode 100644 sources/core/htmlparser/node.js create mode 100644 sources/core/htmlparser/text.js create mode 100644 sources/core/keystrokehandler.js create mode 100644 sources/core/lang.js create mode 100644 sources/core/loader.js create mode 100644 sources/core/log.js create mode 100644 sources/core/plugindefinition.js create mode 100644 sources/core/plugins.js create mode 100644 sources/core/resourcemanager.js create mode 100644 sources/core/scriptloader.js create mode 100644 sources/core/selection.js create mode 100644 sources/core/skin.js create mode 100644 sources/core/style.js create mode 100644 sources/core/template.js create mode 100644 sources/core/tools.js create mode 100644 sources/core/ui.js (limited to 'sources/core') diff --git a/sources/core/_bootstrap.js b/sources/core/_bootstrap.js new file mode 100644 index 00000000..dac236bd --- /dev/null +++ b/sources/core/_bootstrap.js @@ -0,0 +1,74 @@ +/** + * @license Copyright (c) 2003-2015, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or http://ckeditor.com/license + */ + +/** + * @fileOverview API initialization code. + */ + +( function() { + // Disable HC detection in WebKit. (#5429) + if ( CKEDITOR.env.webkit ) + CKEDITOR.env.hc = false; + else { + // Check whether high contrast is active by creating a colored border. + var hcDetect = CKEDITOR.dom.element.createFromHtml( '
', CKEDITOR.document ); + + hcDetect.appendTo( CKEDITOR.document.getHead() ); + + // Update CKEDITOR.env. + // Catch exception needed sometimes for FF. (#4230) + try { + var top = hcDetect.getComputedStyle( 'border-top-color' ), + right = hcDetect.getComputedStyle( 'border-right-color' ); + + // We need to check if getComputedStyle returned any value, because on FF + // it returnes empty string if CKEditor is loaded in hidden iframe. (#11121) + CKEDITOR.env.hc = !!( top && top == right ); + } catch ( e ) { + CKEDITOR.env.hc = false; + } + + hcDetect.remove(); + } + + if ( CKEDITOR.env.hc ) + CKEDITOR.env.cssClass += ' cke_hc'; + + // Initially hide UI spaces when relevant skins are loading, later restored by skin css. + CKEDITOR.document.appendStyleText( '.cke{visibility:hidden;}' ); + + // Mark the editor as fully loaded. + CKEDITOR.status = 'loaded'; + CKEDITOR.fireOnce( 'loaded' ); + + // Process all instances created by the "basic" implementation. + var pending = CKEDITOR._.pending; + if ( pending ) { + delete CKEDITOR._.pending; + + for ( var i = 0; i < pending.length; i++ ) { + CKEDITOR.editor.prototype.constructor.apply( pending[ i ][ 0 ], pending[ i ][ 1 ] ); + CKEDITOR.add( pending[ i ][ 0 ] ); + } + } +} )(); + +/** + * Indicates that CKEditor is running on a High Contrast environment. + * + * if ( CKEDITOR.env.hc ) + * alert( 'You\'re running on High Contrast mode. The editor interface will get adapted to provide you a better experience.' ); + * + * @property {Boolean} hc + * @member CKEDITOR.env + */ + +/** + * Fired when a CKEDITOR core object is fully loaded and ready for interaction. + * + * @event loaded + * @member CKEDITOR + */ diff --git a/sources/core/ckeditor.js b/sources/core/ckeditor.js new file mode 100644 index 00000000..948bc13b --- /dev/null +++ b/sources/core/ckeditor.js @@ -0,0 +1,204 @@ +/** + * @license Copyright (c) 2003-2015, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or http://ckeditor.com/license + */ + +/** + * @fileOverview Contains the third and last part of the {@link CKEDITOR} object + * definition. + */ + +/** @class CKEDITOR */ + +// Remove the CKEDITOR.loadFullCore reference defined on ckeditor_basic. +delete CKEDITOR.loadFullCore; + +/** + * Stores references to all editor instances created. The name of the properties + * in this object correspond to instance names, and their values contain the + * {@link CKEDITOR.editor} object representing them. + * + * alert( CKEDITOR.instances.editor1.name ); // 'editor1' + * + * @property {Object} + */ +CKEDITOR.instances = {}; + +/** + * The document of the window storing the CKEDITOR object. + * + * alert( CKEDITOR.document.getBody().getName() ); // 'body' + * + * @property {CKEDITOR.dom.document} + */ +CKEDITOR.document = new CKEDITOR.dom.document( document ); + +/** + * Adds an editor instance to the global {@link CKEDITOR} object. This function + * is available for internal use mainly. + * + * @param {CKEDITOR.editor} editor The editor instance to be added. + */ +CKEDITOR.add = function( editor ) { + CKEDITOR.instances[ editor.name ] = editor; + + editor.on( 'focus', function() { + if ( CKEDITOR.currentInstance != editor ) { + CKEDITOR.currentInstance = editor; + CKEDITOR.fire( 'currentInstance' ); + } + } ); + + editor.on( 'blur', function() { + if ( CKEDITOR.currentInstance == editor ) { + CKEDITOR.currentInstance = null; + CKEDITOR.fire( 'currentInstance' ); + } + } ); + + CKEDITOR.fire( 'instance', null, editor ); +}; + +/** + * Removes an editor instance from the global {@link CKEDITOR} object. This function + * is available for internal use only. External code must use {@link CKEDITOR.editor#method-destroy}. + * + * @private + * @param {CKEDITOR.editor} editor The editor instance to be removed. + */ +CKEDITOR.remove = function( editor ) { + delete CKEDITOR.instances[ editor.name ]; +}; + +( function() { + var tpls = {}; + + /** + * Adds a named {@link CKEDITOR.template} instance to be reused among all editors. + * This will return the existing one if a template with same name is already + * defined. Additionally, it fires the "template" event to allow template source customization. + * + * @param {String} name The name which identifies a UI template. + * @param {String} source The source string for constructing this template. + * @returns {CKEDITOR.template} The created template instance. + */ + CKEDITOR.addTemplate = function( name, source ) { + var tpl = tpls[ name ]; + if ( tpl ) + return tpl; + + // Make it possible to customize the template through event. + var params = { name: name, source: source }; + CKEDITOR.fire( 'template', params ); + + return ( tpls[ name ] = new CKEDITOR.template( params.source ) ); + }; + + /** + * Retrieves a defined template created with {@link CKEDITOR#addTemplate}. + * + * @param {String} name The template name. + */ + CKEDITOR.getTemplate = function( name ) { + return tpls[ name ]; + }; +} )(); + +( function() { + var styles = []; + + /** + * Adds CSS rules to be appended to the editor document. + * This method is mostly used by plugins to add custom styles to the editor + * document. For basic content styling the `contents.css` file should be + * used instead. + * + * **Note:** This function should be called before the creation of editor instances. + * + * // Add styles for all headings inside editable contents. + * CKEDITOR.addCss( '.cke_editable h1,.cke_editable h2,.cke_editable h3 { border-bottom: 1px dotted red }' ); + * + * @param {String} css The style rules to be appended. + * @see CKEDITOR.config#contentsCss + */ + CKEDITOR.addCss = function( css ) { + styles.push( css ); + }; + + /** + * Returns a string will all CSS rules passed to the {@link CKEDITOR#addCss} method. + * + * @returns {String} A string containing CSS rules. + */ + CKEDITOR.getCss = function() { + return styles.join( '\n' ); + }; +} )(); + +// Perform global clean up to free as much memory as possible +// when there are no instances left +CKEDITOR.on( 'instanceDestroyed', function() { + if ( CKEDITOR.tools.isEmpty( this.instances ) ) + CKEDITOR.fire( 'reset' ); +} ); + +// Load the bootstrap script. +CKEDITOR.loader.load( '_bootstrap' ); // %REMOVE_LINE% + +// Tri-state constants. +/** + * Used to indicate the ON or ACTIVE state. + * + * @readonly + * @property {Number} [=1] + */ +CKEDITOR.TRISTATE_ON = 1; + +/** + * Used to indicate the OFF or INACTIVE state. + * + * @readonly + * @property {Number} [=2] + */ +CKEDITOR.TRISTATE_OFF = 2; + +/** + * Used to indicate the DISABLED state. + * + * @readonly + * @property {Number} [=0] + */ +CKEDITOR.TRISTATE_DISABLED = 0; + +/** + * The editor which is currently active (has user focus). + * + * function showCurrentEditorName() { + * if ( CKEDITOR.currentInstance ) + * alert( CKEDITOR.currentInstance.name ); + * else + * alert( 'Please focus an editor first.' ); + * } + * + * @property {CKEDITOR.editor} currentInstance + * @see CKEDITOR#event-currentInstance + */ + +/** + * Fired when the CKEDITOR.currentInstance object reference changes. This may + * happen when setting the focus on different editor instances in the page. + * + * var editor; // A variable to store a reference to the current editor. + * CKEDITOR.on( 'currentInstance', function() { + * editor = CKEDITOR.currentInstance; + * } ); + * + * @event currentInstance + */ + +/** + * Fired when the last instance has been destroyed. This event is used to perform + * global memory cleanup. + * + * @event reset + */ diff --git a/sources/core/ckeditor_base.js b/sources/core/ckeditor_base.js new file mode 100644 index 00000000..10ae573d --- /dev/null +++ b/sources/core/ckeditor_base.js @@ -0,0 +1,314 @@ +/** + * @license Copyright (c) 2003-2015, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or http://ckeditor.com/license + */ + +/** + * @fileOverview Contains the first and essential part of the {@link CKEDITOR} + * object definition. + */ + +// #### Compressed Code +// Compressed code in ckeditor.js must be be updated on changes in the script. +// The Closure Compiler online service should be used when updating this manually: +// http://closure-compiler.appspot.com/ + +// #### Raw code +// ATTENTION: read the above "Compressed Code" notes when changing this code. + +if ( !window.CKEDITOR ) { + /** + * This is the API entry point. The entire CKEditor code runs under this object. + * @class CKEDITOR + * @singleton + */ + window.CKEDITOR = ( function() { + var basePathSrcPattern = /(^|.*[\\\/])ckeditor\.js(?:\?.*|;.*)?$/i; + + var CKEDITOR = { + + /** + * A constant string unique for each release of CKEditor. Its value + * is used, by default, to build the URL for all resources loaded + * by the editor code, guaranteeing clean cache results when + * upgrading. + * + * alert( CKEDITOR.timestamp ); // e.g. '87dm' + */ + timestamp: '', // %REMOVE_LINE% + /* // %REMOVE_LINE% + // The production implementation contains a fixed timestamp, unique + // for each release and generated by the releaser. + // (Base 36 value of each component of YYMMDDHH - 4 chars total - e.g. 87bm == 08071122) + timestamp: '%TIMESTAMP%', + // %REMOVE_LINE% */ + + /** + * Contains the CKEditor version number. + * + * alert( CKEDITOR.version ); // e.g. 'CKEditor 3.4.1' + */ + version: '%VERSION%', + + /** + * Contains the CKEditor revision number. + * The revision number is incremented automatically, following each + * modification to the CKEditor source code. + * + * alert( CKEDITOR.revision ); // e.g. '3975' + */ + revision: '%REV%', + + /** + * A 3-digit random integer, valid for the entire life of the CKEDITOR object. + * + * alert( CKEDITOR.rnd ); // e.g. 319 + * + * @property {Number} + */ + rnd: Math.floor( Math.random() * ( 999 /*Max*/ - 100 /*Min*/ + 1 ) ) + 100 /*Min*/, + + /** + * Private object used to hold core stuff. It should not be used outside of + * the API code as properties defined here may change at any time + * without notice. + * + * @private + */ + _: { + pending: [], + basePathSrcPattern: basePathSrcPattern + }, + + /** + * Indicates the API loading status. The following statuses are available: + * + * * **unloaded**: the API is not yet loaded. + * * **basic_loaded**: the basic API features are available. + * * **basic_ready**: the basic API is ready to load the full core code. + * * **loaded**: the API can be fully used. + * + * Example: + * + * if ( CKEDITOR.status == 'loaded' ) { + * // The API can now be fully used. + * doSomething(); + * } else { + * // Wait for the full core to be loaded and fire its loading. + * CKEDITOR.on( 'load', doSomething ); + * CKEDITOR.loadFullCore && CKEDITOR.loadFullCore(); + * } + */ + status: 'unloaded', + + /** + * The full URL for the CKEditor installation directory. + * It is possible to manually provide the base path by setting a + * global variable named `CKEDITOR_BASEPATH`. This global variable + * must be set **before** the editor script loading. + * + * alert( CKEDITOR.basePath ); // e.g. 'http://www.example.com/ckeditor/' + * + * @property {String} + */ + basePath: ( function() { + // Find out the editor directory path, based on its + * + * + *
+ * + * + * + * + * @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 ` + * + * + * + * + * + * + * @param {String} [className] The ` + data = protectElements( data, protectTextareaRegex ); + + // Before anything, we must protect the URL attributes as the + // browser may changing them when setting the innerHTML later in + // the code. + data = protectAttributes( data ); + + // Protect elements than can't be set inside a DIV. E.g. IE removes + // style tags from innerHTML. (#3710) + data = protectElements( data, protectElementsRegex ); + + // Certain elements has problem to go through DOM operation, protect + // them by prefixing 'cke' namespace. (#3591) + data = protectElementsNames( data ); + + // All none-IE browsers ignore self-closed custom elements, + // protecting them into open-close. (#3591) + data = protectSelfClosingElements( data ); + + // Compensate one leading line break after 
 open as browsers
+			// eat it up. (#5789)
+			data = protectPreFormatted( data );
+
+			// There are attributes which may execute JavaScript code inside fixBin.
+			// Encode them greedily. They will be unprotected right after getting HTML from fixBin. (#10)
+			data = protectInsecureAttributes( data );
+
+			var fixBin = evtData.context || editor.editable().getName(),
+				isPre;
+
+			// Old IEs loose formats when load html into 
.
+			if ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 && fixBin == 'pre' ) {
+				fixBin = 'div';
+				data = '
' + data + '
';
+				isPre = 1;
+			}
+
+			// Call the browser to help us fixing a possibly invalid HTML
+			// structure.
+			var el = editor.document.createElement( fixBin );
+			// Add fake character to workaround IE comments bug. (#3801)
+			el.setHtml( 'a' + data );
+			data = el.getHtml().substr( 1 );
+
+			// Restore shortly protected attribute names.
+			data = data.replace( new RegExp( 'data-cke-' + CKEDITOR.rnd + '-', 'ig' ), '' );
+
+			isPre && ( data = data.replace( /^
|<\/pre>$/gi, '' ) );
+
+			// Unprotect "some" of the protected elements at this point.
+			data = unprotectElementNames( data );
+
+			data = unprotectElements( data );
+
+			// Restore the comments that have been protected, in this way they
+			// can be properly filtered.
+			data = unprotectRealComments( data );
+
+			if ( evtData.fixForBody === false ) {
+				fixBodyTag = false;
+			} else {
+				fixBodyTag = getFixBodyTag( evtData.enterMode, editor.config.autoParagraph );
+			}
+
+			// Now use our parser to make further fixes to the structure, as
+			// well as apply the filter.
+			data = CKEDITOR.htmlParser.fragment.fromHtml( data, evtData.context, fixBodyTag );
+
+			// The empty root element needs to be fixed by adding 'p' or 'div' into it.
+			// This avoids the need to create that element on the first focus (#12630).
+			if ( fixBodyTag ) {
+				fixEmptyRoot( data, fixBodyTag );
+			}
+
+			evtData.dataValue = data;
+		}, null, null, 5 );
+
+		// Filter incoming "data".
+		// Add element filter before htmlDataProcessor.dataFilter when purifying input data to correct html.
+		editor.on( 'toHtml', function( evt ) {
+			if ( evt.data.filter.applyTo( evt.data.dataValue, true, evt.data.dontFilter, evt.data.enterMode ) )
+				editor.fire( 'dataFiltered' );
+		}, null, null, 6 );
+
+		editor.on( 'toHtml', function( evt ) {
+			evt.data.dataValue.filterChildren( that.dataFilter, true );
+		}, null, null, 10 );
+
+		editor.on( 'toHtml', function( evt ) {
+			var evtData = evt.data,
+				data = evtData.dataValue,
+				writer = new CKEDITOR.htmlParser.basicWriter();
+
+			data.writeChildrenHtml( writer );
+			data = writer.getHtml( true );
+
+			// Protect the real comments again.
+			evtData.dataValue = protectRealComments( data );
+		}, null, null, 15 );
+
+
+		editor.on( 'toDataFormat', function( evt ) {
+			var data = evt.data.dataValue;
+
+			// #10854 - we need to strip leading blockless 
 which FF adds
+			// automatically when editable contains only non-editable content.
+			// We do that for every browser (so it's a constant behavior) and
+			// not in BR mode, in which chance of valid leading blockless 
 is higher.
+			if ( evt.data.enterMode != CKEDITOR.ENTER_BR )
+				data = data.replace( /^
/i, '' );
+
+			evt.data.dataValue = CKEDITOR.htmlParser.fragment.fromHtml(
+				data, evt.data.context, getFixBodyTag( evt.data.enterMode, editor.config.autoParagraph ) );
+		}, null, null, 5 );
+
+		editor.on( 'toDataFormat', function( evt ) {
+			evt.data.dataValue.filterChildren( that.htmlFilter, true );
+		}, null, null, 10 );
+
+		// Transform outcoming "data".
+		// Add element filter after htmlDataProcessor.htmlFilter when preparing output data HTML.
+		editor.on( 'toDataFormat', function( evt ) {
+			evt.data.filter.applyTo( evt.data.dataValue, false, true );
+		}, null, null, 11 );
+
+		editor.on( 'toDataFormat', function( evt ) {
+			var data = evt.data.dataValue,
+				writer = that.writer;
+
+			writer.reset();
+			data.writeChildrenHtml( writer );
+			data = writer.getHtml( true );
+
+			// Restore those non-HTML protected source. (#4475,#4880)
+			data = unprotectRealComments( data );
+			data = unprotectSource( data, editor );
+
+			evt.data.dataValue = data;
+		}, null, null, 15 );
+	};
+
+	CKEDITOR.htmlDataProcessor.prototype = {
+		/**
+		 * Processes the (potentially malformed) input HTML to a purified form which
+		 * is suitable for using in the WYSIWYG editable.
+		 *
+		 * This method fires the {@link CKEDITOR.editor#toHtml} event which makes it possible
+		 * to hook into the process at various stages.
+		 *
+		 * **Note:** Since CKEditor 4.3 the signature of this method changed and all options
+		 * are now grouped in one `options` object. Previously `context`, `fixForBody` and `dontFilter`
+		 * were passed separately.
+		 *
+		 * @param {String} data The raw data.
+		 * @param {Object} [options] The options object.
+		 * @param {String} [options.context] The tag name of a context element within which
+		 * the input is to be processed, defaults to the editable element.
+		 * If `null` is passed, then data will be parsed without context (as children of {@link CKEDITOR.htmlParser.fragment}).
+		 * See {@link CKEDITOR.htmlParser.fragment#fromHtml} for more details.
+		 * @param {Boolean} [options.fixForBody=true] Whether to trigger the auto paragraph for non-block content.
+		 * @param {CKEDITOR.filter} [options.filter] When specified, instead of using the {@link CKEDITOR.editor#filter main filter},
+		 * the passed instance will be used to filter the content.
+		 * @param {Boolean} [options.dontFilter] Do not filter data with {@link CKEDITOR.filter} (note: transformations
+		 * will still be applied).
+		 * @param {Number} [options.enterMode] When specified, it will be used instead of the {@link CKEDITOR.editor#enterMode main enterMode}.
+		 * @param {Boolean} [options.protectedWhitespaces] Indicates that content was wrapped with `` elements to preserve
+		 * leading and trailing whitespaces. Option used by the {@link CKEDITOR.editor#method-insertHtml} method.
+		 * @returns {String}
+		 */
+		toHtml: function( data, options, fixForBody, dontFilter ) {
+			var editor = this.editor,
+				context, filter, enterMode, protectedWhitespaces;
+
+			// Typeof null == 'object', so check truthiness of options too.
+			if ( options && typeof options == 'object' ) {
+				context = options.context;
+				fixForBody = options.fixForBody;
+				dontFilter = options.dontFilter;
+				filter = options.filter;
+				enterMode = options.enterMode;
+				protectedWhitespaces = options.protectedWhitespaces;
+			}
+			// Backward compatibility. Since CKEDITOR 4.3 every option was a separate argument.
+			else {
+				context = options;
+			}
+
+			// Fall back to the editable as context if not specified.
+			if ( !context && context !== null )
+				context = editor.editable().getName();
+
+			return editor.fire( 'toHtml', {
+				dataValue: data,
+				context: context,
+				fixForBody: fixForBody,
+				dontFilter: dontFilter,
+				filter: filter || editor.filter,
+				enterMode: enterMode || editor.enterMode,
+				protectedWhitespaces: protectedWhitespaces
+			} ).dataValue;
+		},
+
+		/**
+		 * See {@link CKEDITOR.dataProcessor#toDataFormat}.
+		 *
+		 * This method fires the {@link CKEDITOR.editor#toDataFormat} event which makes it possible
+		 * to hook into the process at various stages.
+		 *
+		 * @param {String} html
+		 * @param {Object} [options] The options object.
+		 * @param {String} [options.context] The tag name of the context element within which
+		 * the input is to be processed, defaults to the editable element.
+		 * @param {CKEDITOR.filter} [options.filter] When specified, instead of using the {@link CKEDITOR.editor#filter main filter},
+		 * the passed instance will be used to apply content transformations to the content.
+		 * @param {Number} [options.enterMode] When specified, it will be used instead of the {@link CKEDITOR.editor#enterMode main enterMode}.
+		 * @returns {String}
+		 */
+		toDataFormat: function( html, options ) {
+			var context, filter, enterMode;
+
+			// Do not shorten this to `options && options.xxx`, because
+			// falsy `options` will be passed instead of undefined.
+			if ( options ) {
+				context = options.context;
+				filter = options.filter;
+				enterMode = options.enterMode;
+			}
+
+			// Fall back to the editable as context if not specified.
+			if ( !context && context !== null )
+				context = this.editor.editable().getName();
+
+			return this.editor.fire( 'toDataFormat', {
+				dataValue: html,
+				filter: filter || this.editor.filter,
+				context: context,
+				enterMode: enterMode || this.editor.enterMode
+			} ).dataValue;
+		}
+	};
+
+	// Produce a set of filtering rules that handles bogus and filler node at the
+	// end of block/pseudo block, in the following consequence:
+	// 1. elements: - this filter removes any bogus node, then check
+	// if it's an empty block that requires a filler.
+	// 2. elements:
 - After cleaned with bogus, this filter checks the real
+	// line-break BR to compensate a filler after it.
+	//
+	// Terms definitions:
+	// filler: An element that's either 
 or &NBSP; at the end of block that established line height.
+	// bogus: Whenever a filler is proceeded with inline content, it becomes a bogus which is subjected to be removed.
+	//
+	// Various forms of the filler:
+	// In output HTML: Filler should be consistently &NBSP; 
 at the end of block is always considered as bogus.
+	// In Wysiwyg HTML: Browser dependent - see env.needsBrFiller. Either BR for when needsBrFiller is true, or &NBSP; otherwise.
+	// 
 is NEVER considered as bogus when needsBrFiller is true.
+	function createBogusAndFillerRules( editor, type ) {
+		function createFiller( isOutput ) {
+			return isOutput || CKEDITOR.env.needsNbspFiller ?
+				new CKEDITOR.htmlParser.text( '\xa0' ) :
+				new CKEDITOR.htmlParser.element( 'br', { 'data-cke-bogus': 1 } );
+		}
+
+		// This text block filter, remove any bogus and create the filler on demand.
+		function blockFilter( isOutput, fillEmptyBlock ) {
+
+			return function( block ) {
+				// DO NOT apply the filler if it's a fragment node.
+				if ( block.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT )
+					return;
+
+				cleanBogus( block );
+
+				// Add fillers to input (always) and to output (if fillEmptyBlock is ok with that).
+				var shouldFillBlock = !isOutput ||
+					( typeof fillEmptyBlock == 'function' ? fillEmptyBlock( block ) : fillEmptyBlock ) !== false;
+
+				if ( shouldFillBlock && isEmptyBlockNeedFiller( block ) ) {
+					block.add( createFiller( isOutput ) );
+				}
+			};
+		}
+
+		// Append a filler right after the last line-break BR, found at the end of block.
+		function brFilter( isOutput ) {
+			return function( br ) {
+				// DO NOT apply the filer if parent's a fragment node.
+				if ( br.parent.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT )
+					return;
+
+				var attrs = br.attributes;
+				// Dismiss BRs that are either bogus or eol marker.
+				if ( 'data-cke-bogus' in attrs || 'data-cke-eol' in attrs ) {
+					delete attrs [ 'data-cke-bogus' ];
+					return;
+				}
+
+				// Judge the tail line-break BR, and to insert bogus after it.
+				var next = getNext( br ), previous = getPrevious( br );
+
+				if ( !next && isBlockBoundary( br.parent ) )
+					append( br.parent, createFiller( isOutput ) );
+				else if ( isBlockBoundary( next ) && previous && !isBlockBoundary( previous ) )
+					createFiller( isOutput ).insertBefore( next );
+			};
+		}
+
+		// Determinate whether this node is potentially a bogus node.
+		function maybeBogus( node, atBlockEnd ) {
+
+			// BR that's not from IE<11 DOM, except for a EOL marker.
+			if ( !( isOutput && !CKEDITOR.env.needsBrFiller ) &&
+					node.type == CKEDITOR.NODE_ELEMENT && node.name == 'br' &&
+					!node.attributes[ 'data-cke-eol' ] ) {
+				return true;
+			}
+
+			var match;
+
+			// NBSP, possibly.
+			if ( node.type == CKEDITOR.NODE_TEXT && ( match = node.value.match( tailNbspRegex ) ) ) {
+				// We need to separate tail NBSP out of a text node, for later removal.
+				if ( match.index ) {
+					( new CKEDITOR.htmlParser.text( node.value.substring( 0, match.index ) ) ).insertBefore( node );
+					node.value = match[ 0 ];
+				}
+
+				// From IE<11 DOM, at the end of a text block, or before block boundary.
+				if ( !CKEDITOR.env.needsBrFiller && isOutput && ( !atBlockEnd || node.parent.name in textBlockTags ) )
+					return true;
+
+				// From the output.
+				if ( !isOutput ) {
+					var previous = node.previous;
+
+					// Following a line-break at the end of block.
+					if ( previous && previous.name == 'br' )
+						return true;
+
+					// Or a single NBSP between two blocks.
+					if ( !previous || isBlockBoundary( previous ) )
+						return true;
+				}
+			}
+
+			return false;
+		}
+
+		// Removes all bogus inside of this block, and to convert fillers into the proper form.
+		function cleanBogus( block ) {
+			var bogus = [];
+			var last = getLast( block ), node, previous;
+
+			if ( last ) {
+				// Check for bogus at the end of this block.
+				// e.g. 
foo

+				maybeBogus( last, 1 ) && bogus.push( last );
+
+				while ( last ) {
+					// Check for bogus at the end of any pseudo block contained.
+					if ( isBlockBoundary( last ) && ( node = getPrevious( last ) ) && maybeBogus( node ) ) {
+						// Bogus must have inline proceeding, instead single BR between two blocks,
+						// is considered as filler, e.g. 


+						if ( ( previous = getPrevious( node ) ) && !isBlockBoundary( previous ) )
+							bogus.push( node );
+						// Convert the filler into appropriate form.
+						else {
+							createFiller( isOutput ).insertAfter( node );
+							node.remove();
+						}
+					}
+
+					last = last.previous;
+				}
+			}
+
+			// Now remove all bogus collected from above.
+			for ( var i = 0 ; i < bogus.length ; i++ )
+				bogus[ i ].remove();
+		}
+
+		// Judge whether it's an empty block that requires a filler node.
+		function isEmptyBlockNeedFiller( block ) {
+
+			// DO NOT fill empty editable in IE<11.
+			if ( !isOutput && !CKEDITOR.env.needsBrFiller && block.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT )
+				return false;
+
+			// 1. For IE version >=8,  empty blocks are displayed correctly themself in wysiwiyg;
+			// 2. For the rest, at least table cell and list item need no filler space. (#6248)
+			if ( !isOutput && !CKEDITOR.env.needsBrFiller &&
+				( document.documentMode > 7 ||
+					block.name in CKEDITOR.dtd.tr ||
+					block.name in CKEDITOR.dtd.$listItem ) ) {
+				return false;
+			}
+
+			var last = getLast( block );
+			return !last || block.name == 'form' && last.name == 'input' ;
+		}
+
+		var rules = { elements: {} },
+			isOutput = type == 'html',
+			textBlockTags = CKEDITOR.tools.extend( {}, blockLikeTags );
+
+		// Build the list of text blocks.
+		for ( var i in textBlockTags ) {
+			if ( !( '#' in dtd[ i ] ) )
+				delete textBlockTags[ i ];
+		}
+
+		for ( i in textBlockTags )
+			rules.elements[ i ] = blockFilter( isOutput, editor.config.fillEmptyBlocks );
+
+		// Editable element has to be checked separately.
+		rules.root = blockFilter( isOutput, false );
+		rules.elements.br = brFilter( isOutput );
+		return rules;
+	}
+
+	function getFixBodyTag( enterMode, autoParagraph ) {
+		return ( enterMode != CKEDITOR.ENTER_BR && autoParagraph !== false ) ? enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p' : false;
+	}
+
+	// Regex to scan for   at the end of blocks, which are actually placeholders.
+	// Safari transforms the   to \xa0. (#4172)
+	var tailNbspRegex = /(?: |\xa0)$/;
+
+	var protectedSourceMarker = '{cke_protected}';
+
+	function getLast( node ) {
+		var last = node.children[ node.children.length - 1 ];
+		while ( last && isEmpty( last ) )
+			last = last.previous;
+		return last;
+	}
+
+	function getNext( node ) {
+		var next = node.next;
+		while ( next && isEmpty( next ) )
+			next = next.next;
+		return next;
+	}
+
+	function getPrevious( node ) {
+		var previous = node.previous;
+		while ( previous && isEmpty( previous ) )
+			previous = previous.previous;
+		return previous;
+	}
+
+	// Judge whether the node is an ghost node to be ignored, when traversing.
+	function isEmpty( node ) {
+		return node.type == CKEDITOR.NODE_TEXT &&
+			!CKEDITOR.tools.trim( node.value ) ||
+			node.type == CKEDITOR.NODE_ELEMENT &&
+			node.attributes[ 'data-cke-bookmark' ];
+	}
+
+	// Judge whether the node is a block-like element.
+	function isBlockBoundary( node ) {
+		return node &&
+			( node.type == CKEDITOR.NODE_ELEMENT && node.name in blockLikeTags ||
+			node.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT );
+	}
+
+	function append( parent, node ) {
+		var last = parent.children[ parent.children.length - 1 ];
+		parent.children.push( node );
+		node.parent = parent;
+		if ( last ) {
+			last.next = node;
+			node.previous = last;
+		}
+	}
+
+	function getNodeIndex( node ) {
+		return node.parent ? node.getIndex() : -1;
+	}
+
+	var dtd = CKEDITOR.dtd,
+		// Define orders of table elements.
+		tableOrder = [ 'caption', 'colgroup', 'col', 'thead', 'tfoot', 'tbody' ],
+		// List of all block elements.
+		blockLikeTags = CKEDITOR.tools.extend( {}, dtd.$blockLimit, dtd.$block );
+
+	//
+	// DATA filter rules ------------------------------------------------------
+	//
+
+	var defaultDataFilterRulesEditableOnly = {
+		elements: {
+			input: protectReadOnly,
+			textarea: protectReadOnly
+		}
+	};
+
+	// These rules will also be applied to non-editable content.
+	var defaultDataFilterRulesForAll = {
+		attributeNames: [
+			// Event attributes (onXYZ) must not be directly set. They can become
+			// active in the editing area (IE|WebKit).
+			[ ( /^on/ ), 'data-cke-pa-on' ],
+
+			// Don't let some old expando enter editor. Concerns only IE8,
+			// but for consistency remove on all browsers.
+			[ ( /^data-cke-expando$/ ), '' ]
+		]
+	};
+
+	// Disable form elements editing mode provided by some browsers. (#5746)
+	function protectReadOnly( element ) {
+		var attrs = element.attributes;
+
+		// We should flag that the element was locked by our code so
+		// it'll be editable by the editor functions (#6046).
+		if ( attrs.contenteditable != 'false' )
+			attrs[ 'data-cke-editable' ] = attrs.contenteditable ? 'true' : 1;
+
+		attrs.contenteditable = 'false';
+	}
+
+	//
+	// HTML filter rules ------------------------------------------------------
+	//
+
+	var defaultHtmlFilterRulesEditableOnly = {
+		elements: {
+			embed: function( element ) {
+				var parent = element.parent;
+
+				// If the  is child of a , copy the width
+				// and height attributes from it.
+				if ( parent && parent.name == 'object' ) {
+					var parentWidth = parent.attributes.width,
+						parentHeight = parent.attributes.height;
+					if ( parentWidth )
+						element.attributes.width = parentWidth;
+					if ( parentHeight )
+						element.attributes.height = parentHeight;
+				}
+			},
+
+			// Remove empty link but not empty anchor. (#3829, #13516)
+			a: function( element ) {
+				var attrs = element.attributes;
+
+				if ( !( element.children.length || attrs.name || attrs.id || element.attributes[ 'data-cke-saved-name' ] ) )
+					return false;
+			}
+		}
+	};
+
+	// These rules will also be applied to non-editable content.
+	var defaultHtmlFilterRulesForAll = {
+		elementNames: [
+			// Remove the "cke:" namespace prefix.
+			[ ( /^cke:/ ), '' ],
+
+			// Ignore  tags.
+			[ ( /^\?xml:namespace$/ ), '' ]
+		],
+
+		attributeNames: [
+			// Attributes saved for changes and protected attributes.
+			[ ( /^data-cke-(saved|pa)-/ ), '' ],
+
+			// All "data-cke-" attributes are to be ignored.
+			[ ( /^data-cke-.*/ ), '' ],
+
+			[ 'hidefocus', '' ]
+		],
+
+		elements: {
+			$: function( element ) {
+				var attribs = element.attributes;
+
+				if ( attribs ) {
+					// Elements marked as temporary are to be ignored.
+					if ( attribs[ 'data-cke-temp' ] )
+						return false;
+
+					// Remove duplicated attributes - #3789.
+					var attributeNames = [ 'name', 'href', 'src' ],
+						savedAttributeName;
+					for ( var i = 0; i < attributeNames.length; i++ ) {
+						savedAttributeName = 'data-cke-saved-' + attributeNames[ i ];
+						savedAttributeName in attribs && ( delete attribs[ attributeNames[ i ] ] );
+					}
+				}
+
+				return element;
+			},
+
+			// The contents of table should be in correct order (#4809).
+			table: function( element ) {
+				// Clone the array as it would become empty during the sort call.
+				var children = element.children.slice( 0 );
+
+				children.sort( function( node1, node2 ) {
+					var index1, index2;
+
+					// Compare in the predefined order.
+					if ( node1.type == CKEDITOR.NODE_ELEMENT && node2.type == node1.type ) {
+						index1 = CKEDITOR.tools.indexOf( tableOrder, node1.name );
+						index2 = CKEDITOR.tools.indexOf( tableOrder, node2.name );
+					}
+
+					// Make sure the sort is stable, if no order can be established above.
+					if ( !( index1 > -1 && index2 > -1 && index1 != index2 ) ) {
+						index1 = getNodeIndex( node1 );
+						index2 = getNodeIndex( node2 );
+					}
+
+					return index1 > index2 ? 1 : -1;
+				} );
+			},
+
+			// Restore param elements into self-closing.
+			param: function( param ) {
+				param.children = [];
+				param.isEmpty = true;
+				return param;
+			},
+
+			// Remove dummy span in webkit.
+			span: function( element ) {
+				if ( element.attributes[ 'class' ] == 'Apple-style-span' )
+					delete element.name;
+			},
+
+			html: function( element ) {
+				delete element.attributes.contenteditable;
+				delete element.attributes[ 'class' ];
+			},
+
+			body: function( element ) {
+				delete element.attributes.spellcheck;
+				delete element.attributes.contenteditable;
+			},
+
+			style: function( element ) {
+				var child = element.children[ 0 ];
+				if ( child && child.value )
+					child.value = CKEDITOR.tools.trim( child.value );
+
+				if ( !element.attributes.type )
+					element.attributes.type = 'text/css';
+			},
+
+			title: function( element ) {
+				var titleText = element.children[ 0 ];
+
+				// Append text-node to title tag if not present (i.e. non-IEs) (#9882).
+				!titleText && append( element, titleText = new CKEDITOR.htmlParser.text() );
+
+				// Transfer data-saved title to title tag.
+				titleText.value = element.attributes[ 'data-cke-title' ] || '';
+			},
+
+			input: unprotectReadyOnly,
+			textarea: unprotectReadyOnly
+		},
+
+		attributes: {
+			'class': function( value ) {
+				// Remove all class names starting with "cke_".
+				return CKEDITOR.tools.ltrim( value.replace( /(?:^|\s+)cke_[^\s]*/g, '' ) ) || false;
+			}
+		}
+	};
+
+	if ( CKEDITOR.env.ie ) {
+		// IE outputs style attribute in capital letters. We should convert
+		// them back to lower case, while not hurting the values (#5930)
+		defaultHtmlFilterRulesForAll.attributes.style = function( value ) {
+			return value.replace( /(^|;)([^\:]+)/g, function( match ) {
+				return match.toLowerCase();
+			} );
+		};
+	}
+
+	// Disable form elements editing mode provided by some browsers. (#5746)
+	function unprotectReadyOnly( element ) {
+		var attrs = element.attributes;
+		switch ( attrs[ 'data-cke-editable' ] ) {
+			case 'true':
+				attrs.contenteditable = 'true';
+				break;
+			case '1':
+				delete attrs.contenteditable;
+				break;
+		}
+	}
+
+	//
+	// Preprocessor filters ---------------------------------------------------
+	//
+
+	var protectElementRegex = /<(a|area|img|input|source)\b([^>]*)>/gi,
+		// Be greedy while looking for protected attributes. This will let us avoid an unfortunate
+		// situation when "nested attributes", which may appear valid, are also protected.
+		// I.e. if we consider the following HTML:
+		//
+		// 	
+		//
+		// then the "non-greedy match" returns:
+		//
+		// 	'href' => '"X"' // It's wrong! Href is not an attribute of .
+		//
+		// while greedy match returns:
+		//
+		// 	'data-x' => '<a href="X"'
+		//
+		// which, can be easily filtered out (#11508).
+		protectAttributeRegex = /([\w-:]+)\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|(?:[^ "'>]+))/gi,
+		protectAttributeNameRegex = /^(href|src|name)$/i;
+
+		// Note: we use lazy star '*?' to prevent eating everything up to the last occurrence of  or .
+	var protectElementsRegex = /(?:])[^>]*>[\s\S]*?<\/style>)|(?:<(:?link|meta|base)[^>]*>)/gi,
+		protectTextareaRegex = /(])[^>]*>)([\s\S]*?)(?:<\/textarea>)/gi,
+		encodedElementsRegex = /([^<]*)<\/cke:encoded>/gi;
+
+	var protectElementNamesRegex = /(<\/?)((?:object|embed|param|html|body|head|title)[^>]*>)/gi,
+		unprotectElementNamesRegex = /(<\/?)cke:((?:html|body|head|title)[^>]*>)/gi;
+
+	var protectSelfClosingRegex = /]*?)\/?>(?!\s*<\/cke:\1)/gi;
+
+	function protectAttributes( html ) {
+		return html.replace( protectElementRegex, function( element, tag, attributes ) {
+			return '<' + tag + attributes.replace( protectAttributeRegex, function( fullAttr, attrName ) {
+				// Avoid corrupting the inline event attributes (#7243).
+				// We should not rewrite the existed protected attributes, e.g. clipboard content from editor. (#5218)
+				if ( protectAttributeNameRegex.test( attrName ) && attributes.indexOf( 'data-cke-saved-' + attrName ) == -1 )
+					return ' data-cke-saved-' + fullAttr + ' data-cke-' + CKEDITOR.rnd + '-' + fullAttr;
+
+				return fullAttr;
+			} ) + '>';
+		} );
+	}
+
+	function protectElements( html, regex ) {
+		return html.replace( regex, function( match, tag, content ) {
+			// Encode < and > in textarea because this won't be done by a browser, since
+			// textarea will be protected during passing data through fix bin.
+			if ( match.indexOf( '/g, '>' ) + '';
+
+			return '' + encodeURIComponent( match ) + '';
+		} );
+	}
+
+	function unprotectElements( html ) {
+		return html.replace( encodedElementsRegex, function( match, encoded ) {
+			return decodeURIComponent( encoded );
+		} );
+	}
+
+	function protectElementsNames( html ) {
+		return html.replace( protectElementNamesRegex, '$1cke:$2' );
+	}
+
+	function unprotectElementNames( html ) {
+		return html.replace( unprotectElementNamesRegex, '$1$2' );
+	}
+
+	function protectSelfClosingElements( html ) {
+		return html.replace( protectSelfClosingRegex, '' );
+	}
+
+	function protectPreFormatted( html ) {
+		return html.replace( /(]*>)(\r\n|\n)/g, '$1$2$2' );
+	}
+
+	function protectRealComments( html ) {
+		return html.replace( //g, function( match ) {
+			return '';
+		} );
+	}
+
+	// Replace all "on\w{3,}" strings which are not:
+	// * opening tags - e.g. ` (tested in "false positive 1"),
+	// * part of other attribute - e.g. `data-onfoo` or `fonfoo`.
+	function protectInsecureAttributes( html ) {
+		return html.replace( /([^a-z0-9<\-])(on\w{3,})(?!>)/gi, '$1data-cke-' + CKEDITOR.rnd + '-$2' );
+	}
+
+	function unprotectRealComments( html ) {
+		return html.replace( //g, function( match, data ) {
+			return decodeURIComponent( data );
+		} );
+	}
+
+	function unprotectSource( html, editor ) {
+		var store = editor._.dataStore;
+
+		return html.replace( //g, function( match, data ) {
+			return decodeURIComponent( data );
+		} ).replace( /\{cke_protected_(\d+)\}/g, function( match, id ) {
+			return store && store[ id ] || '';
+		} );
+	}
+
+	function protectSource( data, editor ) {
+		var protectedHtml = [],
+			protectRegexes = editor.config.protectedSource,
+			store = editor._.dataStore || ( editor._.dataStore = { id: 1 } ),
+			tempRegex = /<\!--\{cke_temp(comment)?\}(\d*?)-->/g;
+
+		var regexes = [
+			// Script tags will also be forced to be protected, otherwise
+			// IE will execute them.
+			( /|$)/gi ),
+
+			//