@ckeditor/ckeditor5-engine 30.0.0

package/LICENSE.md

@@ -0,0 +1,17 @@
+Software License Agreement
+==========================
+
+**CKEditor 5 editing engine** – https://github.com/ckeditor/ckeditor5-engine <br>
+Copyright (c) 2003-2021, [CKSource](http://cksource.com) Frederico Knabben. All rights reserved.
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html).
+
+Sources of Intellectual Property Included in CKEditor
+-----------------------------------------------------
+
+Where not otherwise indicated, all CKEditor content is authored by CKSource engineers and consists of CKSource-owned intellectual property. In some specific instances, CKEditor will incorporate work done by developers outside of CKSource with their express permission.
+
+Trademarks
+----------
+
+**CKEditor** is a trademark of [CKSource](http://cksource.com) Frederico Knabben. All other brand and product names are trademarks, registered trademarks or service marks of their respective holders.

package/README.md

@@ -0,0 +1,30 @@
+CKEditor 5 editing engine
+========================================
+
+[![npm version](https://badge.fury.io/js/%40ckeditor%2Fckeditor5-engine.svg)](https://www.npmjs.com/package/@ckeditor/ckeditor5-engine)
+[![Coverage Status](https://coveralls.io/repos/github/ckeditor/ckeditor5/badge.svg?branch=master)](https://coveralls.io/github/ckeditor/ckeditor5?branch=master)
+[![Build Status](https://travis-ci.com/ckeditor/ckeditor5.svg?branch=master)](https://travis-ci.com/ckeditor/ckeditor5)
+
+The CKEditor 5 editing engine implements a flexible MVC-based architecture for creating rich text editing features.
+
+## Architecture overview
+
+* **Custom data model.** CKEditor 5 implements a tree-structured custom data model, designed to fit multiple requirements such as enabling real-time collaboration and complex editing features (like tables or nested blocks).
+* **Virtual DOM.** CKEditor 5's editing engine features a custom, editing-oriented virtual DOM implementation that aims to hide browser quirks from your sight. **No more `contentEditable` nightmares!**
+* **Real-time collaborative editing**. The editor implements Operational Transformation for the tree-structured model as well as many other mechanisms which were required to create a seamless collaborative UX. Additionally, we provide cloud infrastructure and plugins enabling real-time collaborative editing in your application! [Check the collaboration demo](https://ckeditor.com/docs/ckeditor5/latest/features/collaboration/overview.html).
+* **Extensible.** The entire editor architecture was designed for maximum flexibility. The code is event-based and highly decoupled, allowing you to plug in or replace selected pieces. Features do not directly depend on each other and communicate in standardized ways.
+* **Schema-less core**. The core makes minimal assumptions and can be controlled through the schema. This leaves all decisions to plugins and to you.
+* **Modular architecture.** Not only can the core modules be reused and recomposed but even the features were implemented in a highly granular way. Feel like running a headless CKEditor 5 with a couple of features in Node.js? Not a problem!
+* **Framework for building rich-text editors.** Every use case is different and every editor needs to fulfill different goals. Therefore, we give you the freedom to create your own editors with custom-tailored features and UI.
+* **Heavily tested from day one.** CKEditor 5 comes with 3x more tests than React itself. All packages have 100% code coverage.
+* **8+ years of support.** It is not yet another framework to be gone next year or a hyped proof-of-concept to fail in a real-life scenario. We have over 15 years of experience in creating rich text editors and invested over 4 years in designing and building your next future-proof rich text editor of choice.
+
+## Documentation
+
+For a general introduction see the [Overview of CKEditor 5 Framework](https://ckeditor.com/docs/ckeditor5/latest/framework/guides/overview.html) guide and then the [Editing engine architecture guide](https://ckeditor.com/docs/ckeditor5/latest/framework/guides/architecture/editing-engine.html).
+
+Additionally, refer to the [`@ckeditor/ckeditor5-engine` package](https://ckeditor.com/docs/ckeditor5/latest/api/engine.html) page in [CKEditor 5 documentation](https://ckeditor.com/docs/ckeditor5/latest/) for even more information.
+
+## License
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html). For full details about the license, please check the `LICENSE.md` file or [https://ckeditor.com/legal/ckeditor-oss-license](https://ckeditor.com/legal/ckeditor-oss-license).

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@ckeditor/ckeditor5-engine",
+  "version": "30.0.0",
+  "description": "The editing engine of CKEditor 5 – the best browser-based rich text editor.",
+  "keywords": [
+    "wysiwyg",
+    "rich text",
+    "editor",
+    "html",
+    "contentEditable",
+    "editing",
+    "operational transformation",
+    "ot",
+    "collaboration",
+    "collaborative",
+    "real-time",
+    "framework",
+    "ckeditor",
+    "ckeditor5",
+    "ckeditor 5",
+    "ckeditor5-lib",
+    "ckeditor5-dll"
+  ],
+  "main": "src/index.js",
+  "dependencies": {
+    "@ckeditor/ckeditor5-utils": "^30.0.0",
+    "lodash-es": "^4.17.15"
+  },
+  "devDependencies": {
+    "@ckeditor/ckeditor5-basic-styles": "^30.0.0",
+    "@ckeditor/ckeditor5-block-quote": "^30.0.0",
+    "@ckeditor/ckeditor5-clipboard": "^30.0.0",
+    "@ckeditor/ckeditor5-core": "^30.0.0",
+    "@ckeditor/ckeditor5-editor-classic": "^30.0.0",
+    "@ckeditor/ckeditor5-enter": "^30.0.0",
+    "@ckeditor/ckeditor5-essentials": "^30.0.0",
+    "@ckeditor/ckeditor5-heading": "^30.0.0",
+    "@ckeditor/ckeditor5-image": "^30.0.0",
+    "@ckeditor/ckeditor5-link": "^30.0.0",
+    "@ckeditor/ckeditor5-list": "^30.0.0",
+    "@ckeditor/ckeditor5-paragraph": "^30.0.0",
+    "@ckeditor/ckeditor5-table": "^30.0.0",
+    "@ckeditor/ckeditor5-theme-lark": "^30.0.0",
+    "@ckeditor/ckeditor5-typing": "^30.0.0",
+    "@ckeditor/ckeditor5-ui": "^30.0.0",
+    "@ckeditor/ckeditor5-undo": "^30.0.0",
+    "@ckeditor/ckeditor5-widget": "^30.0.0",
+    "webpack": "^4.43.0",
+    "webpack-cli": "^3.3.11"
+  },
+  "engines": {
+    "node": ">=12.0.0",
+    "npm": ">=5.7.1"
+  },
+  "author": "CKSource (http://cksource.com/)",
+  "license": "GPL-2.0-or-later",
+  "homepage": "https://ckeditor.com/ckeditor-5",
+  "bugs": "https://github.com/ckeditor/ckeditor5/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ckeditor/ckeditor5.git",
+    "directory": "packages/ckeditor5-engine"
+  },
+  "files": [
+    "lang",
+    "src",
+    "theme",
+    "ckeditor5-metadata.json"
+  ]
+}

package/src/controller/datacontroller.js

@@ -0,0 +1,563 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module engine/controller/datacontroller
+ */
+
+import mix from '@ckeditor/ckeditor5-utils/src/mix';
+import ObservableMixin from '@ckeditor/ckeditor5-utils/src/observablemixin';
+import CKEditorError from '@ckeditor/ckeditor5-utils/src/ckeditorerror';
+
+import Mapper from '../conversion/mapper';
+
+import DowncastDispatcher from '../conversion/downcastdispatcher';
+import { insertText } from '../conversion/downcasthelpers';
+
+import UpcastDispatcher from '../conversion/upcastdispatcher';
+import { convertText, convertToModelFragment } from '../conversion/upcasthelpers';
+
+import ViewDocumentFragment from '../view/documentfragment';
+import ViewDocument from '../view/document';
+import ViewDowncastWriter from '../view/downcastwriter';
+
+import ModelRange from '../model/range';
+import { autoParagraphEmptyRoots } from '../model/utils/autoparagraphing';
+import HtmlDataProcessor from '../dataprocessor/htmldataprocessor';
+
+/**
+ * Controller for the data pipeline. The data pipeline controls how data is retrieved from the document
+ * and set inside it. Hence, the controller features two methods which allow to {@link ~DataController#get get}
+ * and {@link ~DataController#set set} data of the {@link ~DataController#model model}
+ * using given:
+ *
+ * * {@link module:engine/dataprocessor/dataprocessor~DataProcessor data processor},
+ * * downcast converters,
+ * * upcast converters.
+ *
+ * An instance of the data controller is always available in the {@link module:core/editor/editor~Editor#data `editor.data`}
+ * property:
+ *
+ *		editor.data.get( { rootName: 'customRoot' } ); // -> '<p>Hello!</p>'
+ *
+ * @mixes module:utils/observablemixin~ObservableMixin
+ */
+export default class DataController {
+	/**
+	 * Creates a data controller instance.
+	 *
+	 * @param {module:engine/model/model~Model} model Data model.
+	 * @param {module:engine/view/stylesmap~StylesProcessor} stylesProcessor The styles processor instance.
+	 */
+	constructor( model, stylesProcessor ) {
+		/**
+		 * Data model.
+		 *
+		 * @readonly
+		 * @member {module:engine/model/model~Model}
+		 */
+		this.model = model;
+
+		/**
+		 * Mapper used for the conversion. It has no permanent bindings, because they are created when getting data and
+		 * cleared directly after the data are converted. However, the mapper is defined as a class property, because
+		 * it needs to be passed to the `DowncastDispatcher` as a conversion API.
+		 *
+		 * @readonly
+		 * @member {module:engine/conversion/mapper~Mapper}
+		 */
+		this.mapper = new Mapper();
+
+		/**
+		 * Downcast dispatcher used by the {@link #get get method}. Downcast converters should be attached to it.
+		 *
+		 * @readonly
+		 * @member {module:engine/conversion/downcastdispatcher~DowncastDispatcher}
+		 */
+		this.downcastDispatcher = new DowncastDispatcher( {
+			mapper: this.mapper,
+			schema: model.schema
+		} );
+		this.downcastDispatcher.on( 'insert:$text', insertText(), { priority: 'lowest' } );
+
+		/**
+		 * Upcast dispatcher used by the {@link #set set method}. Upcast converters should be attached to it.
+		 *
+		 * @readonly
+		 * @member {module:engine/conversion/upcastdispatcher~UpcastDispatcher}
+		 */
+		this.upcastDispatcher = new UpcastDispatcher( {
+			schema: model.schema
+		} );
+
+		/**
+		 * The view document used by the data controller.
+		 *
+		 * @readonly
+		 * @member {module:engine/view/document~Document}
+		 */
+		this.viewDocument = new ViewDocument( stylesProcessor );
+
+		/**
+		 * Styles processor used during the conversion.
+		 *
+		 * @readonly
+		 * @member {module:engine/view/stylesmap~StylesProcessor}
+		 */
+		this.stylesProcessor = stylesProcessor;
+
+		/**
+		 * Data processor used specifically for HTML conversion.
+		 *
+		 * @readonly
+		 * @member {module:engine/dataprocessor/htmldataprocessor~HtmlDataProcessor} #htmlProcessor
+		 */
+		this.htmlProcessor = new HtmlDataProcessor( this.viewDocument );
+
+		/**
+		 * Data processor used during the conversion.
+		 * Same instance as {@link #htmlProcessor} by default. Can be replaced at run time to handle different format, e.g. XML or Markdown.
+		 *
+		 * @member {module:engine/dataprocessor/dataprocessor~DataProcessor} #processor
+		 */
+		this.processor = this.htmlProcessor;
+
+		/**
+		 * The view downcast writer just for data conversion purposes, i.e. to modify
+		 * the {@link #viewDocument}.
+		 *
+		 * @private
+		 * @readonly
+		 * @member {module:engine/view/downcastwriter~DowncastWriter}
+		 */
+		this._viewWriter = new ViewDowncastWriter( this.viewDocument );
+
+		// Define default converters for text and elements.
+		//
+		// Note that if there is no default converter for the element it will be skipped, for instance `<b>foo</b>` will be
+		// converted to nothing. We therefore add `convertToModelFragment` as a last converter so it converts children of that
+		// element to the document fragment and so `<b>foo</b>` will be converted to `foo` if there is no converter for `<b>`.
+		this.upcastDispatcher.on( 'text', convertText(), { priority: 'lowest' } );
+		this.upcastDispatcher.on( 'element', convertToModelFragment(), { priority: 'lowest' } );
+		this.upcastDispatcher.on( 'documentFragment', convertToModelFragment(), { priority: 'lowest' } );
+
+		this.decorate( 'init' );
+		this.decorate( 'set' );
+
+		// Fire the `ready` event when the initialization has completed. Such low-level listener gives possibility
+		// to plug into the initialization pipeline without interrupting the initialization flow.
+		this.on( 'init', () => {
+			this.fire( 'ready' );
+		}, { priority: 'lowest' } );
+
+		// Fix empty roots after DataController is 'ready' (note that init method could be decorated and stopped).
+		// We need to handle this event because initial data could be empty and post-fixer would not get triggered.
+		this.on( 'ready', () => {
+			this.model.enqueueChange( 'transparent', autoParagraphEmptyRoots );
+		}, { priority: 'lowest' } );
+	}
+
+	/**
+	 * Returns the model's data converted by downcast dispatchers attached to {@link #downcastDispatcher} and
+	 * formatted by the {@link #processor data processor}.
+	 *
+	 * @param {Object} [options] Additional configuration for the retrieved data. `DataController` provides two optional
+	 * properties: `rootName` and `trim`. Other properties of this object are specified by various editor features.
+	 * @param {String} [options.rootName='main'] Root name.
+	 * @param {String} [options.trim='empty'] Whether returned data should be trimmed. This option is set to `empty` by default,
+	 * which means whenever editor content is considered empty, an empty string will be returned. To turn off trimming completely
+	 * use `'none'`. In such cases exact content will be returned (for example `<p>&nbsp;</p>` for an empty editor).
+	 * @returns {String} Output data.
+	 */
+	get( options = {} ) {
+		const { rootName = 'main', trim = 'empty' } = options;
+
+		if ( !this._checkIfRootsExists( [ rootName ] ) ) {
+			/**
+			 * Cannot get data from a non-existing root. This error is thrown when {@link #get DataController#get() method}
+			 * is called with non-existent root name. For example, if there is an editor instance with only `main` root,
+			 * calling {@link #get} like:
+			 *
+			 *		data.get( { rootName: 'root2' } );
+			 *
+			 * will throw this error.
+			 *
+			 * @error datacontroller-get-non-existent-root
+			 */
+			throw new CKEditorError( 'datacontroller-get-non-existent-root', this );
+		}
+
+		const root = this.model.document.getRoot( rootName );
+
+		if ( trim === 'empty' && !this.model.hasContent( root, { ignoreWhitespaces: true } ) ) {
+			return '';
+		}
+
+		return this.stringify( root, options );
+	}
+
+	/**
+	 * Returns the content of the given {@link module:engine/model/element~Element model's element} or
+	 * {@link module:engine/model/documentfragment~DocumentFragment model document fragment} converted by the downcast converters
+	 * attached to {@link #downcastDispatcher} and formatted by the {@link #processor data processor}.
+	 *
+	 * @param {module:engine/model/element~Element|module:engine/model/documentfragment~DocumentFragment} modelElementOrFragment
+	 * Element whose content will be stringified.
+	 * @param {Object} [options] Additional configuration passed to the conversion process.
+	 * @returns {String} Output data.
+	 */
+	stringify( modelElementOrFragment, options = {} ) {
+		// Model -> view.
+		const viewDocumentFragment = this.toView( modelElementOrFragment, options );
+
+		// View -> data.
+		return this.processor.toData( viewDocumentFragment );
+	}
+
+	/**
+	 * Returns the content of the given {@link module:engine/model/element~Element model element} or
+	 * {@link module:engine/model/documentfragment~DocumentFragment model document fragment} converted by the downcast
+	 * converters attached to {@link #downcastDispatcher} to a
+	 * {@link module:engine/view/documentfragment~DocumentFragment view document fragment}.
+	 *
+	 * @param {module:engine/model/element~Element|module:engine/model/documentfragment~DocumentFragment} modelElementOrFragment
+	 * Element or document fragment whose content will be converted.
+	 * @param {Object} [options={}] Additional configuration that will be available through
+	 * {@link module:engine/conversion/downcastdispatcher~DowncastConversionApi#options} during the conversion process.
+	 * @returns {module:engine/view/documentfragment~DocumentFragment} Output view DocumentFragment.
+	 */
+	toView( modelElementOrFragment, options = {} ) {
+		const viewDocument = this.viewDocument;
+		const viewWriter = this._viewWriter;
+
+		// Clear bindings so the call to this method gives correct results.
+		this.mapper.clearBindings();
+
+		// First, convert elements.
+		const modelRange = ModelRange._createIn( modelElementOrFragment );
+		const viewDocumentFragment = new ViewDocumentFragment( viewDocument );
+
+		this.mapper.bindElements( modelElementOrFragment, viewDocumentFragment );
+
+		// Make additional options available during conversion process through `conversionApi`.
+		this.downcastDispatcher.conversionApi.options = options;
+
+		// We have no view controller and rendering to DOM in DataController so view.change() block is not used here.
+		this.downcastDispatcher.convertInsert( modelRange, viewWriter );
+
+		// Convert markers.
+		// For document fragment, simply take the markers assigned to this document fragment.
+		// For model root, all markers in that root will be taken.
+		// For model element, we need to check which markers are intersecting with this element and relatively modify the markers' ranges.
+		// Collapsed markers at element boundary, although considered as not intersecting with the element, will also be returned.
+		const markers = modelElementOrFragment.is( 'documentFragment' ) ?
+			Array.from( modelElementOrFragment.markers ) :
+			_getMarkersRelativeToElement( modelElementOrFragment );
+
+		for ( const [ name, range ] of markers ) {
+			this.downcastDispatcher.convertMarkerAdd( name, range, viewWriter );
+		}
+
+		// Clean `conversionApi`.
+		delete this.downcastDispatcher.conversionApi.options;
+
+		return viewDocumentFragment;
+	}
+
+	/**
+	 * Sets initial input data parsed by the {@link #processor data processor} and
+	 * converted by the {@link #upcastDispatcher view-to-model converters}.
+	 * Initial data can be set only to document that {@link module:engine/model/document~Document#version} is equal 0.
+	 *
+	 * **Note** This method is {@link module:utils/observablemixin~ObservableMixin#decorate decorated} which is
+	 * used by e.g. collaborative editing plugin that syncs remote data on init.
+	 *
+	 * When data is passed as a string it is initialized on a default `main` root:
+	 *
+	 *		dataController.init( '<p>Foo</p>' ); // Initializes data on the `main` root.
+	 *
+	 * To initialize data on a different root or multiple roots at once, object containing `rootName` - `data` pairs should be passed:
+	 *
+	 *		dataController.init( { main: '<p>Foo</p>', title: '<h1>Bar</h1>' } ); // Initializes data on the `main` and `title` roots.
+	 *
+	 * @fires init
+	 * @param {String|Object.<String,String>} data Input data as a string or an object containing `rootName` - `data`
+	 * pairs to initialize data on multiple roots at once.
+	 * @returns {Promise} Promise that is resolved after the data is set on the editor.
+	 */
+	init( data ) {
+		if ( this.model.document.version ) {
+			/**
+			 * Cannot set initial data to not empty {@link module:engine/model/document~Document}.
+			 * Initial data should be set once, during {@link module:core/editor/editor~Editor} initialization,
+			 * when the {@link module:engine/model/document~Document#version} is equal 0.
+			 *
+			 * @error datacontroller-init-document-not-empty
+			 */
+			throw new CKEditorError( 'datacontroller-init-document-not-empty', this );
+		}
+
+		let initialData = {};
+		if ( typeof data === 'string' ) {
+			initialData.main = data; // Default root is 'main'. To initiate data on a different root, object should be passed.
+		} else {
+			initialData = data;
+		}
+
+		if ( !this._checkIfRootsExists( Object.keys( initialData ) ) ) {
+			/**
+			 * Cannot init data on a non-existing root. This error is thrown when {@link #init DataController#init() method}
+			 * is called with non-existent root name. For example, if there is an editor instance with only `main` root,
+			 * calling {@link #init} like:
+			 *
+			 * 		data.init( { main: '<p>Foo</p>', root2: '<p>Bar</p>' } );
+			 *
+			 * will throw this error.
+			 *
+			 * @error datacontroller-init-non-existent-root
+			 */
+			throw new CKEditorError( 'datacontroller-init-non-existent-root', this );
+		}
+
+		this.model.enqueueChange( 'transparent', writer => {
+			for ( const rootName of Object.keys( initialData ) ) {
+				const modelRoot = this.model.document.getRoot( rootName );
+				writer.insert( this.parse( initialData[ rootName ], modelRoot ), modelRoot, 0 );
+			}
+		} );
+
+		return Promise.resolve();
+	}
+
+	/**
+	 * Sets input data parsed by the {@link #processor data processor} and
+	 * converted by the {@link #upcastDispatcher view-to-model converters}.
+	 * This method can be used any time to replace existing editor data by the new one without clearing the
+	 * {@link module:engine/model/document~Document#history document history}.
+	 *
+	 * This method also creates a batch with all the changes applied. If all you need is to parse data, use
+	 * the {@link #parse} method.
+	 *
+	 * When data is passed as a string it is set on a default `main` root:
+	 *
+	 *		dataController.set( '<p>Foo</p>' ); // Sets data on the `main` root.
+	 *
+	 * To set data on a different root or multiple roots at once, object containing `rootName` - `data` pairs should be passed:
+	 *
+	 *		dataController.set( { main: '<p>Foo</p>', title: '<h1>Bar</h1>' } ); // Sets data on the `main` and `title` roots.
+	 *
+	 * To set the data with preserved undo stacks and set the current change to this stack, use the `{ batchType: 'default' }` option.
+	 *
+	 *		dataController.set( '<p>Foo</p>', { batchType: 'default' } ); // Sets data as a new change.
+	 *
+	 * @fires set
+	 * @param {String|Object.<String,String>} data Input data as a string or an object containing `rootName` - `data`
+	 * pairs to set data on multiple roots at once.
+	 * @param {Object} [options={}] Options for setting data.
+	 * @param {'default'|'transparent'} [options.batchType='default'] The batch type that will be used to create a batch for the changes.
+	 * When set to `default`, the undo and redo stacks will be preserved. Note that when not set, the undo feature (when present) will
+	 * override it to `transparent` and all undo steps will be lost.
+	 */
+	set( data, options = {} ) {
+		let newData = {};
+
+		if ( typeof data === 'string' ) {
+			newData.main = data; // Default root is 'main'. To set data on a different root, object should be passed.
+		} else {
+			newData = data;
+		}
+
+		if ( !this._checkIfRootsExists( Object.keys( newData ) ) ) {
+			/**
+			 * Cannot set data on a non-existing root. This error is thrown when {@link #set DataController#set() method}
+			 * is called with non-existent root name. For example, if there is an editor instance with only `main` root,
+			 * calling {@link #set} like:
+			 *
+			 * 		data.set( { main: '<p>Foo</p>', root2: '<p>Bar</p>' } );
+			 *
+			 * will throw this error.
+			 *
+			 * @error datacontroller-set-non-existent-root
+			 */
+			throw new CKEditorError( 'datacontroller-set-non-existent-root', this );
+		}
+
+		const batchType = options.batchType || 'default';
+
+		this.model.enqueueChange( batchType, writer => {
+			writer.setSelection( null );
+			writer.removeSelectionAttribute( this.model.document.selection.getAttributeKeys() );
+
+			for ( const rootName of Object.keys( newData ) ) {
+				// Save to model.
+				const modelRoot = this.model.document.getRoot( rootName );
+
+				writer.remove( writer.createRangeIn( modelRoot ) );
+				writer.insert( this.parse( newData[ rootName ], modelRoot ), modelRoot, 0 );
+			}
+		} );
+	}
+
+	/**
+	 * Returns the data parsed by the {@link #processor data processor} and then converted by upcast converters
+	 * attached to the {@link #upcastDispatcher}.
+	 *
+	 * @see #set
+	 * @param {String} data Data to parse.
+	 * @param {module:engine/model/schema~SchemaContextDefinition} [context='$root'] Base context in which the view will
+	 * be converted to the model. See: {@link module:engine/conversion/upcastdispatcher~UpcastDispatcher#convert}.
+	 * @returns {module:engine/model/documentfragment~DocumentFragment} Parsed data.
+	 */
+	parse( data, context = '$root' ) {
+		// data -> view
+		const viewDocumentFragment = this.processor.toView( data );
+
+		// view -> model
+		return this.toModel( viewDocumentFragment, context );
+	}
+
+	/**
+	 * Returns the result of the given {@link module:engine/view/element~Element view element} or
+	 * {@link module:engine/view/documentfragment~DocumentFragment view document fragment} converted by the
+	 * {@link #upcastDispatcher view-to-model converters}, wrapped by {@link module:engine/model/documentfragment~DocumentFragment}.
+	 *
+	 * When marker elements were converted during the conversion process, it will be set as a document fragment's
+	 * {@link module:engine/model/documentfragment~DocumentFragment#markers static markers map}.
+	 *
+	 * @param {module:engine/view/element~Element|module:engine/view/documentfragment~DocumentFragment} viewElementOrFragment
+	 * Element or document fragment whose content will be converted.
+	 * @param {module:engine/model/schema~SchemaContextDefinition} [context='$root'] Base context in which the view will
+	 * be converted to the model. See: {@link module:engine/conversion/upcastdispatcher~UpcastDispatcher#convert}.
+	 * @returns {module:engine/model/documentfragment~DocumentFragment} Output document fragment.
+	 */
+	toModel( viewElementOrFragment, context = '$root' ) {
+		return this.model.change( writer => {
+			return this.upcastDispatcher.convert( viewElementOrFragment, writer, context );
+		} );
+	}
+
+	/**
+	 * Adds a style processor normalization rules.
+	 *
+	 * You can implement your own rules as well as use one of the available processor rules:
+	 *
+	 * * background: {@link module:engine/view/styles/background~addBackgroundRules}
+	 * * border: {@link module:engine/view/styles/border~addBorderRules}
+	 * * margin: {@link module:engine/view/styles/margin~addMarginRules}
+	 * * padding: {@link module:engine/view/styles/padding~addPaddingRules}
+	 *
+	 * @param {Function} callback
+	 */
+	addStyleProcessorRules( callback ) {
+		callback( this.stylesProcessor );
+	}
+
+	/**
+	 * Registers a {@link module:engine/view/matcher~MatcherPattern} on {@link #htmlProcessor htmlProcessor}
+	 * and {@link #processor processor} for view elements whose content should be treated as a raw data
+	 * and not processed during conversion from DOM to view elements.
+	 *
+	 * The raw data can be later accessed by {@link module:engine/view/element~Element#getCustomProperty view element custom property}
+	 * `"$rawContent"`.
+	 *
+	 * @param {module:engine/view/matcher~MatcherPattern} pattern Pattern matching all view elements whose content should
+	 * be treated as a raw data.
+	 */
+	registerRawContentMatcher( pattern ) {
+		// No need to register the pattern if both `htmlProcessor` and `processor` are the same instances.
+		if ( this.processor && this.processor !== this.htmlProcessor ) {
+			this.processor.registerRawContentMatcher( pattern );
+		}
+
+		this.htmlProcessor.registerRawContentMatcher( pattern );
+	}
+
+	/**
+	 * Removes all event listeners set by the DataController.
+	 */
+	destroy() {
+		this.stopListening();
+	}
+
+	/**
+	 * Checks if all provided root names are existing editor roots.
+	 *
+	 * @private
+	 * @param {Array.<String>} rootNames Root names to check.
+	 * @returns {Boolean} Whether all provided root names are existing editor roots.
+	 */
+	_checkIfRootsExists( rootNames ) {
+		for ( const rootName of rootNames ) {
+			if ( !this.model.document.getRootNames().includes( rootName ) ) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Event fired once the data initialization has finished.
+	 *
+	 * @event ready
+	 */
+
+	/**
+	 * Event fired after the {@link #init `init()` method} was run. It can be {@link #listenTo listened to} in order to adjust or modify
+	 * the initialization flow. However, if the `init` event is stopped or prevented, the {@link #event:ready `ready` event}
+	 * should be fired manually.
+	 *
+	 * The `init` event is fired by the decorated {@link #init} method.
+	 * See {@link module:utils/observablemixin~ObservableMixin#decorate} for more information and samples.
+	 *
+	 * @event init
+	 */
+
+	/**
+	 * Event fired after {@link #set set() method} has been run.
+	 *
+	 * The `set` event is fired by decorated {@link #set} method.
+	 * See {@link module:utils/observablemixin~ObservableMixin#decorate} for more information and samples.
+	 *
+	 * @event set
+	 */
+}
+
+mix( DataController, ObservableMixin );
+
+// Helper function for downcast conversion.
+//
+// Takes a document element (element that is added to a model document) and checks which markers are inside it. If the marker is collapsed
+// at element boundary, it is considered as contained inside the element and marker range is returned. Otherwise, if the marker is
+// intersecting with the element, the intersection is returned.
+function _getMarkersRelativeToElement( element ) {
+	const result = [];
+	const doc = element.root.document;
+
+	if ( !doc ) {
+		return [];
+	}
+
+	const elementRange = ModelRange._createIn( element );
+
+	for ( const marker of doc.model.markers ) {
+		const markerRange = marker.getRange();
+
+		const isMarkerCollapsed = markerRange.isCollapsed;
+		const isMarkerAtElementBoundary = markerRange.start.isEqual( elementRange.start ) || markerRange.end.isEqual( elementRange.end );
+
+		if ( isMarkerCollapsed && isMarkerAtElementBoundary ) {
+			result.push( [ marker.name, markerRange ] );
+		} else {
+			const updatedMarkerRange = elementRange.getIntersection( markerRange );
+
+			if ( updatedMarkerRange ) {
+				result.push( [ marker.name, updatedMarkerRange ] );
+			}
+		}
+	}
+
+	return result;
+}