CKEditor5 Collaboration

` element next to the editor data container: ```html

...

``` Then add styles for the side panel: ```html ``` ### Implementing the custom comments archive UI plugin Now, create a plugin that will use the provided HTML structure and fill the comments archive container with resolved comment threads. The behavior for the tabs will be implemented as simple DOM event listeners. You can observe changes on the [`CommentsArchiveUI#annotationViews`](../../../api/module_comments_comments_commentsarchiveui-CommentsArchiveUI.html#member-annotationViews) collection to fill the comments archive tab content. Additionally, for a better user experience, as long as the comments archive is shown in the side panel, the annotations for regular comment threads will be displayed in the inline display mode. This will give the users access to the regular comment threads data also when the archive is open. ```js class CustomCommentsArchiveUI extends Plugin { static get requires() { // We will use a property from the `CommentsArchiveUI` plugin, so add it to requires. return [ 'CommentsArchiveUI' ]; } init() { this.tabs = document.querySelectorAll( '.tabs__item' ); this.sidebars = document.querySelectorAll( '.sidebar' ); // Switch the side panel to the appropriate tab after clicking it. this.tabs.forEach( item => { item.addEventListener( 'click', () => this.handleTabClick( item ) ); } ); this.initCommentsArchive(); } // Switches between the active tabs. // Shows appropriate tab container and set the CSS classes to reflect the changes. handleTabClick( tabElement ) { if ( tabElement.classList.contains( 'active' ) ) { return; } const annotationsUIs = this.editor.plugins.get( 'AnnotationsUIs' ); const targetId = tabElement.dataset.target; const sidebarContainer = document.getElementById( targetId ); this.tabs.forEach( item => { item.classList.remove( 'active' ); } ); this.sidebars.forEach( item => { item.classList.remove( 'active' ); } ); tabElement.classList.add( 'active' ); sidebarContainer.classList.add( 'active' ); const isCommentsArchiveOpen = targetId === 'archive'; // If the comments archive is open, switch the display mode for comments to "inline". // // This way the annotations for regular comments threads will be displayed next to them // when a user clicks on the comment thread marker. // // When the comments archive is closed, switch back to displaying comments annotations in the wide sidebar. annotationsUIs.switchTo( isCommentsArchiveOpen ? 'inline' : 'wideSidebar' ); } initCommentsArchive() { // Container for the resolved comment threads annotations. const commentsArchiveList = document.querySelector( '.comments-archive__list' ); // The `CommentsArchiveUI` plugin handles all annotation views that can be used // to render resolved comment threads inside the comments archive container. const commentsArchiveUI = this.editor.plugins.get( 'CommentsArchiveUI' ); // First, handle the initial resolved comment threads. for ( const annotationView of commentsArchiveUI.annotationViews ) { commentsArchiveList.appendChild( annotationView.element ); } // Handler to append new resolved thread inside the comments archive custom view. commentsArchiveUI.annotationViews.on( 'add', ( _, annotationView ) => { if ( !commentsArchiveList.contains( annotationView.element ) ) { commentsArchiveList.appendChild( annotationView.element ); } } ); // Handler to remove the element when thread has been removed or reopened. commentsArchiveUI.annotationViews.on( 'remove', ( _, annotationView ) => { if ( commentsArchiveList.contains( annotationView.element ) ) { commentsArchiveList.removeChild( annotationView.element ); } } ); } } ``` Finally, add the new plugin to the editor. ```js ClassicEditor .create( { // ... plugins: [ // ... CustomCommentsArchiveUI ] } ) .then( /* ... */ ) .catch( /* ... */ ); ``` ### Demo > **Note** > > Share the complete URL of this page with your colleagues to collaborate in real-time! Click the “add comment” button in the toolbar to add a comment thread, then use the “tick” icon to resolve a comment thread. Finally, you can see the resolved comment threads in the “Comments archive” tab. source file: "ckeditor5/latest/features/collaboration/comments/comments-integration.html" ## Integrating comments with your application The comments feature [provides an API](../../../api/comments.html) that lets you add, remove, and update comments in the editor. To save and access all these changes in your database, you first need to integrate this feature. > **Note** > > This guide describes integrating comments as a standalone plugin (the asynchronous version of it). If you are using real-time collaboration, refer to the [Real-time collaboration features integration](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration-integration.html) guide. ### Integration methods This guide will discuss two ways to integrate CKEditor 5 with your comments data source: * [A simple “load and save” integration](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--a-simple-load-and-save-integration) using directly the `CommentsRepository` plugin API. * [An adapter integration](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--adapter-integration) which updates the comments data immediately in the database when it changes in the editor. The adapter integration is the recommended one because it gives you better control over the data. ### Before you start > **Note** > > Complementary to this guide, we provide [ready-to-use **samples** available for download](https://github.com/ckeditor/ckeditor5-collaboration-samples/tree/master/collaboration-editor-classic). You may use the samples as an example or a starting point for your integration. #### Preparing a custom editor setup To use the comments plugin, you need to prepare a custom editor setup with the asynchronous version of the comments feature included. The easiest way to do that is by using the [Builder](https://ckeditor.com/ckeditor-5/builder/?redirect=docs). Pick a preset and start customizing your editor. > **Note** > > The Builder allows you to pick your preferred distribution method and framework. For this guide, we will use the “Vanilla JS” option with “npm” and a simple setup based on the “Classic Editor (basic)” preset, with the comments feature enabled. **In the “Features” section** of the Builder (2nd step), make sure to: * turn off the “real-time” toggle next to the “Collaboration” group, * enable the “Collaboration → Comments” feature. Once you finish the setup, the Builder will provide you with the necessary HTML, CSS, and JavaScript code snippets. We will use those code snippets in the next step. #### Setting up a sample project Once we have a custom editor setup we need a simple JavaScript project to run it. For this, we recommend cloning the basic project template from our repository: ```bash npx -y degit ckeditor/ckeditor5-tutorials-examples/sample-project sample-project cd sample-project npm install ``` Then, install the necessary dependencies: ```bash npm install ckeditor5 npm install ckeditor5-premium-features ``` This project template uses [Vite](https://vitejs.dev/) under the hood and contains 3 source files that we will use: `index.html`, `style.css`, and `main.js`. It is now the time to use our custom editor setup. **Go to the “Installation” section** of the Builder and copy the generated code snippets to those 3 files. #### Activating the feature To use this premium feature, you need to activate it with a license key. Refer to the [License key and activation](#ckeditor5/latest/getting-started/licensing/license-key-and-activation.html) guide for details. After you have successfully obtained the license key open the `main.js` file and update the `your-license-key` string with your license key. #### Building the project Finally, build the project by running: ```bash npm run dev ``` When you open the sample in the browser you should see the WYSIWYG editor with the comments plugin. However, it still does not load or save any data. You will learn how to add data to the comments plugin later in this guide. Let’s now dive deeper into the structure of this setup. #### Basic setup’s anatomy > **Note** > > Examples below implement the [wide sidebar display mode](#ckeditor5/latest/features/collaboration/annotations/annotations-display-mode.html--wide-sidebar) for comment threads. If you want to use the inline display mode, remove parts of the snippets that set up the sidebar. Let’s now go through the key fragments of this basic setup. ##### HTML structure The HTML and CSS structure of the page creates two columns: * `

` is the container used by the editor. * `

` is the container used by the sidebar that holds the annotations (namely comments). ##### JavaScript The `main.js` file sets up the editor instance: * Loads all necessary editor plugins (including the [`Comments`](../../../api/module_comments_comments-Comments.html) plugin). * Sets the `licenseKey` configuration option. * Sets the `sidebar.container` configuration option to the container mentioned above. * Adds the `comment` and `commentsArchive` buttons to the editor toolbar. * Defines the templates for the `CommentsIntegration` and `UsersIntegrations` plugins that we will use in the next steps of this tutorial. > **Note** > > If you use the `ImageToolbar` plugin, also add the `comment` button to the [image toolbar](../../../api/module_image_imageconfig-ImageConfig.html#member-toolbar). #### Comments API The integration below uses the comments API. Making yourself familiar with the API may help you understand the code snippets. In case of any problems, refer to the [comments API documentation](../../../api/comments.html). #### Next steps We have set up a simple JavaScript project that runs a basic CKEditor 5 instance with the asynchronous version of the Comments feature. It does not yet handle loading or saving data, though. The next two sections cover the two available integration methods. ### A simple “load and save” integration In this solution, users and comments data is loaded during the editor initialization, and comments data is saved after you finish working with the editor (for example when you submit the form containing the WYSIWYG editor). This method is recommended if you can trust your users or if you provide additional validation of the submitted data. This way, we can make sure that the user changes their comments only. > **Note** > > Complementary to this guide, we provide [ready-to-use **samples** available for download](https://github.com/ckeditor/ckeditor5-collaboration-samples/tree/master/collaboration-editor-classic). You may use the samples as an example or as a starting point for your own integration. #### Loading the data When the comments plugin is already included in the editor, you need to create a plugin which will initialize users and existing comments. First, dump the users and comments data to a variable that will be available for your plugin. > **Note** > > If your application needs to request the comments data from the server asynchronously, instead of putting the data in the HTML source, you can create a plugin that will fetch the data from the database. In this case, your plugin should [return a `Promise` from the `Plugin.init()` method](../../../api/module_core_plugin-PluginInterface.html#function-init) to make sure that the editor initialization waits for your data. If you have set up the sample project as [recommended in the “Before you start” section](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--before-you-start), open the `main.js` file and add this variable right after the imports: ```js // Application data will be available under a global variable `appData`. const appData = { // Users data. users: [ { id: 'user-1', name: 'Mex Haddox' }, { id: 'user-2', name: 'Zee Croce' } ], // The ID of the current user. userId: 'user-1', // Comment threads data. commentThreads: [ { threadId: 'thread-1', comments: [ { commentId: 'comment-1', authorId: 'user-1', content: '

Are we sure we want to use a made-up disorder name?

', createdAt: new Date( '09/20/2018 14:21:53' ), attributes: {} }, { commentId: 'comment-2', authorId: 'user-2', content: '

Why not?

Bilingual Personality Disorder

This may be the first time you hear about this made-up disorder but it actually isn’t so far from the truth. As recent studies show, the language you speak has more effects on you than you realize. According to the studies, the language a person speaks affects their cognition, behavior, emotions and hence their personality.

This shouldn’t come as a surprise since we already know that different regions of the brain become more active depending on the activity. The structure, information and especially the culture of languages varies substantially and the language a person speaks is an essential element of daily life.

` }; ``` The Builder’s output sample already provides templates of two plugins: `UsersIntegration` and `CommentsIntegration`. Replace them with ones that read the data from `appData` and use the [`Users`](../../../api/module_collaboration-core_users-Users.html) and [`CommentsRepository`](../../../api/module_comments_comments_commentsrepository-CommentsRepository.html) API: ```js class UsersIntegration extends Plugin { static get requires() { return [ 'Users' ]; } static get pluginName() { return 'UsersIntegration'; } init() { const usersPlugin = this.editor.plugins.get( 'Users' ); // Load the users data. for ( const user of appData.users ) { usersPlugin.addUser( user ); } // Set the current user. usersPlugin.defineMe( appData.userId ); } } class CommentsIntegration extends Plugin { static get requires() { return [ 'CommentsRepository', 'UsersIntegration' ]; } static get pluginName() { return 'CommentsIntegration'; } init() { const commentsRepositoryPlugin = this.editor.plugins.get( 'CommentsRepository' ); // Load the comment threads data. for ( const commentThread of appData.commentThreads ) { commentsRepositoryPlugin.addCommentThread( commentThread ); } } } ``` Update the `editorConfig.root.initialData` property to use the `appData.initialData` value: ```js const editorConfig = { // ... root: { initialData: appData.initialData } // ... }; ``` And build the project: ```bash npm run dev ``` You should now we see an editor instance with one comment thread. #### Saving the data To save the comments data, you need to get it using the `CommentsRepository` API first. To do this, use the [`getCommentThreads()`](../../../api/module_comments_comments_commentsrepository-CommentsRepository.html#function-getCommentThreads) method. Then, use the comment threads data to save it in your database in the way you prefer. See the example below. In `index.html` add: ```html ``` In `main.js` update the `ClassicEditor.create()` call with a chained `then()`: ```js ClassicEditor .create( /* ... */ ) .then( editor => { // After the editor is initialized, add an action to be performed after a button is clicked. const commentsRepository = editor.plugins.get( 'CommentsRepository' ); // Get the data on demand. document.querySelector( '#get-data' ).addEventListener( 'click', () => { const editorData = editor.data.get(); const commentThreadsData = commentsRepository.getCommentThreads( { skipNotAttached: true, skipEmpty: true, toJSON: true } ); // Now, use `editorData` and `commentThreadsData` to save the data in your application. // For example, you can set them as values of hidden input fields. console.log( editorData ); console.log( commentThreadsData ); } ); } ); ``` > **Note** > > It is recommended to stringify the `attributes` value to JSON, save it as a string in your database, and then parse the value from JSON when loading comments. #### Demo ##### Data ##### Comments ### Adapter integration Adapter integration uses an adapter object – provided by you – to immediately save changes in comments in your data store. It is the recommended way of integrating comments with your application because it lets you handle client-server communication more securely. For example, you can check user permissions, validate sent data, or update the data with information obtained on the server side, like the comment creation date. You will see how to handle the server response in the following steps. > **Note** > > Complementary to this guide, we provide [ready-to-use **samples** available for download](https://github.com/ckeditor/ckeditor5-collaboration-samples/tree/master/collaboration-editor-classic). You may use the samples as an example or as a starting point for your own integration. #### Implementation First, define the adapter using the [`CommentsRepository#adapter`](../../../api/module_comments_comments_commentsrepository-CommentsRepository.html#member-adapter) property. [Adapter methods](../../../api/module_comments_comments_commentsrepository-CommentsAdapter.html) are called after the user makes a change in the comments. The adapter allows you to save the change in your database immediately. Each comment action has a separate adapter method that you should implement. On the UI side, each change in comments is performed immediately, however, all adapter actions are asynchronous and are performed in the background. Because of this, all adapter methods need to return a `Promise`. When the promise is resolved, it means that everything went fine and a local change was successfully saved in the data store. When the promise is rejected, the editor throws a [`CKEditorError`](../../../api/module_utils_ckeditorerror-CKEditorError.html) error, which works nicely together with the [watchdog](#ckeditor5/latest/features/watchdog.html) feature. When you handle the server response you can decide if the promise should be resolved or rejected. While any adapter action is being performed, a pending action is automatically added to the editor [`PendingActions`](../../../api/module_core_pendingactions-PendingActions.html) plugin, so you do not have to worry that the editor will be destroyed before the adapter action has finished. Now you are ready to implement the adapter. If you have set up the sample project as [recommended in the “Before you start” section](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--before-you-start), open the `main.js` file and add this variable right after the imports: ```js // Application data will be available under a global variable `appData`. const appData = { // Users data. users: [ { id: 'user-1', name: 'Mex Haddox' }, { id: 'user-2', name: 'Zee Croce' } ], // The ID of the current user. userId: 'user-1', // Comment threads data. // Include all comment threads: active, resolved, and unlinked. commentThreads: [ { threadId: 'thread-1', comments: [ { commentId: 'comment-1', authorId: 'user-1', content: '

Are we sure we want to use a made-up disorder name?

', createdAt: new Date( '09/20/2018 14:21:53' ), attributes: {} }, { commentId: 'comment-2', authorId: 'user-2', content: '

Why not?

Bilingual Personality Disorder

` }; ``` The Builder’s output sample already provides templates of two plugins `UsersIntegration` and `CommentsIntegration`. Replace them with ones that read the data from `appData` and use the [`Users`](../../../api/module_collaboration-core_users-Users.html) and [`CommentsRepository`](../../../api/module_comments_comments_commentsrepository-CommentsRepository.html) API: ```js class UsersIntegration extends Plugin { static get requires() { return ['Users']; } static get pluginName() { return 'UsersIntegration'; } init() { const usersPlugin = this.editor.plugins.get( 'Users' ); // Load the users data. for ( const user of appData.users ) { usersPlugin.addUser( user ); } // Set the current user. usersPlugin.defineMe( appData.userId ); } } class CommentsIntegration extends Plugin { static get requires() { return [ 'CommentsRepository', 'UsersIntegration' ]; } static get pluginName() { return 'CommentsIntegration'; } init() { const commentsRepositoryPlugin = this.editor.plugins.get( 'CommentsRepository' ); // Pre-load all comment threads (active, resolved, and unlinked) at initialization. // Use `isFromAdapter: true` to indicate this data comes from the backend // and prevent calling adapter.addCommentThread() for pre-loaded threads. for ( const commentThread of appData.commentThreads ) { commentsRepositoryPlugin.addCommentThread( { ...commentThread, isFromAdapter: true } ); } // Set the adapter on the `CommentsRepository#adapter` property. commentsRepositoryPlugin.adapter = { addComment( data ) { console.log( 'Comment added', data ); // Write a request to your database here. The returned `Promise` // should be resolved when the request has finished. // When the promise resolves with the comment data object, it // will update the editor comment using the provided data. return Promise.resolve( { createdAt: new Date() // Should be set on the server side. } ); }, updateComment( data ) { console.log( 'Comment updated', data ); // Write a request to your database here. The returned `Promise` // should be resolved when the request has finished. return Promise.resolve(); }, removeComment( data ) { console.log( 'Comment removed', data ); // Write a request to your database here. The returned `Promise` // should be resolved when the request has finished. return Promise.resolve(); }, addCommentThread( data ) { console.log( 'Comment thread added', data ); // Write a request to your database here. The returned `Promise` // should be resolved when the request has finished. return Promise.resolve( { threadId: data.threadId, comments: data.comments.map( ( comment ) => ( { commentId: comment.commentId, createdAt: new Date() } ) ) // Should be set on the server side. } ); }, getCommentThread( data ) { console.log( 'Getting comment thread', data ); // Write a request to your database here. The returned `Promise` // should resolve with the comment thread data. return Promise.resolve( { threadId: data.threadId, comments: [ { commentId: 'comment-1', authorId: 'user-2', content: '

Are we sure we want to use a made-up disorder name?

They are awesome.

``` Comment on an image: ```html

``` If your application filters HTML content, for example, to prevent XSS, you need to make sure to leave the comments tags and attributes in place when saving the content in the database. The comment markup is necessary for further editing sessions. If you need to display the document data without the comments, you can simply remove the comments markup from the document data: ```html

They are awesome.

``` When launching the editor, though, make sure to include comments markup in the HTML: ```html

They are awesome.

``` #### Saving the data with comment highlights By default, the data returned by `editor.getData()` contains the markup for the comments as described above. It does not provide the markup that visually shows the comment highlights in the data (similarly to how they are shown in the editor). It is possible to change the editor output using the `showCommentHighlights` option passed in `editor.getData()`. When set, the editor output will return comments similarly to how they are present inside the editor: ```js editor.getData( { showCommentHighlights: true } ); ``` Will return: ```html

Foo bar

Editor 1

Foo bar baz

Editor 2

Foo bar baz

Let's edit this together!

``` If you cannot or do not want to set the initial data straight in the HTML, use the [`initialData` configuration option](../../../api/module_core_editor_editorconfig-EditorConfig.html#member-initialData) instead. Do not use [`editor.setData()`](../../../api/module_core_editor_editor-Editor.html#function-setData) (see below). After the first user initializes the document and starts the editing session, every other user that connects to the same document will receive the content from CKEditor Cloud Services (while their local initial data is discarded). From that moment on, every single change to the editor content is passed between Cloud Services and clients and the document for each client is updated. Any conflicting updates are resolved on the fly. This is the reason why you should not use the `editor.setData()` or `editor.data.set()` methods when using the collaboration plugin. These simply overwrite the whole content of the editor (even if the data to set is the same as the current editor data). In real-time collaboration, this behavior can result in overwriting other clients’ local updates. In most cases, using `editor.setData()` and `editor.data.set()` in real-time collaboration is incorrect. If you are sure that you understand and accept the behavior and side effects of setting the editor data this way, you can call `editor.data.set()` with the flag `suppressErrorInCollaboration` set to `true`: ```js editor.data.set( '

Your data

` is the main container used by the editor. * `

` is the main container used by revision history. * `

` is the container used by revision history that shows selected revision content. * `

` is the container used by the editor. * `

` is the container used by the sidebar that holds the annotations (namely track changes). ##### JavaScript The `main.js` file sets up the editor instance: * Loads all necessary editor plugins (including the [`TrackChanges`](../../../api/module_track-changes_trackchanges-TrackChanges.html) plugin). * Sets the `licenseKey` configuration option. * Sets the `sidebar.container` configuration option to the container mentioned above. * Adds the `trackChanges` button to the editor toolbar. #### Comments Track changes use the [comments plugin](#ckeditor5/latest/features/collaboration/comments/comments.html) to allow discussion in suggestions. You should be familiar with the [comments integration](#ckeditor5/latest/features/collaboration/comments/comments-integration.html) guide before you start integrating suggestions. For that reason, the `main.js` file [obtained in the previous step](#ckeditor5/latest/features/collaboration/track-changes/track-changes-integration.html--javascript) does the following on top of the track changes plugin setup: * Loads the [`Comments`](../../../api/module_comments_comments-Comments.html) plugin (dependency of the `TrackChanges` plugin). * Defines the plugin templates: * For the `CommentsIntegration` plugin (learn how to [save comments](#ckeditor5/latest/features/collaboration/comments/comments-integration.html)). * For the `UsersIntegrations` plugin that is shared by both track changes and comments features and we will be used in the next steps of this tutorial. * Adds the `comment` and `commentsArchive` buttons to the editor toolbar. #### Next steps We have set up a simple JavaScript project that runs a basic CKEditor instance with the asynchronous version of the track changes feature. It does not yet handle loading or saving data, though. The next two sections cover the two available integration methods. ### A simple “load and save” integration In this solution, user and suggestions data is loaded during the editor initialization, and suggestions data is saved after you finish working with the editor (for example, when you submit the form containing the WYSIWYG editor). This method is recommended only if you can trust your users or if you provide additional validation of the submitted data to make sure that the user changed their suggestions only. > **Note** > > Complementary to this guide, we provide [ready-to-use **samples** available for download](https://github.com/ckeditor/ckeditor5-collaboration-samples/tree/master/collaboration-editor-classic). You may use the samples as an example or a starting point for your integration. > **Note** > > The integration below uses the track changes API. Making yourself familiar with the API may help you understand the code snippets. In case of any problems, refer to the [track changes API documentation](../../../api/track-changes.html). #### Loading the data When the track changes plugin is already included in the editor, you need to create plugins which will initialize users and existing suggestions. First, dump the users and the suggestions data to a variable that will be available for your plugin. > **Note** > > If your application needs to request the suggestions data from the server asynchronously, instead of putting the data in the HTML source, you can create a plugin that will fetch the data from the database. In this case, your plugin should [return a `Promise` from the `Plugin.init()` method](../../../api/module_core_plugin-PluginInterface.html#function-init) to make sure that the editor initialization waits for your data. ```js // Application data will be available under a global variable `appData`. const appData = { // Users data. users: [ { id: 'user-1', name: 'Mex Haddox' }, { id: 'user-2', name: 'Zee Croce' } ], // The ID of the current user. userId: 'user-1', // Comment threads data. commentThreads: [ { threadId: 'thread-1', comments: [ { commentId: 'comment-1', authorId: 'user-1', content: '

Are we sure we want to use a made-up disorder name?

', createdAt: new Date( '09/20/2018 14:21:53' ), attributes: {} }, { commentId: 'comment-2', authorId: 'user-2', content: '

Why not?

', createdAt: new Date( '09/21/2018 08:17:01' ), attributes: {} } ], context: { type: 'text', value: 'Bilingual Personality Disorder' }, unlinkedAt: null, resolvedAt: null, resolvedBy: null, attributes: {} } ], // Suggestions data. suggestions: [ { id: 'suggestion-1', type: 'insertion', authorId: 'user-2', createdAt: new Date( 2019, 1, 13, 11, 20, 48 ), data: null, attributes: {} }, { id: 'suggestion-2', type: 'deletion', authorId: 'user-1', createdAt: new Date( 2019, 1, 14, 12, 7, 20 ), data: null, attributes: {} }, { id: 'suggestion-3', type: 'attribute:bold|ci1tcnk0lkep', authorId: 'user-1', createdAt: new Date( 2019, 2, 8, 10, 2, 7 ), data: { key: 'bold', oldValue: null, newValue: true }, attributes: { groupId: 'e29adbb2f3963e522da4d2be03bc5345f' } } ], // Editor initial data. initialData: `

Bilingual Personality Disorder

This may be the first time you hear about this made-up disorder but it actually is not that far from the truth. As recent studies show, the language you speak has more effects on you than you realize. According to the studies, the language a person speaks affects their cognition, feelings, behavior, emotions and hence their personality.

This shouldn’t come as a surprise since we already know that different regions of the brain become more active depending on the activity. The structure, information and especially the culture of languages varies substantially and the language a person speaks is an essential element of daily life.

Are we sure we want to use a made-up disorder name?

', createdAt: new Date( '09/20/2018 14:21:53' ), attributes: {} }, { commentId: 'comment-2', authorId: 'user-2', content: '

Why not?

Bilingual Personality Disorder

This shouldn’t come as a surprise since we already know that different regions of the brain become more active depending on the activity. The structure, information and especially the culture of languages varies substantially and the language a person speaks is an essential element of daily life.

` }; ``` The Builder’s output sample already provides templates of three plugins: `UsersIntegration`, `CommentsIntegration`, and `TrackChangesIntegration`. Replace them with ones that read the data from `appData` and use the [`Users`](../../../api/module_collaboration-core_users-Users.html), [`CommentsRepository`](../../../api/module_comments_comments_commentsrepository-CommentsRepository.html), and [`TrackChanges`](../../../api/track-changes.html) APIs, respectively: ```js class UsersIntegration extends Plugin { static get requires() { return [ 'Users' ]; } static get pluginName() { return 'UsersIntegration'; } init() { const usersPlugin = this.editor.plugins.get( 'Users' ); // Load the users data. for ( const user of appData.users ) { usersPlugin.addUser( user ); } // Set the current user. usersPlugin.defineMe( appData.userId ); } } class CommentsIntegration extends Plugin { static get requires() { return [ 'CommentsRepository', 'UsersIntegration' ]; } static get pluginName() { return 'CommentsIntegration'; } init() { const commentsRepositoryPlugin = this.editor.plugins.get( 'CommentsRepository' ); // Load the comment threads data. for ( const commentThread of appData.commentThreads ) { commentsRepositoryPlugin.addCommentThread( commentThread ); } } } class TrackChangesIntegration extends Plugin { static get requires() { return [ 'TrackChanges', 'UsersIntegration' ]; } static get pluginName() { return 'TrackChangesIntegration'; } init() { const trackChangesPlugin = this.editor.plugins.get( 'TrackChanges' ); // Set the adapter to the `TrackChanges#adapter` property. trackChangesPlugin.adapter = { getSuggestion: suggestionId => { console.log( 'Getting suggestion', suggestionId ); // Write a request to your database here. // The returned `Promise` should be resolved with the suggestion // data object when the request has finished. switch ( suggestionId ) { case 'suggestion-1': return Promise.resolve( { id: suggestionId, type: 'insertion', authorId: 'user-2', createdAt: new Date(), data: null, attributes: {} } ); case 'suggestion-2': return Promise.resolve( { id: suggestionId, type: 'deletion', authorId: 'user-1', createdAt: new Date(), data: null, attributes: {} } ); case 'suggestion-3': return Promise.resolve( { id: 'suggestion-3', type: 'attribute:bold|ci1tcnk0lkep', authorId: 'user-1', createdAt: new Date( 2019, 2, 8, 10, 2, 7 ), data: { key: 'bold', oldValue: null, newValue: true }, attributes: { groupId: 'e29adbb2f3963e522da4d2be03bc5345f' } } ); } }, addSuggestion: suggestionData => { console.log( 'Suggestion added', suggestionData ); // Write a request to your database here. // The returned `Promise` should be resolved when the request // has finished. When the promise resolves with the suggestion data // object, it will update the editor suggestion using the provided data. // // Important: Also create a comment thread record in your database // with the same ID as the suggestion (suggestionData.id). This is // needed because adapter.addCommentThread() is not called for // suggestion-created threads. return Promise.resolve( { createdAt: new Date() // Should be set on the server side. } ); }, updateSuggestion: ( id, suggestionData ) => { console.log( 'Suggestion updated', id, suggestionData ); // Write a request to your database here. // The returned `Promise` should be resolved when the request // has finished. return Promise.resolve(); } }; // In order to load comments added to suggestions, you // should also integrate the comments adapter. See the // comments integration guide for details on pre-loading // comment threads and setting up the comments adapter. } } ``` > **Warning** > > When `addSuggestion()` is called, also create a comment thread record in your backend with the same ID as the suggestion. Comment threads for suggestions are not created through the comments adapter automatically. See the [comments adapter integration](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--adapter-integration) guide for details. Update the `editorConfig.root.initialData` property to use `appData.initialData` value: ```js const editorConfig = { // ... root: { initialData: appData.initialData } // ... }; ``` And build the project: ```bash npm run dev ``` You should now we see an editor instance with one comment thread and several track changes suggestions. The adapter is now ready to use with your rich text editor. > **Note** > > It is recommended to stringify the `attributes` value to JSON, save it as a string in your database, and then parse the value from JSON when loading suggestions. > **Note** > > Note that this sample does not contain the comments adapter. [Check the comments integration](#ckeditor5/latest/features/collaboration/comments/comments-integration.html--adapter-integration) guide to learn how to build a complete solution. Also, note that both snippets define the same list of users. Make sure to deduplicate this code and define the list of users only once to avoid errors. #### Demo Since the track changes adapter saves suggestions immediately after they are performed, it is also recommended to use the [Autosave](../../../api/module_autosave_autosave-Autosave.html) plugin to save the editor content after each change. #### Why is there no event when I accept or discard a suggestion? Note that when you discard or accept a suggestion, no event is fired in the adapter. This is because the suggestion is never removed from the editor during the editing session. You are able to restore it using undo (`Cmd+Z` or `Ctrl+Z`). The same happens when you remove a paragraph with suggestions – there will be no event fired because no data is really removed. However, to make sure that you do not keep outdated suggestions in your database, you should do a cleanup when the editor is destroyed or closed. You can compare the suggestions stored in the editor data with the suggestions stored in your database and remove all the suggestions that are no longer in the editor data from your database. ### Track changes samples Please visit the [`ckeditor5-collaboration-samples`](https://github.com/ckeditor/ckeditor5-collaboration-samples/tree/master) GitHub repository to find several sample integrations of the track changes feature. source file: "ckeditor5/latest/features/collaboration/track-changes/track-changes-preview.html" ## Preview final content The track changes preview feature displays a modal window with a preview of your content as it will look once all suggestions are accepted. This helps when a document is heavily edited with many suggestions, possibly from different authors, and it becomes hard to picture the final result. ### Demo Use the “Preview final content” button in the track changes toolbar dropdown (you can find it in the menu bar, in “Tools -> Track changes” menu). The editor will display a modal window with the preview. Add more suggestions to the document to see how the final content changes. This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action. ### Installation To enable the track changes preview feature, add the `TrackChangesPreview` plugin to your editor setup: **NPM** ```js import { ClassicEditor } from 'ckeditor5'; import { TrackChangesPreview } from 'ckeditor5-premium-features'; ClassicEditor .create( { licenseKey: '', plugins: [ TrackChangesPreview, /* ... */ ] } ) .then( /* ... */ ) .catch( /* ... */ ); ``` **CDN** ```js const { ClassicEditor } = CKEDITOR; const { TrackChangesPreview } = CKEDITOR_PREMIUM_FEATURES; ClassicEditor .create( { licenseKey: '', plugins: [ TrackChangesPreview, /* ... */ ] } ) .then( /* ... */ ) .catch( /* ... */ ); ``` The plugin will add a new “Preview final content” button to the track changes toolbar dropdown and in the “Tools -> Track changes” menu in the menu bar. You can also execute `previewFinalContent` command to show the modal window with the preview: ```js editor.commands.get( 'previewFinalContent' ).execute(); ``` ### Configuration When the preview is opened, the editor content is put inside a container element, which has the same CSS classes as the editor’s editable element. In most cases this is sufficient to replicate the styling of editor content. If you see that your custom CSS styles are not applied in the preview, make sure that your CSS rules also apply to the HTML in the preview modal. You may need to adjust selectors in your CSS rules to match the preview dialog structure. By default, the editor content is put into a following DOM structure: ```html

``` You can target the `ck-track-changes-preview` and `ck-track-changes-preview__root-container` classes, as well as `data-ck-root-name` attribute. However, some integrations may require a custom DOM structure, for example due to complex CSS rules, or if you use [`MultiRootEditor`](../../../api/module_editor-multi-root_multirooteditor-MultiRootEditor.html). To provide a custom DOM structure inside the preview modal dialog, use the `trackChanges.preview.renderFunction` configuration option. ```js { trackChanges: { preview: { renderFunction: ( container, elements ) => { // Custom callback inserting the `elements` into `container`. // ... } } } } ``` Two parameters are passed to the callback: * `container` – the main container element that will be inserted into the modal window (this is the element with the `ck-track-changes-preview` CSS class). * `elements` – an array of elements, each holding the contents of one of the editor roots. Unless you are using [`MultiRootEditor`](../../../api/module_editor-multi-root_multirooteditor-MultiRootEditor.html), there will be only one element available. They are sorted according to their DOM order. Each element has the `data-ck-root-name` attribute set to the corresponding editor’s root name. You can use them for styling purposes, or to recognize a particular root and handle it in some custom way. Use `renderFunction` to process the `elements` array, wrap them in a DOM structure that will fit your needs, and insert them into `container` element. Below is an example of how `renderFunction` could be used together with a multi-root editor: ```js ClassicEditor .create( { // ... Other configuration options ... trackChanges: { preview: { renderFunction: ( container, elements ) => { for ( const element of elements ) { // Wrap each root into an additional container. const dataContainer = document.createElement( 'div' ); dataContainer.classList.add( 'additional-container' ); dataContainer.appendChild( element ); container.appendChild( dataContainer ); } } } } } ) .then( /* ... */ ) .catch( /* ... */ ); ``` This will result in the following structure inside the preview modal window: ```html

``` source file: "ckeditor5/latest/features/collaboration/track-changes/track-changes.html" ## Track changes overview The track changes feature (also known as suggestion mode) records edits as suggestions marked in the content instead of applying them directly. Reviewers can then follow who changed what and accept or decline each suggestion individually or all at once. It works both as a standalone plugin and as part of real-time collaboration. ### Demo You can test the track changes feature in the editor below. Use the toolbar dropdown to enable changes tracking and mass accept or decline suggestions. Use the side panel to work with individual changes. This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action. In this mode, changes done by the users are marked in the content and shown as suggestions in the sidebar. Suggestions can be accepted or discarded by the users. The suggestion balloon is then closed and the change is no longer marked. > **Note** > > Suggestion annotations can be displayed in a sidebar or as inline balloons. Visit the [display mode](#ckeditor5/latest/features/collaboration/annotations/annotations-display-mode.html) guide to learn how to configure the display mode. The mode specified for comments is also set for track changes. > > This sample automatically switches between display modes according to the screen size. Resize the window and observe how the editor changes its appearance. Apart from reading this guide, we encourage you to read a dedicated blog post which [compares the track changes with revision history](https://ckeditor.com/blog/ckeditor-5-comparing-revision-history-with-track-changes/) and another blog post discussing [CKEditor 5’s collaboration features and their real-life implementations](https://ckeditor.com/blog/Feature-of-the-month-Collaborative-writing-in-CKEditor-5/). ### Integration #### Use as a standalone plugin The track changes feature does not require real-time collaboration to work. If you prefer a more traditional approach to document editing, track changes can be added to CKEditor 5 just like any other plugin. To learn how to integrate track changes as a standalone plugin, please refer to the [Integrating track changes with your application](#ckeditor5/latest/features/collaboration/track-changes/track-changes-integration.html) guide. #### Use with real-time collaboration If you are using the real-time collaboration feature, refer to the [Real-time collaboration features integration](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration-integration.html) guide. ### Learn more After you run the track changes feature in your editor, you may want to learn more about it. Find out below how it works, how it can be configured, customized, and extended, to fit your application the best way possible. #### Configuration The configuration for the track changes feature can be found in the [`TrackChangesConfig`](../../../api/module_track-changes_trackchangesconfig-TrackChangesConfig.html) API reference. #### Suggestions markup Suggestions are always attached to some place in the document. To make sure that they will not be lost, the track changes plugin adds some special markup to the document: * `` and `` tags are added if the suggestion starts/ends in text, * otherwise, the following attributes are added to elements: * `data-suggestion-start-before`, * `data-suggestion-end-after`, * `data-suggestion-start-after`, * `data-suggestion-end-before`. Also, the `` tag is used for table cells pasting suggestions to separate old content (original) from the new content (pasted). [Read more about marker-to-data conversion](../../../api/module_engine_conversion_downcasthelpers-DowncastHelpers.html#function-markerToData) to understand what data you may expect. Examples of the possible markup: Replacing the word “chocolate” with the word “ice-cream”: ```html

I like ice-cream chocolate.

``` Inserting image: ```html

``` Adding bold: ```html

This is important .

``` Pasting a table cell with the text “New” into a table cell with the text “Old”: ```html

New

Old

``` Note that if your application filters HTML content, for example, to prevent XSS, make sure to leave the suggestion tags and attributes in place when saving the content in the database. The suggestion markup is necessary for further editing sessions. #### Suggestions attributes Suggestion attributes is additional data stored with the suggestions and used by other features. You can also use them to set and read custom data necessary by your custom features built around suggestions. ```ts suggestion.setAttribute( 'isImportant', true ); ``` You can group multiple values in an object, using dot notation: ```ts suggestion.setAttribute( 'customData.type', 'image' ); suggestion.setAttribute( 'customData.src', 'foo.jpg' ); ``` Attributes set on the suggestion can be accessed through `attribute` property: ```ts const isImportant = suggestion.attributes.isImportant; const type = suggestion.attributes.customData.type; ``` You can also observe `attributes` property or bind other properties to it: ```ts myObj.bind( 'customData' ).to( suggestion, 'attributes', attributes => attributes.customData ); ``` Whenever [`setAttribute()`](../../../api/module_track-changes_suggestion-Suggestion.html#function-setAttribute) or [`removeAttribute()`](../../../api/module_track-changes_suggestion-Suggestion.html#function-removeAttribute) is called, the `attributes` property is re-set, and observables are refreshed. Using these fires the `update` method in an adapter. #### Saving the data without suggestions If you need to get the editor data with all the existing suggestions accepted or discarded, please refer to the [dedicated guide](#ckeditor5/latest/features/collaboration/track-changes/track-changes-data.html). #### Saving the data with suggestion highlights By default, the data returned by `editor.getData()` contains the markup for the suggestions as described above. It does not provide the markup that visually shows the suggestion highlights in the data (similarly to how they are shown in the editor). It is possible to change the editor output using the `showSuggestionHighlights` option passed in `editor.getData()`. When set, the editor output will return suggestions similarly to how they are present inside the editor: ```js editor.getData( { showSuggestionHighlights: true } ); ``` Will return: ```html

Foo bar

Header content

', footer_html: '

', header_and_footer_css: '#header, #footer { background: hsl(0, 0%, 95%); } .styled { font-weight: bold; } .styled-counter { font-size: 1em; }', wait_for_network: true, wait_time: 0 } } } ``` For the complete list of V1 options, see the [V1 API documentation](../../api/module_export-pdf_exportpdf-ExportPdfConverterOptions.html) and the [V1 REST API documentation](https://pdf-converter.cke-cs.com/v1/convert/docs). ### HTML to PDF converter features #### Page setup Configure the page size, orientation, and margins through the `document` object in `converterOptions`: ```js converterOptions: { document: { size: 'A4', orientation: 'portrait', margins: { top: '20mm', bottom: '20mm', left: '15mm', right: '15mm' } } } ``` The `size` property accepts predefined formats (`'A4'`, `'Letter'`, `'Legal'`, `'A3'`, etc.) or a custom object with `width` and `height`. For a complete example including matching editor CSS, see [Setting the page format](#ckeditor5/latest/features/converters/export-pdf.html--setting-the-page-format). ```js document: { size: { width: '210mm', height: '297mm' } } ``` #### Setting the base URL To enable proper resolution of relative URLs for images and links, pass the `base_url` option: ```js converterOptions: { base_url: 'https://example.com' } ``` For editor content like: ```html

Homepage

``` this option will resolve the URLs into their absolute forms: * `/` will become `https://example.com`, * `/logo.png` will become `https://example.com/logo.png`. #### Images Currently, the converter only supports absolute URLs and `Base64`-encoded images. See the [REST API documentation](https://pdf-converter.cke-cs.com/v2/convert/docs) for details. #### Web fonts If you are using web fonts via an `@import` or `@font-face` declaration, you can pass the path(s) to the `.css` file(s) containing them to the [`config.exportPdf.stylesheets`](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html#member-stylesheets). The order of the provided paths matters – you should list style sheets with web font declarations first. For more technical details, check the [API documentation](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html) and [REST API documentation](https://pdf-converter.cke-cs.com/v2/convert/docs). #### Rendering options Fine-tune how the converter renders the page before generating the PDF: ```js converterOptions: { rendering: { wait_for_network: true, wait_time: 0, wait_for_selector: '.content-loaded' } } ``` * `wait_for_network` – When `true`, the converter waits for all network requests to finish before rendering. * `wait_time` – Additional wait time in milliseconds (0–15000) after the page loads. * `wait_for_selector` – A CSS selector; the converter waits until an element matching this selector appears in the DOM. #### Headers and footers The converter lets you set the document’s header and footer similarly to Microsoft Word or Google Docs. Define a `default` header and footer applied to all pages: ```js converterOptions: { document: { margins: { top: '15mm', bottom: '15mm', right: '15mm', left: '15mm' } }, headers: { default: { html: '

Header content

', css: '#header { background: hsl(0, 0%, 95%); } .styled { font-weight: bold; text-align: center; }' } }, footers: { default: { html: '

', css: '#footer { background: hsl(0, 0%, 95%); } .styled-counter { font-size: 1em; color: hsl(0, 0%, 60%); }' } } } ``` > **Note** > > To ensure that the header or footer is displayed, the margin must be big enough to accommodate it. In the code above, `document.margins.top` corresponds with the header and `document.margins.bottom` – with the footer. You can set a background for the header or footer using the `#header` or `#footer` selector in the `css` option. These wrapper elements are provided by the converter. ##### Per-page-type headers and footers You can define different headers and footers for the first page, odd pages, and even pages using the `first`, `odd`, and `even` keys. Each overrides the `default` for its respective pages: ```js headers: { default: { html: '', css: '.header { text-align: center; font-size: 10pt; }' }, first: { html: '

Report Title

', css: '.header-first { text-align: center; font-size: 14pt; font-weight: bold; }' }, odd: { html: '

Section

', css: '.header-odd { text-align: right; }' }, even: { html: '

Section

', css: '.header-even { text-align: left; }' } } ``` The `footers` object follows the same structure. If a page type key is not defined, the `default` is used as a fallback. As you can see in the examples above, you can use the `pageNumber` and `totalPages` placeholders. For more details, refer to the [REST API documentation](https://pdf-converter.cke-cs.com/v2/convert/docs). If you import headers and footers from a Word document and want to preserve and reapply them when exporting, see the Import from Word guide’s [Preserving headers and footers](#ckeditor5/latest/features/converters/import-word/import-word.html--preserving-headers-and-footers). Note that when forwarding stored headers/footers into PDF export, you typically need to inject those header/footer converter options within the `execute` call of the `exportPdf` command. Hence, the converter receives them at export time. #### Mirror margins Mirror margins (also known as “gutter” or “book” margins) are useful for documents intended for double-sided printing or binding. When `enable_mirror_margins` is set to `true`, the left and right margins swap between odd and even pages: * **Odd pages (right-hand)**: `left` becomes the inner margin (near binding), `right` becomes the outer margin. * **Even pages (left-hand)**: the margins are reversed – `right` becomes the inner margin, `left` becomes the outer margin. ```js converterOptions: { document: { margins: { top: '20mm', bottom: '20mm', left: '25mm', right: '15mm', enable_mirror_margins: true } } } ``` In this example, odd pages will have a 25 mm inner margin and 15 mm outer margin, while even pages will swap to 15 mm inner and 25 mm outer, creating a mirrored layout suitable for book binding. > **Important** > > For mirror margins to work correctly, you must specify at least one of the `left` or `right` margins. If both are unset, the `enable_mirror_margins` option will have no effect. #### Document metadata Set PDF properties such as title, author, subject, keywords, and custom fields. PDF readers display this information in their document properties panel. ```js converterOptions: { metadata: { title: 'Quarterly Report', author: 'Jane Smith', subject: 'Q1 2026 Financial Summary', keywords: [ 'finance', 'quarterly', 'report' ], custom_fields: { 'Department': 'Marketing', 'Document-ID': 'DOC-12345' } } } ``` #### Security and encryption Protect generated PDFs with an owner password. The owner password controls document permissions (printing, copying, modifying). The PDF is encrypted with AES-256 by default. ```js converterOptions: { security: { owner_password: 'securePassword123' } } ``` The `owner_password` is required when using this feature and must be between 6 and 64 characters. #### Digital signatures Sign documents with PKCS#12 certificates to verify authenticity. The signature is embedded invisibly in the PDF metadata – it does not add visual elements to the document pages. PDF readers will show signature details in their signature panel. ```js converterOptions: { signature: { certificate: 'base64EncodedPKCS12Certificate', certificate_password: 'certificatePassword', reason: 'Document approval', location: 'New York, USA' } } ``` Both `certificate` (base64-encoded `.p12`/`.pfx` file) and `certificate_password` are required. The `reason` and `location` fields are optional metadata. > **Note** > > PEM certificates are not supported. Convert to PKCS#12 (`.p12`/`.pfx`) format before use. #### Compression control By default, the converter compresses PDF output for smaller file sizes. You can disable compression to preserve the original PDF structure: ```js converterOptions: { disable_compression: true } ``` #### Other * By default, the generated PDF file is encoded with **`UTF-8`**. * By default, the converter sets **`color-adjust: exact;`**. This means that your PDF document will preserve colors, images, and styles as you can see them in the editor. * The generated document can be watermarked. [See the example and demo in the section below.](#ckeditor5/latest/features/converters/export-pdf.html--adding-a-watermark-to-the-document) ### Examples Check out some configuration examples that will show you how to customize the export to PDF feature. In the first example, you will learn how to add custom styling. The second example will show you how to set the page format. In the third one, you can see how to use web fonts in your configuration. #### Re-using custom editor styling The default configuration of the [`ExportPdf`](../../api/module_export-pdf_exportpdf-ExportPdf.html) plugin attaches the default editor content styles to the HTML content sent to the converter. However, if you need to, you can also set paths to additional CSS files. Let us assume that you already have a `my-custom-editor-styles.css` with your custom styling for the editor content that you use on your website, but you also want to include these styles in the generated PDF file. Here is the example code: ```js ClassicEditor .create( { // ... Other configuration options ... exportPdf: { stylesheets: [ 'path/to/editor-styles.css', 'path/to/my-styles.css' ], fileName: 'my-document.pdf' } } ) .then( /* ... */ ) .catch( /* ... */ ); ``` This is how the corresponding editor styles may look like: ```css /* my-custom-editor-styles.css */ /* Custom link color. */ .ck.ck-content a { color: purple; } /* Custom header styling. */ .ck.ck-content h1 { border-bottom: 2px solid; } /* Another custom styling... */ /* ... */ ``` With these settings, the content in the generated PDF file should have the same styling as it has in the WYSIWYG editor. > **Note** > > You are not obligated to use `.ck.ck-content` selectors to style your content. If your implementation contains custom CSS classes, you can use them instead. #### Setting the page format Consistency is an important factor. To make sure that the editor content and the generated PDF file look the same, you need to match their format settings. You can change your existing style sheet or use a new one, for example, `format.css`. By default, the CKEditor Cloud Services HTML to PDF converter is set to A4 format, but you may change this setting in your configuration. Assuming that you want to create a document in the US Letter format, with the standard margins (`19mm` for each side), here is the example code you can use: ```js ClassicEditor .create( { // ... Other configuration options ... exportPdf: { stylesheets: [ 'path/to/editor-styles.css', 'path/to/my-styles.css' ], fileName: 'my-document.pdf', converterOptions: { document: { // Document format settings with proper margins. size: 'Letter', orientation: 'portrait', margins: { top: '19mm', bottom: '19mm', right: '19mm', left: '19mm' } } } } } ) .then( /* ... */ ) .catch( /* ... */ ); ``` > **Note** > > This example focuses only on preparing the editable to match the converter settings. As a result, the appearance of your editor may change. Depending on your editor type and implementation or even some inherited global styles like `box-sizing`, applying new `padding` values may change the size of the editor on your website. > > For this example, `box-sizing: border-box` was implemented to make sure that the editor’s width would not change. Now set the corresponding editor styles: ```css /* format.css */ /* Styles for the editable. */ .ck.ck-content.ck-editor__editable { /* US Letter size. */ width: 215.9mm; /* Padding is your document's margin. */ padding: 19mm; /* You do not want to change the size of the editor by applying the new padding values. */ box-sizing: border-box; /* ... */ } ``` With these settings, the content in the generated PDF file should have the same US Letter format layout as it has in the editor. #### Providing web font styles This time you want to add a web font to your plugin. Let us assume that the editor is used on a page with certain typography, so the content in the editor inherits the font styles from the page. As such, these styles need to be passed to the HTML to PDF converter service. The example below uses a web font from the Google Fonts service. For your convenience, the `@import` declaration and any font styles needed for your website are kept in a separate file, for example, `fonts.css`. ```css /* fonts.css */ @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;700&display=swap'); html, body { font-family: "Source Sans Pro", sans-serif; /* ... */ } /* ... */ ``` This allows you to use the web font settings in the plugin, without any additional tweaks. Just pass the path to the file in the [`config.exportPdf.stylesheets`](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html#member-stylesheets) configuration option. The order matters here. Font declarations should be at the beginning of the style sheets’ array. Otherwise, there is no guarantee that the font styling will be applied to the PDF file. Refer to the [`config.exportPdf.stylesheets`](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html#member-stylesheets) API documentation for more details. ```js ClassicEditor .create( { // ... Other configuration options ... exportPdf: { stylesheets: [ 'path/to/fonts.css', 'path/to/editor-styles.css', 'path/to/my-styles.css' ], // More configuration of the export to PDF feature. // ... } } ) .then( /* ... */ ) .catch( /* ... */ ); ``` Thanks to this, the editor inherits the font settings and you can be sure that they will be applied in the generated PDF file as well. Take a look at another example of a `fonts.css` file. Suppose that your website uses the `Source Sans Pro` font as before but this time you want the `Inter` font to be used in the WYSIWYG editor. The file should look like this: ```css /* fonts.css */ /* Import the web font for your website. */ @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;700&display=swap'); /* Import the web font for your editor. */ @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap'); /* Use the Source Sans Pro web font in your website. */ html, body { font-family: "Source Sans Pro", sans-serif; /* ... */ } /* Use the Inter web font in your editor. */ .ck.ck-content.ck-editor__editable { font-family: "Inter", sans-serif; /* ... */ } /* ... */ ``` Having the file set like this for your website and just re-using it in [`config.exportPdf.stylesheets`](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html#member-stylesheets) makes the whole setup as simple as possible. #### Adding a watermark to the document Apart from adding a header and a footer, there is also the possibility of adding a watermark to the generated document. This can be achieved by utilizing [`config.exportPdf.dataCallback`](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html#member-dataCallback). To do this, you need to get the data that is being sent to the converter first and update it with a watermark markup: ```js exportPdf: { // More configuration of the export to PDF. // ... dataCallback: ( editor ) => { return ` ${ editor.getData() }

Draft document

Default header content

', css: templateCSS }, // Header template only for the first page of the document. { html: '

First document page header content

', css: templateCSS, type: 'first' }, // Header template for every even page of the document. { html: '

Every even page header content

', css: templateCSS, type: 'even' }, // Header template for every odd page of the document. { html: '

Every odd page header content

', css: templateCSS, type: 'odd' } ], footer: [ // Footer template for all footers (without the `type` property). { html: '

Default footer content

', css: templateCSS }, // Footer template only for the first page of the document. { html: '

First document page footer content

', css: templateCSS, type: 'first' }, // Footer template for every even page of the document. { html: '

Every even page footer content

', css: templateCSS, type: 'even' }, // Footer template for every odd page of the document. { html: '

Every odd page footer content

', css: templateCSS, type: 'odd' } ], } ``` ### HTML to Word converter features #### Styling a document By default, the [export to Word](../../api/module_export-word_exportword-ExportWord.html) plugin takes editor content styles and sends them to the CKEditor Cloud Services HTML to DOCX Converter. You can also add custom styles by providing the paths to the external CSS files. ```js // More editor's configuration. // ... exportWord: { fileName: 'document.docx', converterUrl: 'https://docx-converter.cke-cs.com/v2/convert/html-docx', stylesheets: [ 'path/to/editor-styles.css', 'path/to/my-styles.css' ], // More configuration of the export to Word feature. // ... } // More editor's configuration. // ... ``` ##### Supported CSS properties The HTML to DOCX Converter supports proper CSS inheritance with a set of whitelisted properties. You can use them to style the document content. You can apply CSS properties like: * `color` * `background-color` * `font-size` * `font-family` * `text-align` to the following elements: `h1`, `h2`, `h3`, `h4`, `h5`, `h6`, `p`, `span`, `td`, `th`, `strong`, `i`, `u`, `s`, `sub`, `sup`, `mark`. You can also position images using the `float` CSS property, supporting `left`, `right`, and `none` values. > **Note** > > You can use any CSS selector to style these elements, including classes, attributes, and the `*` selector. #### Setting the page format Consistency is an important factor. To make sure that the editor content and the generated Word file look the same, you need to match their format settings. You can change your existing style sheet or use a new one, for example, `format.css`. By default, the CKEditor Cloud Services HTML to DOCX converter is set to A4 format, but you may change this setting in your configuration. Assuming that you want to create a document in the US Letter format, with the standard margins (`19mm` for each side), here is the example code you can use: ```js ClassicEditor .create( { // ... Other configuration options ... exportWord: { stylesheets: [ 'path/to/editor-styles.css', 'path/to/my-styles.css' ], fileName: 'my-document.docx', converterOptions: { document: { size: 'Letter', // Document format settings with proper margins. margin: { top: '19mm', bottom: '19mm', right: '19mm', left: '19mm' } } } } } ) .then( /* ... */ ) .catch( /* ... */ ); ``` > **Note** > > This example focuses only on preparing the editable to match the converter settings. Please keep in mind that as a result, the appearance of your editor may change. Depending on your editor type and implementation or even some inherited global styles like `box-sizing`, applying new `padding` values may change the size of the editor on your website. > > For the purpose of this example, `box-sizing: border-box` was implemented to make sure that the editor’s width will not change. Now set the corresponding editor styles: ```css /* format.css */ /* Styles for the editable. */ .ck.ck-content.ck-editor__editable { /* US Letter size. */ width: 215.9mm; /* Padding is your document's margin. */ padding: 19mm; /* You don't want to change the size of the editor by applying the new padding values. */ box-sizing: border-box; /* ... */ } ``` With these settings, the content in the generated Word file should have the same US Letter format layout as it has in the editor. #### Header and footer The converter lets you set the document’s header and footer similarly to Microsoft Word or Google Docs. ```js const templateCSS = '.styled { color: #4b22aa; text-align: center; }' const converterOptions = { headers: { // Header template for all headers. default : { html: '

Default header content

', css: templateCSS }, // Header template only for the first page of the document. first: { html: '

First document page header content

', css: templateCSS }, // Header template for every even page of the document. even: { html: '

Every even page header content

', css: templateCSS }, // Header template for every odd page of the document. odd: { html: '

Every odd page header content

', css: templateCSS } }, footers: { // Footer template for all footers. default: { html: '

Default footer content

', css: templateCSS }, // Footer template only for the first page of the document. first: { html: '

First document page footer content

', css: templateCSS }, // Footer template for every even page of the document. even: { html: '

Every even page footer content

', css: templateCSS }, // Footer template for every odd page of the document. odd: { html: '

Every odd page footer content

', css: templateCSS } }, } ``` Regarding CSS, you can style the `headers` and `footers` using the same [supported properties](#ckeditor5/latest/features/converters/export-word.html--supported-css-properties) as used for styling the whole document. For more details, refer to the [CKEditor Cloud Services HTML to DOCX converter’s documentation](https://docx-converter.cke-cs.com/v2/convert/docs). As you can see, the `headers` and `footers` options are objects whose keys (`default`, `first`, `even`, and `odd`) define the template for each page type. If you want a consistent template no matter the page, define only the `default` entry. If you import headers and footers from a Word document and want to preserve and reapply them when exporting, see the [preserving headers and footers](#ckeditor5/latest/features/converters/import-word/import-word.html--preserving-headers-and-footers) section in the [Import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) guide. #### Setting the base URL To enable proper resolution of relative URLs for images and links, you need to pass the `base_url` option: ```js const conversionOptions = { base_url: 'https://ckeditor.com' }; ``` For an editor’s content like the one below: ```html

Our company homepage

An example paragraph.

Initial content of the editor

` (for instance, a `<div>` element),
* to override the `placeholder` text of a `<textarea>`, if one was passed into `Editor.create()` but the placeholder text should be different.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        root: {
            placeholder: 'Type the content here!'
        }
    } )
    .then( editor => {
        console.log( editor );
    } )
    .catch( error => {
        console.error( error );
    } );
```

If your editor implementation uses multiple roots, configure placeholders using `roots.<rootName>.placeholder`:

```js
MultiRootEditor
    .create( {
        roots: {
            header: {
                placeholder: 'Type header...',
                element: document.querySelector( '#header' )
            },
            content: {
                placeholder: 'Type content...',
                element: document.querySelector( '#content' )
            },
            leftSide: {
                placeholder: 'Type left-side...',
                element: document.querySelector( '#left-side' )
            },
            rightSide: {
                placeholder: 'Type right-side...',
                element: document.querySelector( '#right-side' )
            }
        }
    } )
    .then( editor => {
        console.log( editor );
    } )
    .catch( error => {
        console.error( error );
    } );
```

### Styling the placeholder

The editor placeholder text is displayed using a CSS pseudo–element (`::before`) related to the first empty element in the editor content (usually a paragraph). You can use the following snippet to change the appearance of the placeholder:

```css
.ck.ck-editor__editable > .ck-placeholder::before {
    color: #d21714;
    font-family: Georgia;
}
```

**Note**: The `.ck-placeholder` class is also used to display placeholders in other places, for instance, [image captions](#ckeditor5/latest/features/images/images-captions.html). Make sure your custom styles apply to the right subset of placeholders.

### Changing the placeholder

The editor placeholder could be updated at runtime by changing the `placeholder` property in the editing root.

```js
editor.editing.view.document.getRoot( 'main' ).placeholder = 'new placeholder';
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-core>.

<a id="ckeditor5/latest/features/email-editing/email-configuration-helper.html">source file: "ckeditor5/latest/features/email-editing/email-configuration-helper.html"</a>

## Email configuration helper

While configuring an email editor looks like a demanding task, the email configuration helper plugin is the best way to start and make this experience more manageable.

### Demo

Look at the logs below to see the configuration problems.

The logs displayed below come from DevTools and show problems encountered by the editor during configuration validation. These issues may cause emails to be displayed incorrectly in various email clients.

**JS Console**

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { EmailConfigurationHelper } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ EmailConfigurationHelper, /* ... */ ],
		link: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { EmailConfigurationHelper } = CKEDITOR_PREMIUM_FEATURES;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ EmailConfigurationHelper, /* ... */ ],
		link: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Activating the feature

To use this premium feature, you need to activate it with proper credentials. Refer to the [License key and activation](#ckeditor5/latest/getting-started/licensing/license-key-and-activation.html) guide for details.

### Configuration

#### Logs and warnings

The [`EmailConfigurationConfig`](../../api/module_email_emailconfigurationconfig-EmailConfigurationConfig.html) property lets you suppress warnings or log messages about email client compatibility.

```js
ClassicEditor
    .create( {
        email: {
            logs: {
                suppressAll: false,
                suppress: [
                    'email-configuration-unsupported-reversed-list',
                    'email-configuration-unsupported-list-style-type',
                    // ... other message codes
                ]
            }
        }
    } )
```

### Common API

The [`EmailConfigurationHelper`](../../api/module_email_emailconfigurationhelper-EmailConfigurationHelper.html) plugin registers the following components:

* The [`EmailConfigurationHelper`](../../api/module_email_emailconfigurationhelper-EmailConfigurationHelper.html) component.
* The [`EmailConfigurationConfig`](../../api/module_email_emailconfigurationconfig-EmailConfigurationConfig.html) property.

> **Note**
>
> We recommend using the official [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) for development and debugging. It will give you tons of useful information about the state of the editor such as internal data structures, selection, commands, and many more.

<a id="ckeditor5/latest/features/email-editing/email.html">source file: "ckeditor5/latest/features/email-editing/email.html"</a>

## Email editing in CKEditor 5

CKEditor 5 provides a wide variety of tools and functions for editing almost any kind of content. This, too, includes email editing. However, creating and editing emails is a demanding task that needs a proper configuration. This is due to a variety of software products and a lack of a standardized approach. The email editing solution is a set of tools aimed at making the email composition a better and more effective experience.

### Demo

Use the demo below to see the feature in action. Click the layout table toolbar button to insert a new layout table. It is useful in creating email templates. Experiment with the newsletter content - see how it looks in the editor and the source HTML.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Setting up your email editor

A good email editor is a versatile, advanced software solution and as such, it needs several additional features. A set of CKEditor 5 plugins forms the full experience. Below is a list of all email-assisting features that may be useful when preparing a full-fledged email editor.

> **Warning**
>
> **Always test your content**
>
> Various email clients have varying levels of CSS support. Always test your exported content in target email clients to ensure proper rendering.

#### Email configuration helper

The [email configuration helper](#ckeditor5/latest/features/email-editing/email-configuration-helper.html) features provides a comprehensive set of tools for email composition and editing. It helps overcome various semantic and technical difficulties by:

* Verifying editor configuration for email compatibility.
* Ensuring proper HTML structure for email clients.
* Managing content restrictions specific to email formats.
* Providing warnings about unsupported features in email clients.

Using this feature alongside export with inline styles ensures your email content not only looks correct but also follows email-specific best practices and technical requirements. Learn how to configure it in the [email configuration helper](#ckeditor5/latest/features/email-editing/email-configuration-helper.html) guide.

#### Layout tables plugin

The [layout tables](#ckeditor5/latest/features/tables/layout-tables.html) feature provides specialized layout tables that are specifically designed for structuring email content, as opposed to presenting data in traditional content tables. For optimal email template development, we recommend using the [`TableLayout`](../../api/module_table_tablelayout-TableLayout.html) plugin alongside the export with inline styles feature.

Layout tables created using the `TableLayout` plugin:

* Have `role="presentation"` for better accessibility.
* Include proper styling optimized for email layouts (100% width, proper borders, and padding).
* Maintain their appearance when exported with inline styles.

This is particularly important for email templates where table-based layouts are still the standard practice. The combination of layout tables and inline styles export ensures that your email templates maintain their structure and appearance across different email clients.

> **Note**
>
> Layout tables created with the `TableLayout` plugin are automatically detected during the export process and their specific styling requirements are preserved in the output.

Learn how to configure it in the [Layout tables](#ckeditor5/latest/features/tables/layout-tables.html) guide.

#### Export with inline styles plugin

The export inline styles feature turns the editor’s global CSS styles into inline styles for DOM elements. For example, a global `<p class="red">` style defining the font color to be red will be turned into `<p style="color: red">`. Learn how to configure it in the [export with inline styles](#ckeditor5/latest/features/export-with-inline-styles.html--configuration) guide.

##### Email-specific style transformations

For email-specific use cases, the package provides dedicated transformations through the [`getEmailInlineStylesTransformations()`](../../api/module_email_emailinlinestylestransformations.html#function-getEmailInlineStylesTransformations) function. These transformations improve compatibility with email clients by converting modern CSS properties to better-supported HTML attributes.

To use these transformations, import the function and include it in your editor configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { ExportInlineStyles, getEmailInlineStylesTransformations } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ ExportInlineStyles, /* ...other plugins */ ],
		exportInlineStyles: {
			// Add email-specific transformations to the editor configuration.
			transformations: getEmailInlineStylesTransformations( {
				// Transform figure elements to tables for better email client compatibility.
				useFigureToTableFallback: true
			} )
		}
	} )
	.then( editor => {
		// When exporting content, the email transformations will be applied automatically.
		editor.execute( 'exportInlineStyles' )
			.then( html => {
				console.log( 'Email-ready content with proper HTML attributes:', html );
			} );
	} )
	.catch( error => {
		console.error( error );
	} );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { ExportInlineStyles, getEmailInlineStylesTransformations } = CKEDITOR_PREMIUM_FEATURES;

The provided transformations handle the following email-specific styling conversions:

1. Float to align attribute:

* `<img style="float: left">` → `<img style="float: left" align="left">`
   * `<table style="float: right">` → `<table style="float: right" align="right">`

2. Table centering via auto margins:

* `<table style="margin-left: auto; margin-right: auto">` → `<table style="..." align="center">`

These transformations ensure better rendering consistency across various email clients that may have limited CSS support but respect traditional HTML attributes.

You can also combine these email transformations with your own custom transformations:

```js
ClassicEditor
    .create( {
        plugins: [ ExportInlineStyles, /* ...other plugins */ ],
        exportInlineStyles: {
            transformations: [
                ...getEmailInlineStylesTransformations( {
                    // Transform figure elements to tables for better email client compatibility.
                    useFigureToTableFallback: true
                } ),
                // Your additional custom transformations.
                ( element, stylesMap ) => {
                    if ( element.tagName === 'A' ) {
                        stylesMap.set( 'text-decoration', 'underline' );
                    }
                }
            ]
        }
    } );
```

#### Plain table output

This feature strips the table data from the `<figure>` tag and moves all applied attributes to the `table` element. This is because this tag is not supported by most popular email clients and removing it ensures compatibility. Learn more about this plugin in the [Plain table output](../../api/module_table_plaintableoutput-PlainTableOutput.html) API guide.

#### Merge fields plugin

Merge fields are visually distinct placeholder elements, which you may put into the content to mark places, where real values should be inserted. This is perfect for creating document templates and other kinds of personalized content. Learn how to configure it in the [Merge fields](#ckeditor5/latest/features/merge-fields.html--configuration) guide.

#### Template plugin

The template plugin allows you to create and manage templates in the editor. It provides a user-friendly interface for selecting and applying templates to your content. It is useful for creating consistent email designs and layouts. Learn how to configure it in the [Templates](#ckeditor5/latest/features/template.html--configuration) guide.

#### Empty block plugin

The [`EmptyBlock`](../../api/module_html-support_emptyblock-EmptyBlock.html) plugin removes the ` ` fillers added by default to empty block elements like paragraphs. In some cases, such as loading legacy content, this prevents inconsistent rendering across email clients and interference with the CSS styling.

Here is how empty blocks are handled with and without the plugin:

```html

<p class="spacer"> </p>
<td> </td>

<p class="spacer"></p>
<td></td>
```

To enable the EmptyBlock plugin, add it to your editor configuration:

**NPM**

```js
import { EmailConfigurationHelper } from 'ckeditor5-premium-features';
import { EmptyBlock } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ EmailConfigurationHelper, EmptyBlock, /* ... */ ],
		htmlSupport: {
			preserveEmptyBlocksInEditingView: true
		}
	} )
	.then( editor => {
		console.log( 'Editor was initialized' );
	} )
	.catch( error => {
		console.error( error );
	} );
```

**CDN**

```js
const { EmailConfigurationHelper } = CKEDITOR_PREMIUM_FEATURES;
const { EmptyBlock } = CKEDITOR;

The `preserveEmptyBlocksInEditingView` option determines whether empty blocks should be preserved during editing (`true`) or only in the final output (`false`).

### Known issues

Email rendering can vary significantly between different email clients due to inconsistent HTML and CSS support. What looks perfect in one client may appear broken in another. Always test your emails in various popular clients and devices before sending them to ensure consistent appearance and functionality across platforms.

* Email clients’ default styles can significantly impact the rendering of your content. Even small changes like adding the `<!DOCTYPE html>` preamble to your email can dramatically alter the appearance of your content. However, many email clients use their rendering engines and may ignore the `DOCTYPE` altogether. Including it does not cause harm and is considered a best practice.
* Email clients do not support all color modes available in the editor. If you intend to use, for example, the [font color or font background color](#ckeditor5/latest/features/font.html) features in your editor, please [set the color picker](#ckeditor5/latest/features/font.html--color-picker) to `hex` mode for optimal compatibility.
* Most email clients offer no support for alpha channel settings in the `rgb` color mode.

### Related features

Here are some related CKEditor 5 features that you may find helpful:

* [Export with inline styles](#ckeditor5/latest/features/export-with-inline-styles.html) – The export with inline styles feature turns all external CSS style sheets into inline styles, providing better compatibility with various email clients.
* [Layout tables](#ckeditor5/latest/features/tables/layout-tables.html) – Create layout tables optimized for email templates with proper structure and styling.
* [Plain table output](../../api/module_table_plaintableoutput-PlainTableOutput.html) – This plugin strips the `<figure>` tag from the table data for email client compatibility.
* [Merge fields](#ckeditor5/latest/features/merge-fields.html) – Create placeholder elements in your content to replace later.
* [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) – Add support for additional HTML elements and attributes in your content.
* [Styles](#ckeditor5/latest/features/style.html) – Apply predefined styles to content elements that can be exported as inline styles.

<a id="ckeditor5/latest/features/emoji.html">source file: "ckeditor5/latest/features/emoji.html"</a>

## Emoji

The emoji feature lets you insert emojis into the document from the editor toolbar or while writing the content. The emojis are pulled from the CDN to lessen the editor load.

Since there is a large number of emojis, they have been conveniently divided into several categories for easier use, such as “Smileys & Expressions” or “Objects.” You may also search for a specific emoji using the search field.

### Demo

Use the emoji toolbar button in the editor below to open a panel with a table of selectable emojis. You may also trigger the emoji UI while writing the content by typing the pre-configured `:` marker followed by at least two letters of desired emoji name. Then, you can either choose which emoji to insert from the suggestion list or select the `Show all emoji...` option to open the full panel. The marker must be preceded by a space to work.

There is an option to set the skin tone of the emojis next to the search field, too.

The selected emoji category and skin tone are remembered by the feature, so next time you invoke the panel, you can quickly insert an emoji of similar type.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Emoji, Mention } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Emoji, Mention, /* ... */ ],
		toolbar: [ 'emoji', /* ... */ ],
		emoji: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Emoji, Mention } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Emoji, Mention, /* ... */ ],
		toolbar: [ 'emoji', /* ... */ ],
		emoji: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> The emoji feature requires the [mentions feature](#ckeditor5/latest/features/mentions.html) to be installed to work properly.

The [emoji plugin](../api/module_emoji_emoji-Emoji.html) consists of two sub-plugins:

* [`EmojiMention`](../api/module_emoji_emojimention-EmojiMention.html) – Adds support for triggering the emoji UI dropdown while writing the content when you type a pre-configured `:` marker followed by at least two letters of the desired emoji name.
* [`EmojiPicker`](../api/module_emoji_emojipicker-EmojiPicker.html) – Registers the UI button component, which opens a panel with a table of selectable emojis.

You can freely choose how to load the feature: either as a whole (as shown in the example above) or select one of the sub-plugins if you need only one of the ways of inserting emojis into the document.

### Unsupported contexts

The emoji autocompletion triggered by the `:` marker is automatically disabled inside [code blocks](#ckeditor5/latest/features/code-blocks.html). Typing `:` inside a code block will insert the character as plain text without triggering the emoji suggestions. The toolbar emoji picker button remains available regardless of the cursor position.

### Configuration

The feature can be configured via the [`config.emoji`](../api/module_emoji_emojiconfig-EmojiConfig.html) object.

* `dropdownLimit` – the number of items to appear in the emoji dropdown.

```js
  ClassicEditor
      .create( {
          // ... Other configuration options ...
          emoji: {
              dropdownLimit: 5
          }
      } )
      .then( /* ... */ )
      .catch( /* ... */ );
  ```

* `skinTone` – the initial skin tone for the emojis that support skin tones.

```js
  ClassicEditor
      .create( {
          // ... Other configuration options ...
          emoji: {
              skinTone: 'medium'
          }
      } )
      .then( /* ... */ )
      .catch( /* ... */ );
  ```

* `definitionsUrl` – the URL to the emoji definitions file. The URL should return a JSON array with emoji definitions specified by the [`EmojiCdnResource`](../api/module_emoji_emojirepository-EmojiCdnResource.html) interface.

> **Warning**
  >
  > If the `definitionsUrl` is not provided, the feature will fetch the emoji definitions from the CKEditor 5 CDN.

```js
  ClassicEditor
      .create( {
          // ... Other configuration options ...
          emoji: {
              definitionsUrl: 'https://example.com/emoji-definitions.json'
          }
      } )
      .then( /* ... */ )
      .catch( /* ... */ );
  ```

* `version` – the emoji database version. By default, version 16 is used. This option is ignored if the `definitionsUrl` setting is provided.

```js
  ClassicEditor
      .create( {
          // ... Other configuration options ...
          emoji: {
              version: 15
          }
      } )
      .then( /* ... */ )
      .catch( /* ... */ );
  ```

* `useCustomFont` – if you customize the [emoji availability and appearance](#ckeditor5/latest/features/emoji.html--emoji-availability-and-appearance). It that case, it is highly recommended to disable the filtering mechanism because it uses a font built-in to your system.

```js
  ClassicEditor
      .create( {
          // ... Other configuration options ...
          emoji: {
              useCustomFont: true
          }
      } )
      .then( /* ... */ )
      .catch( /* ... */ );
  ```

#### Emoji availability and appearance

The availability of the emoji depends on the operating system. Different systems will have different Unicode support. You may decide to lower the number of newer emoji by setting a lower [`version`](../api/module_emoji_emojiconfig-EmojiConfig.html#member-version) of Unicode of the emoji repository (CKEditor 5 hosts v15 and v16) or by providing a custom emoji repository using the [`definitionsUrl`](../api/module_emoji_emojiconfig-EmojiConfig.html#member-definitionsUrl). This way, the users with newer systems will not be able to use newer emojis. Keep in mind that this only affects the editor feature. A user will still be able to use the native emoji insertion methods. The availability may also increase with the usage of a custom font.

If you want to standardize the appearance of emoji accross operating systems, please consider using an external font in your integration, such as [Noto Color Emoji](https://fonts.google.com/noto/specimen/Noto+Color+Emoji). In the setup make sure to:

1. Set the `font-family` for the content, this way the emoji in the editable will use the custom font. For example:

```css
   body {
       font-family: 'Lato', 'Noto Color Emoji', sans-serif;
   }
   ```

2. Update the `--ck-font-face` variable, so that emoji in the picker and mention will use the custom font.

```css
   :root {
       --ck-font-face: Helvetica, Arial, Tahoma, Verdana, 'Noto Color Emoji';
   }
   ```

3. Update the [editor configuration](../api/module_core_editor_editorconfig-EditorConfig.html) by adding the [`emoji.useCustomFont`](../api/module_emoji_emojiconfig-EmojiConfig.html#member-useCustomFont) option.

```js
   {
       // ... Other configuration options ...
       emoji: {
           useCustomFont: true
       }
   }
   ```

#### Emoji source

The database of English emoji is loaded by default from our CDN. Make sure that your [CSP rules](#ckeditor5/latest/getting-started/setup/csp.html) are correctly set up.

If you do not want to use our distribution and prefer to self-host emoji, you can use the [`definitionsUrl`](../api/module_emoji_emojiconfig-EmojiConfig.html#member-definitionsUrl) option. You can download the data directly from the package mentioned above or from our CDN, and place it under a static assets URL, for example:

1. Download the latest emoji database from <https://cdn.ckeditor.com/ckeditor5/data/emoji/16/en.json>, or download version 15 for older Unicode versions.
2. Place the downloaded file in your application’s assets folder, for example `public/emoji/en.json`. The specific location may vary depending on your framework and setup.
3. Update the configuration option `definitionsUrl` to point to the URL of your assets, for example: `https://example.com/emoji/en.json`.

You can prepare your own database with a different emoji set, but it must have an identical structure as ours. Otherwise, the Emoji feature will not work.

#### Marker conflicts

The emoji feature uses the `:` marker that opens a panel with a table of selectable emojis. If you use the [mentions](#ckeditor5/latest/features/mentions.html) or [merge fields](#ckeditor5/latest/features/merge-fields.html) features, they can also show UI panels by pressing a pre-configured key. Those keys may conflict with the emoji feature. In such a case, the [`EmojiMention`](../api/module_emoji_emojimention-EmojiMention.html) plugin will not integrate the autocompletion mechanism.

To prevent conflicts, make sure that the [mention’s `marker`](../api/module_mention_mentionconfig-MentionFeed.html#member-marker) and [merge field’s `prefix`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-prefix) configuration options are not defined as `:`.

### Troubleshooting

If you are experiencing issues with the emoji feature in CKEditor 5 and the `emoji-repository-empty` is displayed in the console, it may be due to missing system support for emoji fonts or problems loading the emoji repository. Below are some common issues and their solutions.

#### No emoji font installed

**Problem**:\
The system does not have an emoji font installed, preventing the emoji feature from rendering emoji correctly.

**Solution**:\
To use the emoji feature, install an emoji font on your operating system:

* macOS: `Apple Color Emoji`
* Windows: `Segoe UI Emoji`
* Linux: `Noto Color Emoji` (or an alternative like `Twemoji`)

Once installed, restart your browser and reload the editor.

#### Server error when loading the emoji repository

**Problem**:\
The request to load the emoji repository was completed, but the server returned an error (such as `404 Not Found`, or `500 Internal Server Error`).

**Solution**:

* Ensure the emoji repository URL is correct and accessible.
* If using a custom emoji repository, verify that it is properly configured.

#### Network issues preventing the emoji repository from loading

**Problem**:\
The emoji repository could not be loaded due to a network issue, CORS restriction, or blocked request.

**Solution**:

* Verify that the URL is correct and accessible.
* Check your internet connection.
* If applicable, update your Content Security Policy (CSP) settings to allow connections to the emoji repository.

For more details on configuring CSP, see the [Content Security Policy](#ckeditor5/latest/getting-started/setup/csp.html) guide.

By following these steps, you should be able to resolve common issues with the emoji plugin in CKEditor 5. If problems persist, check your browser console for additional error messages or consult the CKEditor 5 [GitHub repository for support](https://github.com/ckeditor/ckeditor5/issues).

### Related features

In addition to enabling the emoji feature, you may want to check the following related features:

* [Special characters](#ckeditor5/latest/features/special-characters.html) – Allows inserting **mathematical operators**, **currency symbols**, **punctuation**, **graphic symbols** (such as arrows or bullets), or Unicode letters typically not accessible from the keyboard (such as **umlauts** or **other diacritics**).
* [Mentions](#ckeditor5/latest/features/mentions.html) – Brings support for smart autocompletion.

### Common API

The [`EmojiPicker`](../api/module_emoji_emojipicker-EmojiPicker.html) plugin registers the UI button component (`'emoji'`) and the command (`'emoji'`) that allows opening the emoji picker UI.

> **Note**
>
> We recommend using the official [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) for development and debugging. It will give you tons of useful information about the state of the editor, such as internal data structures, selection, commands, and many more.

### Contribute

The source code of the feature is available at GitHub in <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-emoji>.

<a id="ckeditor5/latest/features/export-with-inline-styles.html">source file: "ckeditor5/latest/features/export-with-inline-styles.html"</a>

## Export with inline styles

The export with inline styles feature applies the styles defined by CSS style sheets directly on HTML elements. For example, a global `<p class="red">` style defining the font color to be red, will be turned into `<p style="color: red">`. This is especially useful for email creation but may be helpful in other use cases.

### Demo

Use the Source editing command to see changes. Check the output below to see the exported content with inline styles applied.

Switch the tabs below to see three different outputs: the HTML tags with classes, CSS styles, and the HTML with those styles inlined. The last output shows how the exported content would look like.

**HTML**

**CSS**

**HTML with inline styles**

The preview below shows the rendered content with inlined styles.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { ExportInlineStyles } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ ExportInlineStyles, /* ... */ ],
		exportInlineStyles: {
			// Configuration.
		}
	} )
	.then( editor => {
		editor.execute( 'exportInlineStyles' )
			.then( html => {
				console.log( 'Email-ready content with proper HTML attributes:', html );
			} );
		// ...
	} )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { ExportInlineStyles } = CKEDITOR_PREMIUM_FEATURES;

#### Activating the feature

### Configuration

The export with inline styles feature can be configured using the `exportInlineStyles` configuration object:

```ts
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            stylesheets: [ '/ckeditor5-content.css' ],
            inlineCss: `
                .ck-content {
                    .warning { color: red; }
                    .note { background: yellow; }
                }
            `,
            stripCssClasses: true
            // ...
        }
    } )
```

#### Stylesheets

An array of paths (relative or absolute URLs) to CSS files that the plugin loads from the browser using `fetch()` and processes during export. The order matters — later files override styles from earlier ones.

##### Source files

Provide the editor’s content style sheets so the exported HTML preserves the look readers see in the editor. CKEditor 5 distributes content-only style sheets in two locations:

* The `dist/ckeditor5-content.css` file from the `ckeditor5` npm package and the matching `dist/ckeditor5-premium-features-content.css` from the `ckeditor5-premium-features` npm package.
* The same files served from `https://cdn.ckeditor.com/ckeditor5/48.4.0/ckeditor5-content.css` and `https://cdn.ckeditor.com/ckeditor5-premium-features/48.4.0/ckeditor5-premium-features-content.css`.

For full background, see the [Editor and content styles](#ckeditor5/latest/getting-started/setup/css.html) guide.

##### Hosting the CSS in your application

The `stylesheets` option uses `window.fetch()` to load each URL from the browser. The files must be served from a same-origin URL or have permissive CORS headers — bundler-only paths (for example, `import 'ckeditor5/ckeditor5-content.css'`) are not reachable. Copy or reference the files in a way that matches your application setup:

| Integration           | Where to host the file                                               | Example URL in the config                |
| --------------------- | -------------------------------------------------------------------- | ---------------------------------------- |
| Next.js (App / Pages) | Copy to `public/`, then reference from the site root.                | `'/ckeditor5-content.css'`               |
| React (Vite, CRA)     | Place in `public/` (Vite, CRA) — referenced from the site root.      | `'/ckeditor5-content.css'`               |
| Vue 3 (Vite)          | Place in `public/` and reference from the site root.                 | `'/ckeditor5-content.css'`               |
| Nuxt 3                | Place in `public/`.                                                  | `'/ckeditor5-content.css'`               |
| Angular CLI           | Add to the `assets` array in `angular.json` and reference from root. | `'/assets/ckeditor5-content.css'`        |
| Server-rendered apps  | Serve from your application’s static directory.                      | `'/static/ckeditor5-content.css'`        |
| CDN                   | Reference the CKEditor CDN URL directly (no local copy).             | See the CDN configuration example below. |

A typical configuration combining both content style sheets and an application-specific style sheet:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            stylesheets: [
                '/ckeditor5-content.css', // Open-source content styles.
                '/ckeditor5-premium-features-content.css', // Premium content styles (if used).
                '/styles.css' // Your application styles.
            ]
        }
    } )
```

Or, when loading style sheets directly from the CKEditor CDN:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            stylesheets: [
                'https://cdn.ckeditor.com/ckeditor5/48.4.0/ckeditor5-content.css', // Open-source content styles.
                'https://cdn.ckeditor.com/ckeditor5-premium-features/48.4.0/ckeditor5-premium-features-content.css', // Premium content styles (if used).
                '/styles.css' // Your application styles.
            ]
        }
    } )
```

If `stylesheets` is omitted, the plugin processes only the default editor content style sheets via the `'EDITOR_STYLES'` token. This token works only in legacy custom builds with webpack or DLLs. In npm and CDN setups, these default content style sheets are not inlined unless you list URLs explicitly.

> **Warning**
>
> **CSS selectors must include the `.ck-content` prefix**
>
> Styles without this prefix will be ignored during the inline styles transformation. You can use CSS nesting with `.ck-content` as the parent:
>
> For example:
>
> ```css
> /* ❌ This style will be ignored */
> .warning { color: red; }
>
> /* ✅ This style will be processed - flat approach */
> .ck-content .warning { color: red; }
>
> /* ✅ This style will be processed - nested approach */
> .ck-content {
>     .warning { color: red; }
> }
> ```

> **Note**
>
> **Direct styles on `.ck-content` are inherited by first-level children**
>
> Any styles set directly on the `.ck-content` element will be copied to all its direct children during export. This is because the `.ck-content` element itself is synthetic and not part of the exported content.
>
> For example, if you define styles like `color: red` and `font-family: Arial` on `.ck-content`, all first-level elements such as paragraphs and lists will have these styles directly applied to them in the exported content. This inheritance only applies to first-level children, not to deeper descendants.

#### Inline CSS

A string containing CSS rules to apply after processing the external style sheets. Useful for adding supplemental styles without external files. The option defaults to an empty string.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            inlineCss: `
                .ck-content {
                    /* Styles directly applied to .ck-content */
                    color: blue;
                    font-family: Arial;

/* Nested styles for children */
                    .warning {
                        color: red;
                        font-weight: bold;
                    }
                    .highlight {
                        background: yellow;
                    }
                }
            `
            // ...
        }
    } )
```

#### Strip CSS classes

When set to `true`, the feature will remove the CSS classes from elements after inline styles are applied. This ensures the exported content preserves styling without depending on external style sheets. The option defaults to `false`.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            stripCssClasses: true
            // ...
        }
    } )
```

#### Transformations

An array of functions that allow you to modify the elements and their styles before applying inline styles. Each function receives the element and a `stylesMap` object, which contains the computed styles for that element. You can use this to add, remove, or modify styles based on your needs.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        exportInlineStyles: {
            transformations: [
                ( element, stylesMap ) => {
                    // Example transformation: Add a custom attribute to all paragraphs.
                    if ( element.tagName === 'P' ) {
                        element.setAttribute( 'data-paragraph', 'true' );
                    }
                }
            ]
            // ...
        }
    } )
```

We also provide a handy transformation helper for email creation use cases. These transformations improve compatibility with email clients by converting modern CSS properties to better-supported HTML attributes.

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { ExportInlineStyles, getEmailInlineStylesTransformations } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		// ... Other configuration options ...
		exportInlineStyles: {
			// Add email-specific transformations to the editor configuration.
			transformations: getEmailInlineStylesTransformations()
			// ...
		}
	} )
	.then( editor => {
		// When exporting content, the email transformations will be applied automatically.
		editor.execute( 'exportInlineStyles' )
			.then( html => {
				console.log( 'Email-ready content with proper HTML attributes:', html );
			} );
	} )
	.catch( error => {
		console.error( error );
	} );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { ExportInlineStyles, getEmailInlineStylesTransformations } = CKEDITOR_PREMIUM_FEATURES;

### Usage

To export the editor content with inline styles, use the [`ExportInlineStyles`](../api/module_export-inline-styles_exportinlinestyles-ExportInlineStyles.html) command:

```js
editor.execute( 'exportInlineStyles' )
    .then( ( html ) => {
        console.log( html );
    } )
    .catch( ( error ) => {
        console.error( error );
    } );
```

You can also pass configuration options directly to the command. These options will override any editor configuration settings:

```js
editor.execute( 'exportInlineStyles', {
    stylesheets: [ '/ckeditor5-content.css' ],
    inlineCss: '.ck-content .warning { color: red; }',
    stripCssClasses: true,
    transformations: [ /* custom transformations */ ]
} )
    .then( ( html ) => {
        console.log( html );
    } )
    .catch( ( error ) => {
        console.error( error );
    } );
```

The command outputs the exported content as an HTML string with inline styles applied. You can then use the content in email templates, CMS systems, or other environments where external CSS is not supported.

> **Warning**
>
> **One-way transformation**
>
> The exported content should not be loaded back to the editor. The content with inlined styles will render depending on the editor’s configuration and the UI of some features may not work correctly.
>
> If you want to save the content with inlined styles, make sure to save the `getData` output as well as `exportInlineStyles` . Always load the editor with the `getData` output.
>
> If you need to load content with inlined styles consider using the [General HTML Support (“GHS”)](#ckeditor5/latest/features/html/general-html-support.html) feature. However, it may lose some of the original styling and document structure.

#### Style transformations

The export with inline styles feature allows you to apply custom transformations to elements before inline styles are applied. Transformations enable you to modify elements and their styles programmatically during the export process.

##### When transformations are invoked

Transformations are called for each element in the DOM tree during the export process:

1. Child elements are processed first, before their parent elements.
2. For each element, the transformation is executed immediately before inline styles are assigned to the element.

This execution order gives you powerful control over the exported content:

* You can modify the element’s attributes and styles just before they are finalized.
* You can add or remove styles from the `stylesMap` to customize the final appearance.
* You can manipulate the element’s children (add, remove, or modify) since they are already processed when the parent’s transformation is called.
* You can even remove elements completely from the output if needed.

##### Example transformation

```js
transformations: [
    ( element, stylesMap ) => {
        // Add a new style.
        if ( element.tagName === 'P' ) {
            stylesMap.set( 'line-height', '1.5' );
        }

// Remove a style.
        if ( element.classList.contains( 'no-margin' ) ) {
            stylesMap.delete( 'margin' );
        }

// Modify child structure.
        if ( element.classList.contains( 'box' ) ) {
            // Remove unwanted child elements.
            const unwantedElements = Array.from( element.querySelectorAll( '.remove-me' ) );
            unwantedElements.forEach( el => el.remove() );

// Add new child element.
            const disclaimer = document.createElement( 'div' );
            disclaimer.textContent = 'Important notice';
            element.appendChild( disclaimer );
        }
    }
]
```

This processing approach provides flexibility for implementing complex export logic while ensuring all styles are properly applied to the modified DOM structure.

#### Real-world example

Here is a simple example showing how to use this feature to export content for an email message:

```js
// Button that exports the editor content for email use.
document.querySelector( '#export-for-email' ).addEventListener( 'click', () => {
    // Get content with inline styles with configuration options.
    editor.execute( 'exportInlineStyles', {
        // Specify which root to use (useful in multi-root editors).
        rootName: 'main',

// Override editor configuration with email-specific settings.
        stylesheets: [ './email-styles.css' ],
        inlineCss: `
            .ck-content {
                font-family: Arial, sans-serif;
                .quote { font-style: italic; }
            }
        `,
        stripCssClasses: true,

// Apply email-specific transformations.
        transformations: [
            ( element, stylesMap ) => {
                // Make all links color blue and underlined for better email client compatibility.
                if ( element.tagName === 'A' ) {
                    stylesMap.set( 'color', '#0066cc' );
                    stylesMap.set( 'text-decoration', 'underline' );
                }

// Ensure all images have explicit width/height (helps with email rendering).
                if ( element.tagName === 'IMG' && !element.getAttribute( 'width' ) ) {
                    element.setAttribute( 'width', '300px' );
                    element.setAttribute( 'height', '100px' );
                }

// Ensure paragraphs have margin for email spacing.
                if ( element.tagName === 'P' ) {
                    stylesMap.set( 'margin-bottom', '16px' );
                }
            }
        ],

// Remove all classes to prevent dependency on external CSS.
        stripCssClasses: true
    } )
        .then( htmlWithInlineStyles => {
            // Use the exported content in your email sending logic.
            sendEmail( {
                subject: 'Newsletter',
                content: htmlWithInlineStyles,
                recipients: [ 'user@example.com' ]
            } );
        } )
        .catch( error => {
            console.error( 'Failed to export content:', error );
        } );
} );

// Example email sending function (would be replaced with your actual email API).
function sendEmail( emailData ) {
    console.log( 'Sending email with inline-styled content:', emailData );
    // Your email API call would go here:
    // emailAPI.send( emailData );
}
```

### Compatibility

#### Supported features

* Basic CSS properties (`color`, `background-color`, `font-family`, etc.)
* Compound properties (`background`, `margin`, `padding`, etc.)
* CSS variables (resolved during export)
* Simple CSS selectors (`class`, `id`, `element`)

Supported pseudo-classes:

* Structural pseudo-classes:

* `:first-child`
  * `:last-child`
  * `:nth-child()`
  * `:only-child`
  * `:empty`
  * `:nth-of-type()`
  * `:first-of-type`
  * `:last-of-type`

* Logical pseudo-classes:

* `:matches()`
  * `:not()`
  * `:is()`

* Root pseudo-class:
  * `:root`

#### Limited or unsupported features

* `media` queries

* `@import` and `@font-face` rules

* `@keyframes` and `animation` properties

* `transition` properties

* `:before` and `:after` pseudo-elements

* Interactive state pseudo-classes:

* `:focus`
  * `:visited`
  * `:link`
  * `:hover`
  * `:active`

* Shadow DOM and `::part()` selectors

### Related features

Here are some other CKEditor 5 features that work well with the export with inline styles feature:

* [Email configuration helper](#ckeditor5/latest/features/email-editing/email-configuration-helper.html) – Ensure email-compatible content structure and validate against email client restrictions.
* [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) – Add support for additional HTML elements and attributes in your content.
* [Style](#ckeditor5/latest/features/style.html) – Apply predefined styles to content elements that can be exported as inline styles.
* [Layout tables](#ckeditor5/latest/features/tables/layout-tables.html) – Layout tables are used to structure a web page content spatially rather than for presenting tabular data.

### Common API

The [`ExportInlineStyles`](../api/module_export-inline-styles_exportinlinestyles-ExportInlineStyles.html) plugin registers the [`ExportInlineStyles`](../api/module_export-inline-styles_exportinlinestyles-ExportInlineStyles.html) command.

It accepts the optional `rootName` configuration parameter, which determines the editor root to use for content origin.

<a id="ckeditor5/latest/features/feature-digest.html">source file: "ckeditor5/latest/features/feature-digest.html"</a>

## Feature digest

CKEditor 5 offers over 150 various features, from basic editing capabilities like bold or italics to full-blown real-time collaboration, where multiple people can work on one document at the same time. This page collects them all and groups them into capabilities, features, and sub-features. Let’s hope this list will help you grasp and easily digest everything CKEditor 5 has to offer.

### Core editing

Core editing capability provides tools to create, edit, and style content. Here are essentials that every writer needs in their tool belt, like bold or italics. There is also something for coders - advanced HTML editing capabilities where you can directly edit HTML elements.

#### Advanced HTML Editing

Advanced HTML Editing provides general HTML support, offering detailed control over permissible HTML elements, attributes, and styles. It further allows HTML Source Code Editing, handling HTML elements, HTML comments, and editing of the full page content, including meta tags.

#### Block formatting

Block Formatting allows for the organization and emphasis of content through the use of Headings, Style Headings, Block Quotes, and Horizontal Lines. Users can select from different levels of headings to outline sections and subsections, apply various styles to these headings for visual hierarchy, insert horizontal lines to delineate sections, and use block quotes to highlight excerpts or important passages.

#### Bookmarks

The bookmarks feature allows for adding and managing the bookmarks anchors attached to the content of the editor. These provide fast access to important content sections, and speed up the navigation boosting efficiency.

[Feature page](#ckeditor5/latest/features/bookmarks.html)

#### Clipboard

Copy, cut, and paste content within the editor or from external sources.

[Feature page](#ckeditor5/latest/framework/deep-dive/clipboard.html)

#### Code blocks

Supports the insertion and management of pre-formatted code snippets with distinct styling.

[Feature page](#ckeditor5/latest/features/code-blocks.html)

#### Drag and drop

Rearrange elements within a document, including moving text blocks, images, or other content types.

[Feature page](#ckeditor5/latest/features/drag-drop.html)

#### Font formatting

The font feature lets you change font family, size, and color (including background color). All of these options are configurable.

#### Image

The image feature allows adding images of various kinds to the rich content inside the editor. A large set of subfeatures lets the users fully control this process. Upload or paste images, insert via URL, use responsive images, resize images, add captions, set different image styles, and link images.

#### Links

Facilitates the addition of hyperlinks to text, automatically converting typed or pasted URLs into clickable links, and allowing manual insertion and editing of links.

[Feature page](#ckeditor5/latest/features/link.html)

#### Lists

Lists allow the creation and management of various list types, including to-do lists, bulleted and numbered lists, with additional customization options such as list styles, setting the start number for lists, creating reversed lists, adjusting list indentation, and crafting nested lists.

#### Mermaid

You can create flowcharts and diagrams in CKEditor 5 thanks to the experimental integration with the Mermaid library. Mermaid uses a Markdown-inspired syntax to create and dynamically modify flowcharts, Gantt diagrams, pie or quadrant charts, graphs, mindmaps, and more.

[Feature page](#ckeditor5/latest/features/mermaid.html)

#### Remove formatting

The remove format feature lets you quickly remove any text formatting applied using inline HTML elements and CSS styles, like basic text styles (bold, italic) or font family, size, and color. This feature does not remove block-level formatting (headings, images) or semantic data (links).

[Feature page](#ckeditor5/latest/features/remove-format.html)

#### Select all

Enables the selection of all content within the editor with a single command or shortcut.

[Feature page](#ckeditor5/latest/features/select-all.html)

#### Tables

CKEditor 5 provides robust support for tables, with the ability to merge and split cells, resize columns, style tables and individual cells, insert and delete columns and rows, as well as create nested tables for complex data presentation.

#### Text alignment

Allows the adjustment of text alignment to the left, right, center, or justify and permits the alteration of indentation.

[Feature page](#ckeditor5/latest/features/text-alignment.html)

#### Text formatting

CKEditor 5 provides developers with text editing and formatting features such as Bold, Italic, Underline, Strikethrough, Subscript, Superscript, Inline Code, Highlight, and Font Styles. These features allow users to style and present their content as needed. This ensures users can style their text to improve readability, match branding guidelines, or highlight important content sections.

#### Undo/redo

Backtrack or repeat actions for editing purposes.

[Feature page](#ckeditor5/latest/features/undo-redo.html)

### Collaboration

Collaborate with others - real-time or asynchronously. Comment, co-author, and mention team members in your documents. With collaboration features review process should be a breeze.

#### Asynchronous collaboration

Asynchronous Collaboration in CKEditor 5 is designed for teams using a turn-based approach to collaboratively write, review, and discuss content within the application. It integrates Track Changes, Comments, and Revision History features to facilitate collaboration.

#### Comments

Users can add side notes to marked fragments of the document, including text and block elements such as images. It also allows the users to discuss in threads and remove comments when they finish the discussion.

#### Mentions

The mention feature supports smart autocompletion triggered by user input. Typing a predetermined marker, like @ or #, prompts a panel to appear, offering autocomplete suggestions.

[Feature page](#ckeditor5/latest/features/mentions.html)

#### Real-time collaboration

Real-Time Collaboration in CKEditor 5 is designed for users who are writing, reviewing, and commenting on content simultaneously. It also automatically solves all conflicts if users make changes at the same time.

#### Revision history

The revision history feature is a document versioning tool. It allows CKEditor 5 users to create and view the chronological revision history of their content. These versions are listed in the side panel. The preview mode allows for easy viewing of content development between revisions. You can rename, compare, and restore older revisions on the go.

[Feature page](#ckeditor5/latest/features/collaboration/revision-history/revision-history.html)

#### Track changes

The track changes feature brings automatic suggestion marking for the document as you change it. When editing the document, the user can switch to the track changes mode. All their changes will then create suggestions that they can accept or discard.

[Feature page](#ckeditor5/latest/features/collaboration/track-changes/track-changes.html)

#### Users list and permissions

The Users plugin and related plugins let you manage user data and permissions. This is essential when many users are working on the same document.

[Feature page](#ckeditor5/latest/features/collaboration/users.html)

### Content conversion & embedding

Collaborate also regarding different formats. With content conversions, you can integrate content across commonly used business formats. You can also enrich your content with media embeds.

#### Content generation

CKEditor 5 may be your universal starting point for generating content in several recognizable formats.

#### Export with inline styles

The `ExportInlineStyles` plugin applies the styles defined by CSS style sheets directly on HTML elements.

[Feature page](#ckeditor5/latest/features/export-with-inline-styles.html)

#### Markdown output

Enable Markdown as the default output format instead of HTML with the Markdown plugin. Combined with Autoformatting, CKEditor becomes an efficient Markdown editor, allowing the creation of text documents using the simplified formatting syntax favored by developers.

[Feature page](#ckeditor5/latest/features/markdown.html)

#### Media embed

Embed media such as YouTube or Vimeo videos and other rich content directly in your editor – either via the insert media button in the toolbar or by pasting a URL straight into the editor.

#### Paste Markdown

The paste Markdown feature lets users paste Markdown-formatted content straight into the editor. It will be then converted into rich text on the fly.

[Feature page](#ckeditor5/latest/features/pasting/paste-markdown.html)

#### XML output

Turn your content into parsable XML files for automation and cross-platform interoperability.

[Feature page](../api/module_engine_dataprocessor_xmldataprocessor-XmlDataProcessor.html)

### Page management

Format, organize, and navigate your documents easily with page management features. Create a table of contents, insert page breaks, and manage pagination.

#### Document outline

The Document Outline feature automatically detects and lists document headings in a sidebar, enabling faster navigation through large documents. Headings are organized in a structured list, so users can click and jump to different sections quickly. This feature also allows for customization of the outline’s location within the user interface, catering to different user preferences for workspace layout.

[Feature page](#ckeditor5/latest/features/document-outline.html)

#### Page utilities

CKEditor 5 Page Utilities enables users to dictate the structuring and print formatting of their documents effectively.

#### Pagination

The Pagination feature visually indicates where pages begin and end within a document. This feature is designed to assist users in preparing their documents for printing or export to various document formats, ensuring that the transition between pages is seamless and accurately reflected in the final output. Users may adjust content distribution across pages as they like, ensuring well-organized documents with presented content, whether in digital form or print. By providing a clear view of how text and elements will appear page-by-page, Pagination aids in the creation of professional and polished documents.

[Feature page](#ckeditor5/latest/features/pagination/pagination.html)

#### Table of contents

The Table of Contents feature is a dynamic tool for organizing documents. It allows for the insertion of a linked table of contents that automatically updates in real time as the document’s content changes. This means changes made to headings or structured sections within the document are reflected immediately in the table of contents, accurately representing the document structure.

[Feature page](#ckeditor5/latest/features/table-of-contents.html)

### Productivity

Speed up the content creation process with dedicated productivity utilities. The CKEditor AI feature brings generation, summarization, correction, translation, contextual chat help, reviews, and many other capabilities right into the editor.

#### CKEditor AI

By integrating AI writing assistance directly into the editing experience, CKEditor AI empowers authors with real-time AI writing support, streamlines content creation, and enhances editorial workflows across a wide range of use cases – from productivity boosts and proof-reading to content quality and consistency.

#### AI Assistant (legacy)

The AI Assistant feature enhances editing efficiency and creativity with artificial intelligence capabilities. It allows users to generate new content and process data through custom queries or utilize a set of predefined commands that are also customizable. The feature supports integration with multiple AI API providers: OpenAI, Azure OpenAI, and Amazon Bedrock. You can also integrate it with custom models.

[Feature page](#ckeditor5/latest/features/ai/ai-assistant/ai-assistant-overview.html)

#### Automation

Automate your workflow with CKEditor 5 automation tools, regardless of whether you write, link, or save!

#### Case change

The Case Change feature simplifies adjusting text cases within a document. With just a single click, users can shift text between UPPERCASE, lowercase, and Title Case options. The case transformation can be applied to various text blocks (paragraph, heading, or list item) by placing the cursor within the block. Alternatively, users can select a specific fragment of text they wish to modify. This feature enhances the editing workflow by removing the need for manual case adjustments.

[Feature page](#ckeditor5/latest/features/case-change.html)

#### Emoji

The Emoji feature lets you insert emojis into the document from the editor toolbar, or on the go while writing the content.

[Feature page](#ckeditor5/latest/features/emoji.html)

#### Find and replace

The Find and Replace feature in CKEditor 5’s Productivity tools allows you to search for words or phrases in your document and replace them with different text. This function helps speed up editing and maintain content consistency.

[Feature page](#ckeditor5/latest/features/find-and-replace.html)

#### Format painter

The Format Painter feature lets users clone formatting from one section and apply it to others within a document. This tool speeds up maintaining style consistency across the document. Once initiated, Format Painter can continue to apply the copied formatting to multiple sections consecutively. This “continuous painting” ensures a uniform style is achieved quickly without the need to repeatedly select the formatting options for each new section.

[Feature page](#ckeditor5/latest/features/format-painter.html)

#### Fullscreen mode

The fullscreen mode lets you temporarily expand the editor to the whole browser viewport, giving you more space to comfortably edit content and use editor’s UI features.

[Feature page](#ckeditor5/latest/features/fullscreen.html)

#### Keyboard shortcuts

CKEditor 5 supports various keyboard shortcuts that boost productivity and provide necessary accessibility to screen reader users.

[Feature page](#ckeditor5/latest/features/accessibility.html--keyboard-shortcuts)

#### MathType

Math Equations allows you to add properly formatted mathematical notation and chemical formulas to your documents. This feature supports the inclusion of math equations, which can be handwritten on a tablet and automatically converted into well-formed digital text. It also offers simple numbering of equations and the ability to customize with various fonts and colors, enhancing readability and presentation in your content.

[Feature page](#ckeditor5/latest/features/math-equations.html)

#### Merge fields

Merge Fields allows the inclusion of placeholders in your content, facilitating the creation of document templates, especially useful for email templates and document automation. These placeholders can later be replaced with dynamic values by the customer’s application, enabling tasks like mass email distribution or generation of personalized documents.

[Feature page](#ckeditor5/latest/features/merge-fields.html)

#### Paste from Google Docs

Paste from Google Docs allows you to paste content from Google Docs and preserve its original structure and formatting.

[Feature page](#ckeditor5/latest/features/pasting/paste-from-google-docs.html)

#### Paste from Office

Paste from Office features let you paste content from Microsoft Word and Microsoft Excel and preserve its original structure and formatting. This is the basic, open-source Paste from Office feature.

[Feature page](#ckeditor5/latest/features/pasting/paste-from-office.html)

#### Enhanced paste from Office

The Enhanced Paste from Word/Excel feature accurately retains formatting and structure when content is pasted from Microsoft Word documents into the editor. This includes preserving text styles, lists, tables, and layouts. The feature facilitates the transfer of documents from Word to CKEditor 5 without compromising on formatting.

[Feature page](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html)

#### Paste plain text

The Paste as Plain Text feature strips formatting from the pasted text. This feature ensures that text pasted into the document adopts the style of the surrounding content, effectively described as “pasting without formatting.” Additionally, it intelligently converts double-line breaks into paragraphs and single-line breaks into soft breaks, aiding in maintaining the structural integrity of the document.

[Feature page](#ckeditor5/latest/features/pasting/paste-plain-text.html)

#### Slash commands

The Slash Commands feature lets users insert block elements and apply styles using just the keyboard. By pressing the / key, a panel with suggested commands appears, enabling quick and mouse-free actions. Users can filter through these commands by typing additional phrases after the /, making it easier to find specific commands. Additionally, the option to customize personal commands is available, allowing for a tailored editing experience.

[Feature page](#ckeditor5/latest/features/slash-commands.html)

#### Special characters

The Special Characters feature lets you insert a variety of unique symbols and characters into your document. This includes mathematical operators, currency symbols, punctuation, graphic symbols like arrows or bullets, and Unicode letters that are not typically available on standard keyboards, such as umlauts or diacritics. Additionally, the feature supports the insertion of emojis. This tool is particularly useful for enhancing the detail and accuracy of content that requires specialized symbols.

[Feature page](#ckeditor5/latest/features/special-characters.html)

#### Templates

The Templates feature enables the insertion of predefined content structures into documents, ranging from small content pieces, like formatted tables, to complete document frameworks, like formal letter templates. Templates accelerate the document creation process while ensuring adherence to the company’s content and document policies.

[Feature page](#ckeditor5/latest/features/template.html)

### Configurations

Configure CKEditor 5 to your liking. Choose the editor type, modify the toolbar, and select a language from our translated language packs.

#### Editor placeholder

You can prompt the user to input content by displaying a configurable placeholder text when the editor is empty. This works similarly to the native DOM placeholder attribute used by inputs. Not to be confused with content placeholder.

[Feature page](#ckeditor5/latest/features/editor-placeholder.html)

#### Editor UI types

The editor’s user interface is dependent on the editor types. The editor provides functionality through specialized features accessible via a configurable toolbar or keyboard shortcuts. Some of these features are only available with certain editor types.

#### Email editing

CKEditor 5 provides a wide variety of tools and functions for editing almost any kind of content. This includes a wide array of tools and solutions to make email editing easier and more compatible with various email clients.

#### Professionally translated language packs

CKEditor 5 provides 38 professionally translated language options, along with additional languages provided by community translations. CKEditor 5 also supports right-to-left (RTL) languages natively. When an RTL language is selected, the editor automatically adjusts its interface, including elements like toolbars, dropdowns, and buttons, to ensure an optimal editing experience.

[Feature page](#ckeditor5/latest/getting-started/setup/ui-language.html)

#### Toolbar and menus

The Toolbar Configuration feature provides different toolbar interfaces for editing content. The default toolbar includes dropdown menus and buttons for various editing functions. The Balloon Toolbar appears when text is selected, showing relevant tools. The Block Toolbar is accessed by clicking a button on the left-hand side of the editor, providing tools for the active block of content. Additionally, the Multiline Toolbar option allows for the expansion of the standard toolbar over multiple lines to display more tools simultaneously.

#### Watchdog

The watchdog utility protects you from data loss in case the editor crashes. It saves your content just before the crash and creates a new instance of the editor with your content intact.

[Feature page](#ckeditor5/latest/features/watchdog.html)

### Compliance

Make your content accessible to any person or restrict it to specific users.

#### Accessibility support

CKEditor 5 includes accessibility functionality designed to ensure content is accessible to all users. These features encompass keyboard navigation for easier content access without a mouse, screen reader compatibility facilitated by ARIA attributes, and semantic output markup for clearer interpretation of content structures. CKEditor 5 meets the requirements of the Web Content Accessibility Guidelines (WCAG) 2.2 at levels A and AA, as well as Section 508 of the Rehabilitation Act, as detailed in the Accessibility Conformance Report, ensuring broad accessibility compliance.

[Feature page](#ckeditor5/latest/features/accessibility.html)

#### Read-only support

The Read-Only Mode feature enables content to be locked from editing while still allowing it to be viewed. This mode is often used for restricting editing access based on user roles, allowing only specific users or groups to view the content without being able to modify it. Common uses include viewing sensitive documents like financial reports, software logs, or copyrighted stories that should not be altered but need to be accessible for copying or by screen readers. This mode can be toggled on and off by system triggers.

[Feature page](#ckeditor5/latest/features/read-only.html)

#### Restricted editing

The Restricted Editing feature allows some sections of a document to be designated as non-editable while others remain editable. This feature supports two modes: the standard editing mode, where all content can be edited, and the restricted editing mode, where users can only modify parts of the content that are specifically marked as editable. This functionality is useful for workflows where one group of users creates document templates that include protected sections, and a second group fills in editable details such as names, dates, or product names without altering the rest of the document.

[Feature page](#ckeditor5/latest/features/restricted-editing.html)

#### Text Part Language

The Text Part Language feature allows users to specify the language of individual sections of text. This capability helps in creating documents that include multiple languages by ensuring that browsers and screen readers correctly interpret each part according to its designated language. This feature is particularly valuable for content that contains text in varying directions, such as an English document with Arabic citations. It supports the WCAG 3.1.2 Language of Parts specification, facilitating the creation of more accessible and comprehensible multilingual content.

[Feature page](#ckeditor5/latest/features/language.html)

#### Word and character counter

The Word and Character Count feature provides a real-time tracking tool for monitoring the number of words and characters within the editor. This functionality assists in managing content length and ensuring it meets specific requirements or limits.

[Feature page](#ckeditor5/latest/features/word-count.html)

#### WProofreader

The Spelling and Grammar Checker is a proofreading tool that supports over 80 languages and dialects. It checks spelling and grammar in real time and through a separate dialog. Features include spelling autocorrect, text autocomplete, and suggestions that appear on hover. Users can create custom dictionaries for specific terms related to their brand or company. The tool is compliant with WCAG 2.1 and Section 508 accessibility standards. It also detects sentence-level errors and offers context-based correction suggestions.

[Feature page](#ckeditor5/latest/features/spelling-and-grammar-checking.html)

### Customization

Customize your editor even further. Use components and helpers from our UI library to create a UI that will match your design system.

#### Editor SDK

Select from numerous toolbar styles and over 100 plugins to tailor an editor that perfectly fits your requirements, all without needing any development expertise. For those looking to go further, the CKEditor API enables the creation of custom plugins or modification of the editor’s functionality. To assist the development process, dedicated resources such as a package generator and the CKEditor 5 Inspector - a comprehensive suite of debugging tools - are provided, helping accelerate development work.

#### Themes

Customize the editor theme to match your design needs.

[Feature page](#ckeditor5/latest/framework/deep-dive/ui/theme-customization.html)

#### UI Library

The standard UI library of CKEditor 5 is @ckeditor/ckeditor5-ui. It provides base classes and helpers that allow for building a modular UI that seamlessly integrates with other components of the ecosystem.

[Feature page](#ckeditor5/latest/framework/architecture/ui-library.html)

### File management

Upload and manage your files using file management features. Take advantage of CKBox, our file management solution, or create your own using an adapter.

#### Base64 Upload Adapter

Convert inserted images into Base64-encoded strings in the editor output. Images are stored with other content in the database without server-side processing.

[Feature page](#ckeditor5/latest/features/images/image-upload/base64-upload-adapter.html)

#### CKBox

Securely upload, store, edit, and utilize your images and files in CKEditor 5. Simplify media discovery in your uploads with the media browser alongside an intuitive Image Editor for image adjustments. Designed to facilitate organization, CKBox enables integrations, maintains permissions, and uses Workspaces to categorize files according to the user, document, or customer. It guarantees fast loading and optimal display of your images across devices through an efficient CDN. Deployable on-premises or as cloud SaaS.

[Feature page](#ckeditor5/latest/features/file-management/ckbox.html)

#### CKFinder

The CKFinder feature lets you insert images and links to files into your content. CKFinder is a powerful file manager with various image editing and image upload options.

[Feature page](#ckeditor5/latest/features/file-management/ckfinder.html)

#### Custom Upload Adapter

Have your own file management solution? Use this adapter to integrate your preferred software with CKEditor.

[Feature page](#ckeditor5/latest/features/images/image-upload/custom-upload-adapter.html)

#### Simple Upload Adapter

Upload images to your server using the XMLHttpRequest API with a minimal editor configuration.

[Feature page](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html)

#### Uploadcare

Upload, store, transform, optimize, and deliver images, videos, and documents with this cloud-based file handler. Upload media from local storage, web cameras, cloud services, and social networks with automated media optimization through a CDN for responsive image delivery. Popular features include adaptive image quality, automated image format conversion, progressive JPEG, and options for preview, resize, stretch, crop, content-aware crop, and setting fill color.

[Feature page](https://uploadcare.com/)

<a id="ckeditor5/latest/features/file-management/ckbox.html">source file: "ckeditor5/latest/features/file-management/ckbox.html"</a>

## CKBox file manager

CKBox is a dedicated asset manager and management platform service that provides a comprehensive digital asset management experience for CKEditor 5.

It handles file uploads and significantly reduces the effort required to build a complete modern editing solution that supports optimized and [responsive images](#ckeditor5/latest/features/images/images-responsive.html). Functionally, CKBox replaces the basic CKEditor 5 image upload feature by integrating a comprehensive file manager.

### Demo

**CKEditor 5 addon**

This demo presents a limited set of features. Visit the [feature-rich editor example](../../examples/builds-custom/full-featured-editor.html) to see more in action.

**Upload widget**

**Standalone application**

### How CKBox enhances CKEditor 5

CKBox streamlines the entire media content lifecycle from uploading and storing to management and display. By integrating CKBox, you enhance editing and accelerate content creation for your team.

CKBox works natively with CKEditor 5. Implementation is straightforward, saving you time and money.

#### Before you start

> **Note**
>
> This is a premium feature. [Contact us](https://ckeditor.com/contact/?sales=true#contact-form) to receive an offer tailored to your needs.\
> You can also sign up for the [CKEditor Premium Features 14-day free trial](https://portal.ckeditor.com/checkout?plan=free) to test the feature.\
> If you already have a valid license, please log into your [Customer Portal](https://portal.ckeditor.com/) to access the feature settings.

#### Key features

| CKEditor 5 Integration Capabilities | Details                                                                                                                                                                                                                                     |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Effortless Uploads                  | Enables drag and drop uploads of images and files directly into CKEditor 5, as well as image pasting from the clipboard, Word, and Google Docs.                                                                                             |
| Image Editing                       | Provides an intuitive image editor for basic operations such as cropping, resizing, and rotating. Basic editing capabilities (crop, resize, rotate, flip) are available directly from the image contextual toolbar for CKBox-served images. |
| Management UI                       | Adds a dedicated toolbar button to open the CKBox UI for managing and reusing uploaded files. Non-embeddable files (such as PDF) are inserted as links automatically.                                                                       |
| Asset Separation                    | Supports multi-tenant workspaces to separate assets per user, document, or customer.                                                                                                                                                        |
| User Experience and SEO             | CKBox simplifies the use of responsive images served from a CDN, improving loading times, boosting SEO, and increasing conversions.                                                                                                         |
| Bandwidth Savings                   | Out-of-the-box support for the most modern image formats, CKBox can save up to 90% of bandwidth if your application does not yet support responsive images, or up to 34% compared to relying on responsive JPG/PNG images.                  |
| Security and Administration         | Manage asset security and compliance using configurable permissions across workspaces, categories, and user groups.                                                                                                                         |

With CKBox you no longer need to write server-side code to upload and scale images or manage uploaded files.

### Hosting options

CKBox offers significant architectural flexibility, providing users with full control of their data by supporting diverse deployment scenarios. CKBox is available for both cloud (SaaS) and on-premises (self-hosted) installation:

| Option                           | Benefits                                                                                                                                                                                                                                                                                                                               |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| SaaS                             | Offers hassle-free, maintenance-free usage. We manage the cloud infrastructure to keep it secure and up-to-date, perform regular backups of your files, ensure automatic scaling, and guarantee maximum security and high availability. Assets are served via a secure and blazing-fast CDN.                                           |
| On-premises Option (Self-Hosted) | Allows you to host CKBox yourself. It can be installed anywhere, including AWS, Azure, Google Cloud, or your own data center. It runs with any Open Container runtime tool (for example: Kubernetes, Docker, OpenShift, Podman) and supports various storage types like S3, Azure Blob Storage, MySQL, Postgres, and local filesystem. |

To find out more about CKBox, the brand-new file manager and image editor, visit the [CKBox website](https://ckeditor.com/ckbox/) and read the dedicated [CKBox documentation page](#ckbox/latest/guides/index.html).

You can read more about the storage options in the dedicated [CKBox Deployment](#cs/latest/onpremises/ckbox-onpremises/deployment.html) guide.

### Installation

CKBox offers two primary methods for loading the library: using a Content Delivery Network (CDN) for fast, script-based integration, or using a Package Manager (npm/yarn) for modern application bundles.

#### Method 1: Installation from CDN

The easiest way to load the CKBox library is to include the following `<script>` tag in your HTML header that points to the CKBox CDN, ensuring it loads before the rich text editor:

```html
<script src="https://cdn.ckbox.io/ckbox/2.13.0/ckbox.js"></script>
```

When referencing the CKBox library via CDN, you must specify the version number (for example: `2.13.0` or `latest`).

> **Note**
>
> While the ability to use the shorthand `latest` tag instead of a specific version number is available, it is strongly advised against. The use of the latest tag may inadvertently introduce breaking changes into your application, which could cause your CKBox integration to stall unexpectedly.

Suppose you wish to change the default language of the CKBox, which supports over 40 official translations. In that case, you must ensure you load the corresponding translation file after loading the main CKBox library. For example, to load the Spanish translation (es):

```html
<script src="https://cdn.ckbox.io/ckbox/2.13.0/ckbox.js"></script>
<script src="https://cdn.ckbox.io/ckbox/2.13.0/translations/es.js"></script>
```

Once imported, you can use it within your application:

```html
<!DOCTYPE html>
<html>
    <head>
        <link rel="stylesheet" href="https://cdn.ckeditor.com/ckeditor5/48.4.0/ckeditor5.css">
    </head>
    <body>
        <div id="editor"></div>
        <script src="https://cdn.ckeditor.com/ckeditor5/48.4.0/ckeditor5.umd.js"></script>
        <script src="https://cdn.ckbox.io/ckbox/2.13.0/ckbox.js"></script>
        <script>
            const { ClassicEditor, LinkEditing, Image, ImageUpload, PictureEditing, CKBox, CKBoxImageEdit, CloudServices } = CKEDITOR;

ClassicEditor
                .create( {
                    licenseKey: '<YOUR_LICENSE_KEY>',
                    plugins: [ LinkEditing, Image, PictureEditing, ImageUpload, CloudServices, CKBox, CKBoxImageEdit /* ... */ ],
                    toolbar: [ 'imageUpload', 'ckbox', 'ckboxImageEdit' /* ... */ ], // Depending on your preference.
                    ckbox: {
                        // Configuration.
                    }
                } )
                .then( /* ... */ )
                .catch( /* ... */ );
        </script>
    </body>
</html>
```

#### Method 2: Installation from npm

For applications using modern bundling tools (such as Webpack or Vite) and package managers (npm, yarn, pnpm), CKBox components should be installed as dependencies and imported into your CKEditor 5 build.

> **Note**
>
> CKBox is a premium feature. Using the self-hosted distribution channel (npm) requires having an appropriate commercial plan or a Custom plan that permits the use of the editor via npm or a ZIP package.
>
> You can [sign up](https://portal.ckeditor.com/checkout?plan=free) for the CKEditor Premium Features 14-day free trial to test the feature. If you already have a license, you should log into your [Customer Portal Dashboard](https://portal.ckeditor.com/signin) to access feature settings and credentials.

First, install the necessary dependencies:

```bash
npm install ckeditor5 ckbox
```

Once the packages are installed, you can import the necessary modules directly into your application code and use them within your application:

```js
import { ClassicEditor, Image, ImageUpload, LinkEditing, PictureEditing, CKBox, CKBoxImageEdit, CloudServices } from 'ckeditor5';
import * as ckbox from 'ckbox';
import 'ckeditor5/ckeditor5.css';
import 'ckbox/dist/styles/ckbox.css';

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>',
        plugins: [ LinkEditing, Image, PictureEditing, ImageUpload, CloudServices, CKBox, CKBoxImageEdit, /* ... */ ],
        toolbar: [ 'imageUpload', 'ckbox', 'ckboxImageEdit', /* ... */ ], // Depending on your preference.
        ckbox: {
            // Configuration.
            tokenUrl: '<YOUR_TOKEN_URL>'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Configuration

The feature can be configured via the [`config.ckbox`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html) object.

#### Defining upload categories

By default, the CKBox feature maps the uploaded image type to the category configured on the cloud service. You can override this behavior and provide your own mappings via the [`config.ckbox.defaultUploadCategories`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-defaultUploadCategories) configuration option. It is an object where the keys define categories, and their values are the types of images that will be uploaded to these categories. The categories might be referenced either by their name or by their ID. Referencing by ID is future-proof because it will not require configuration changes when a category name changes.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            defaultUploadCategories: {
                Bitmaps: [ 'bmp' ],
                Pictures: [ 'jpg', 'jpeg' ],
                Scans: [ 'png', 'tiff' ],
                // The category below is referenced by its ID.
                'fdf2a647-b67f-4a6c-b692-5ba1dc1ed87b': [ 'gif' ]
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

If you define your own upload category mappings for a particular image type, only your first found category will be taken into account while finding the appropriate category for the uploaded image. Category mappings configured on the server will not be searched in that case. The image will not be uploaded (and hence inserted into the editor) in the following cases:

* If you have defined your own category mapping in `defaultUploadCategories` for the uploaded image type:

* The category does not exist on the server.
  * The category exists on the server, but the server configuration does not allow the uploaded image type.

* If you have not defined your own category mapping in `defaultUploadCategories` for the uploaded image type:
  * There is no category mapping for the uploaded image type on the server.

#### Defining default upload workspace

The [CKBox workspaces](#ckbox/latest/features/file-management/workspaces.html) provide a convenient solution for achieving data isolation and user separation within CKBox. With workspaces, you can easily create separate storage and data spaces, giving you precise control over assigning specific users, user groups, or tenants to each workspace.

If the user is assigned to more than one workspace, by default all the files uploaded directly from CKEditor are located in the first workspace in the list of workspaces allowed in the user’s JWT token. This corresponds to uploads through drag and drop into the editor area, pasting images from the clipboard, or images uploaded using the Image feature. If you would like to define a specific workspace for files uploaded this way, you can define its ID in the `defaultUploadWorkspaceId` option. After that, all the files uploaded directly from CKEditor will be placed in the specified workspace.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            tokenUrl: 'https://your.token.url',
            // Sample workspace referenced by its ID.
            defaultUploadWorkspaceId: [ 'pHUSQFj_QIvc' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

You can obtain the list of available workspaces using the [Workspaces REST API](#ckbox/latest/features/file-management/workspaces.html--managing-workspaces-with-the-rest-api).

#### Adding the ID for inserted assets

After choosing an asset from the CKBox dialog, it is inserted into the editor content with a unique `data-ckbox-resource-id` attribute. If you want to disable it and do not want to add this attribute, set the [`config.ckbox.ignoreDataId`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-ignoreDataId) option to `true`:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            ignoreDataId: true
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Changing the language

By default, the CKBox dialog takes the current language from the editor. If you want to use a different language, you can set the language code in the [`config.ckbox.language`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-language) option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            language: 'es'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Also, make sure to include the translation file after loading the CKBox library:

```html
<script src="https://cdn.ckbox.io/ckbox/2.13.0/ckbox.js"></script>
<script src="https://cdn.ckbox.io/ckbox/2.13.0/translations/es.js"></script>
```

#### Providing the token URL

The CKBox feature requires the token endpoint URL configured in the [`config.ckbox.tokenUrl`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-tokenUrl) key. If not explicitly provided, the token URL from [`config.cloudServices.tokenUrl`](../../api/module_cloud-services_cloudservicesconfig-CloudServicesConfig.html#member-tokenUrl) is used instead. If both are provided, the token URL defined in `config.ckbox.tokenUrl` takes precedence over the `config.cloudServices.tokenUrl`.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            tokenUrl: 'https://example.com/cs-token-endpoint'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuring the API service

Using the CKBox cloud service, you should configure the base URL of the API service via the [`config.ckbox.serviceOrigin`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-serviceOrigin) option. The default region is United States (Northern Virginia).

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            serviceOrigin: 'https://api.ckbox.io'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

If you are using the EU cloud region instead, remember to adjust the endpoint:

```js
ckbox: {
    serviceOrigin: 'https://api-eu.ckbox.io'
}
```

#### Editing external images

If you want to allow CKBox to edit external images, not hosted by the file manager (for example, pasted via URL) you need to whitelist the URLs of the images. You can do this using the [`config.ckbox.allowExternalImagesEditing`](../../api/module_ckbox_ckboxconfig-CKBoxConfig.html#member-allowExternalImagesEditing) option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckbox: {
            allowExternalImagesEditing: [ 'origin', /^cksource.com/ ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The image is editable if this option is:

* a regular expression and it matches the image URL, or
* a custom function that returns true for the image URL, or
* `origin` literal and the image URL is from the same origin, or
* an array of the above and the image URL matches one of the array elements.

> **Warning**
>
> Make sure that the domains you whitelist have CORS enabled, allowing to fetch the images from that domain. If you whitelist a domain without proper CORS configuration, you will get errors from the editor.

### Common API

The [`CKBox`](../../api/module_ckbox_ckbox-CKBox.html) plugin registers:

* The `'ckbox'` UI button component for CKBox asset manager.
* The `'ckbox'` command implemented by the [`CKBoxCommand`](../../api/module_ckbox_ckboxcommand-CKBoxCommand.html).

You can open CKBox by executing the following code:

```js
editor.execute( 'ckbox' );
```

If you want to use the CKBox editing capabilities straight from the editor, the plugin will also register the following:

* The `'ckboxImageEdit'` UI button component for the CKBox image editor.
* The `'ckboxImageEdit'` command implemented by the [`CKBoxImageEdit`](../../api/module_ckbox_ckboximageedit-CKBoxImageEdit.html).

### REST API

The CKBox REST API allows managing files and configuration of the drive. Read the [REST API documentation](https://api.ckbox.io/api/docs) to find out how to employ it in your implementation.

### What’s next

Be sure to check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) guide to learn more about different ways of uploading images in CKEditor 5.

See the [image feature](#ckeditor5/latest/features/images/images-overview.html) guide to find out more about handling images in CKEditor 5 in general.

> **Warning**
>
> Need more functionality? [Take a survey and help us develop CKBox to suit your needs better!](https://www.surveymonkey.com/r/MG97W8S)

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-ckbox>.

<a id="ckeditor5/latest/features/file-management/ckfinder.html">source file: "ckeditor5/latest/features/file-management/ckfinder.html"</a>

## CKFinder file manager

The CKFinder feature lets you insert images and links to files into your content. CKFinder is a powerful file manager with various image editing and image upload options.

### Demos

#### Image upload only

This demo shows the integration where the file manager’s server connector handles [image upload](#ckeditor5/latest/features/file-management/ckfinder.html--configuring-the-image-upload-only) only:

* Paste an image directly into the editor. It will be automatically uploaded using the server-side connector.
* Use the insert image button in the toolbar to insert an image.

#### Full integration

This demo shows the [full integration](#ckeditor5/latest/features/file-management/ckfinder.html--configuring-the-full-integration) with the CKFinder file uploader:

* Paste an image directly into the editor. It will be automatically uploaded using the server-side connector.
* Use the insert image or file button in the toolbar to open the CKFinder file manager. Then insert an image or a link to any other file.

> **Note**
>
> These demos present a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The CKFinder integration feature is a bridge between the CKEditor 5 WYSIWYG editor and the [CKFinder](https://ckeditor.com/ckfinder) file manager and uploader. CKFinder is a commercial application designed with CKEditor compatibility in mind. It is available as version 3.x for PHP, ASP.NET, and Java and version 2.x for ASP and ColdFusion.

You can use this feature in the rich-text editor in two different ways:

* [**As a server-side connector only**](#ckeditor5/latest/features/file-management/ckfinder.html--configuring-the-image-upload-only) ([demo](#ckeditor5/latest/features/file-management/ckfinder.html--image-upload-only)). In this scenario, images dropped or pasted into the editor are uploaded to the CKFinder server-side connector running on your server.

* [**As a server and client-side file manager integration**](#ckeditor5/latest/features/file-management/ckfinder.html--configuring-the-full-integration) ([demo](#ckeditor5/latest/features/file-management/ckfinder.html--full-integration)). Images dropped or pasted directly into the editor are uploaded to the server (just like in the first option).

There are more cool features available, for instance:

* **Uploading** using the full user interface.
  * Uploading **multiple files** at once.
  * **Browsing** previously uploaded images.
  * **Editing** images (cropping, resizing, etc.).
  * **Organizing** or deleting images.

Check out the [CKFinder file manager website](https://ckeditor.com/ckfinder/) to learn more about the features you can use in your project.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

#### From npm

```js
import { ClassicEditor, CKFinder, CKFinderUploadAdapter } from 'ckeditor5';

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>',
        plugins: [ CKFinder, CKFinderUploadAdapter, /* ... */ ],
        toolbar: [ 'ckfinder', 'uploadImage', /* ... */ ], // Depending on your preference.
        ckfinder: {
            // Configuration.
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### From CDN

> **Note**
>
> The `ckfinder.js` script exposes a global variable named `window.CKFinder`. Use an alias for the `CKFinder` import to avoid naming conflicts.

```js
const { ClassicEditor, CKFinder: CKFinderPlugin, CKFinderUploadAdapter } = CKEDITOR;

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>',
        plugins: [ CKFinderPlugin, CKFinderUploadAdapter, /* ... */ ],
        toolbar: [ 'ckfinder', 'uploadImage', /* ... */ ], // Depending on your preference.
        ckfinder: {
            // Configuration.
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Configuration

The feature is configurable by using the [`config.ckfinder`](../../api/module_ckfinder_ckfinderconfig-CKFinderConfig.html) object.

#### Configuring the image upload only

This feature can upload images automatically to the server (for example, when the user drops an image into the content) thanks to the [CKFinder upload adapter](../../api/module_adapter-ckfinder_uploadadapter-CKFinderUploadAdapter.html). All it requires is the correct [`config.ckfinder.uploadUrl`](../../api/module_ckfinder_ckfinderconfig-CKFinderConfig.html#member-uploadUrl) path.

Assuming that you [installed the CKFinder PHP server-side connector](https://ckeditor.com/docs/ckfinder/ckfinder3-php/quickstart.html#quickstart_installation_folders) (and it is available under `https://example.com/ckfinder/`), use the following [quick upload](https://ckeditor.com/docs/ckfinder/ckfinder3-php/commands.html#command_quick_upload) command URL to enable the image upload:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckfinder: {
            // Upload the images to the server using the CKFinder QuickUpload command.
            uploadUrl: 'https://example.com/ckfinder/core/connector/php/connector.php?command=QuickUpload&type=Images&responseType=json'
            }
        } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

See the **[demo of the image upload only](#ckeditor5/latest/features/file-management/ckfinder.html--image-upload-only)**.

#### Configuring the full integration

To use both the image upload functionality and the file manager user interface in your application, you must first load the CKFinder JavaScript library. Then enable the CKFinder integration in your rich-text editor instance.

The easiest way to load the CKFinder library is to include the `<script>` tag loading the `ckfinder.js` file first:

```html
<script src="https://example.com/ckfinder/ckfinder.js"></script>
```

Then:

* Make sure that the [CKFinder plugin](../../api/module_ckfinder_ckfinder-CKFinder.html) for CKEditor 5 is enabled. See the [Installation](#ckeditor5/latest/features/file-management/ckfinder.html--installation) section.

* To enable the automatic file upload to the server when an image is pasted or dropped into the editor content, set the correct [`config.ckfinder.uploadUrl`](../../api/module_ckfinder_ckfinderconfig-CKFinderConfig.html#member-uploadUrl) path.

* To display the toolbar button that opens the CKFinder file manager UI allowing the users to choose the files on the server, make sure that `'ckfinder'` is present in your [`config.toolbar`](../../api/module_core_editor_editorconfig-EditorConfig.html#member-toolbar).

* Additionally, you can use [`config.ckfinder.options`](../../api/module_ckfinder_ckfinderconfig-CKFinderConfig.html#member-options) to define [CKFinder’s options](https://ckeditor.com/docs/ckfinder/ckfinder3/#!/api/CKFinder.Config). For example:

* You can define [`options.resourceType`](https://ckeditor.com/docs/ckfinder/ckfinder3/#!/api/CKFinder.Config-cfg-resourceType) to tell CKFinder the specified resource type can be browsed when the user clicks the button.
  * You can define [`options.language`](https://ckeditor.com/docs/ckfinder/ckfinder3/#!/api/CKFinder.Config-cfg-language) to set the UI language of CKFinder. By default, it will be set to the UI language of the editor.

// Define the CKFinder configuration (if necessary).
            options: {
                resourceType: 'Images'
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

See the **[demo of the full integration](#ckeditor5/latest/features/file-management/ckfinder.html--full-integration)**.

##### Configuring the opener

You can change the way CKFinder opens using the [`config.ckfinder.openerMethod`](../../api/module_ckfinder_ckfinderconfig-CKFinderConfig.html#member-openerMethod) option.

By default, the file manager opens as a modal. To open it in a new pop-up window, set the configuration value to `popup`:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        ckfinder: {
            // Open the file manager in the pop-up window.
            openerMethod: 'popup'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuring allowed file types

You should configure the allowed file types that can be uploaded in two places:

* On the client side, in CKEditor 5, restricting image upload through the CKEditor 5 UI and commands
* On the server side, in CKFinder, restricting the file formats accepted in CKFinder

##### Client-side configuration

Use the [`image.upload.types`](../../api/module_image_imageconfig-ImageUploadConfig.html#member-types) configuration option to define the allowed image MIME types that the users can upload to CKEditor 5.

By default, users can upload `jpeg`, `png`, `gif`, `bmp`, `webp`, and `tiff` files, but you can customize this behavior to accept, for example, SVG files.

##### Server-side configuration

Use the `allowedExtensions` configuration option to define the file extension allowed to be uploaded with CKFinder for a particular resource type. Refer to the [relevant server-side connector documentation](#ckfinder/latest/index.html) to learn more.

### Common API

The [`CKFinder`](../../api/module_ckfinder_ckfinder-CKFinder.html) plugin registers:

* The `'ckfinder'` UI button component.

* The `'ckfinder'` command implemented by the [`CKFinderCommand`](../../api/module_ckfinder_ckfindercommand-CKFinderCommand.html).

You can open CKFinder by executing the following code:

```js
  editor.execute( 'ckfinder' );
  ```

Additionally, in the “image upload only” integration, you can use the following button and command registered by the [`ImageUpload`](../../api/module_image_imageupload-ImageUpload.html) plugin:

* The `'uploadImage'` UI button component.
* The `'uploadImage'` command implemented by the [`UploadImageCommand`](../../api/module_image_imageupload_uploadimagecommand-UploadImageCommand.html).

### What’s next

Check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) to learn more about different ways of uploading images in CKEditor 5.

See the [image feature guide](#ckeditor5/latest/features/images/images-overview.html) to find out more about handling images in CKEditor 5.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-ckfinder>.

<a id="ckeditor5/latest/features/file-management/uploadcare.html">source file: "ckeditor5/latest/features/file-management/uploadcare.html"</a>

## Uploadcare image uploader and editor

Uploadcare is a dedicated image manager supporting image upload and editing. The Uploadcare feature lets you easily upload images from various services like Dropbox, Facebook, Google Drive, Google Photos, or OneDrive and insert them into your content. It offers an image editor with multiple editing options, optimization capabilities and provides a [responsive images mechanism](#ckeditor5/latest/features/images/images-responsive.html) for CKEditor 5.

### How Uploadcare enhances CKEditor 5

As a full-fledged image uploader and editor, Uploadcare also replaces the basic CKEditor 5 image upload feature. It provides image upload and editing capabilities:

* Enables images upload directly from services like Dropbox, Facebook, Google Drive, Google Photos, OneDrive.
* Enables images upload from local machine and directly via external URL.
* Enables drag & drop uploads of images.
* Transforms the _Image_ toolbar button, allowing the user to quickly upload and insert images.
* Adds a separate dedicated image toolbar button to quickly open image editor for selected image.
* Provides image editing capabilities like crop, resize, rotate, flip, apply filters, and adjust image parameters (like contrast, brightness, saturation).
* Uploadcare storage is powered by AWS S3 and you can use your own bucket.

With Uploadcare you no longer need to write a server-side code to upload and edit images.

To find out more about Uploadcare, visit the [Uploadcare website](https://uploadcare.com/).

> **Warning**
>
> Uploadcare is available as a premium add-on in CKEditor plans and cannot be linked to an existing Uploadcare account. If you need more details or assistance, [contact us](https://ckeditor.com/contact).

### Demo

To upload a file using Uploadcare, use the upload image toolbar button and choose the provider you want to upload from. You can choose more than one file at a time. Use the edit image button from the image contextual toolbar to edit the selected image.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

Image files are inserted into the content as images that you can drag around and resize.

You can also upload images by dragging them into your content. After you drag an image into the editor, it gets uploaded into the Uploadcare cloud storage and inserted into the content.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration.

The Uploadcare upload feature requires following image plugins to work correctly:

* [The `Image` feature](../../api/module_image_image-Image.html),
* [The `ImageUpload` feature](../../api/module_image_imageupload-ImageUpload.html),
* [The `ImageInsert` feature](../../api/module_image_imageinsert-ImageInsert.html),
* [The `PictureEditing` feature](../../api/module_image_pictureediting-PictureEditing.html).

Make sure to include them during editor setup:

**NPM**

```js
import { ClassicEditor, Image, ImageUpload, ImageInsert, PictureEditing } from 'ckeditor5';
import { Uploadcare } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Uploadcare, Image, ImageUpload, ImageInsert, PictureEditing, /* ... */ ],
		toolbar: [ 'ImageInsert', /* ... */],
		// Provide Uploadcare license key (see explanation below).
		uploadcare: {
			pubkey: 'YOUR_UPLOADCARE_KEY',
			// Further configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Image, ImageUpload, ImageInsert, PictureEditing } = CKEDITOR;
const { Uploadcare } = CKEDITOR_PREMIUM_FEATURES;

Further in the document, the dependency plugins will be omitted in code listings for clarity.

#### Adding image editing capabilities

To add image editor allowing to invoke it straight from the image contextual toolbar (available when an image is selected), the `UploadcareImageEdit` plugins needs to be loaded and added to the toolbar configuration.

> **Note**
>
> The Uploadcare image editor requires the [`ImageToolbar`](../../api/module_image_imagetoolbar-ImageToolbar.html) feature. Make sure it is loaded too.

**NPM**

```js
import { ClassicEditor, ImageToolbar } from 'ckeditor5';
import { Uploadcare, UploadcareImageEdit } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Uploadcare, UploadcareImageEdit, ImageToolbar, /* ... */ ],
		toolbar: [ ImageUpload, /* ... */],
		image: {
			toolbar: [ /* ... */ , 'uploadcareImageEdit' ]
		}
		// Provide Uploadcare license key (see explanation below).
		uploadcare: {
			pubkey: 'YOUR_UPLOADCARE_KEY',
			// Further configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, ImageToolbar } = CKEDITOR;
const { Uploadcare, UploadcareImageEdit } = CKEDITOR_PREMIUM_FEATURES;

Further in the document, the dependency plugins will be omitted in code listings for clarity.

#### Activating the feature

After you purchase a license, log into your Uploadcare customer dashboard to create a public API key, as explained in the [Uploadcare Project settings guide](https://uploadcare.com/docs/start/settings/#keys-public).

### Configuration

The feature can be configured via the [`config.uploadcare`](../../api/module_uploadcare_uploadcareconfig-UploadcareConfig.html) object.

#### Choosing services to upload from

Uploadcare feature allows uploading images from multiple external services - Dropbox, Facebook, Google Drive, Google Photos, OneDrive, and from local machine and external URLs. The list of allowed upload methods is configurable via [`config.uploadcare.uploader.sourceList`](../../api/module_uploadcare_uploadcareconfig-UploadcareUploaderConfig.html#member-sourceList).

Available options are:

* `dropbox`
* `facebook`
* `gdrive`
* `gphotos`
* `onedrive`
* `local`
* `url`

For example, to allow users to upload images from local computer, Dropbox and OneDrive, the configuration would look as below:

```js
ClassicEditor
    .create( {
        uploadcare: {
            uploader: {
                sourceList: [
                    'local',
                    'dropbox',
                    'onedrive'
                ]
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Editing external images

To enable Uploadcare to edit external images (not hosted by the Uploadcare service) you need to whitelist the URLs of the images. You can do this using the [`config.uploadcare.allowExternalImagesEditing`](../../api/module_uploadcare_uploadcareconfig-UploadcareConfig.html#member-allowExternalImagesEditing) option:

```js
ClassicEditor
    .create( {
        uploadcare: {
            allowExternalImagesEditing: [ 'origin', /^cksource.com/ ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The image is editable if this option is:

> **Note**
>
> Please keep in mind that when you edit any external image for the first time it will be automatically uploaded to the Uploadcare cloud. This is important to know, since it affects the quota usage.

#### Adjusting other configuration options

Uploadcare feature configuration directly exposes other Uploadcare configuration options, and those can be set via CKEditor 5 configuration directly. Please refer to official Uploadcare documentation to get familiar with all configuration options.

The configuration related to upload process should be set via [`config.uploadcare.uploader`](../../api/module_uploadcare_uploadcareconfig-UploadcareConfig.html#member-uploader) object:

```js
ClassicEditor
    .create( {
        uploadcare: {
            uploader: {
                cropPreset: '1:1',
                imageShrink: '800x600'
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Please see all available options in [the official Uploadcare documentation](https://uploadcare.com/docs/file-uploader/options/).

> **Warning**
>
> The `imgOnly`, `removeCopyright`, `localeName`, `confirmUpload`, `cameraMirror`, `cameraCapture`, `showEmptyList` options are not supported at all at the moment. Changing them will not have any effect. For locale configuration, use the `locale` option instead of `localeName`.

The configuration related to image editor should be set via [`config.uploadcare.editor`](../../api/module_uploadcare_uploadcareconfig-UploadcareConfig.html#member-editor) object:

```js
ClassicEditor
    .create( {
        uploadcare: {
            editor: {
                cropPreset: '5:4'
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Please see all available options in [the official Uploadcare documentation](https://uploadcare.com/docs/file-uploader/image-editor/#configuration).

#### Locale configuration

Since the Uploadcare integration plugin bases on an external component, it is necessary to make an extra step to provide translations for the Uploadcare component.

You can provide the translations using the [`config.uploadcare.locale`](../../api/module_uploadcare_uploadcareconfig-UploadcareConfig.html#member-locale) option.

The plugin automatically uses the editor’s language (`editor.locale.contentLanguage`) as the locale name. If the editor language is different from `'en'`, you need to provide translations for that language (see the examples below). The `locale` property is used only to supply translations that will be used by Uploadcare components.

For information on how to configure the editor’s language, see the [CKEditor 5 localization documentation](#ckeditor5/latest/framework/deep-dive/ui/localization.html).

##### Using CDN translations

Load pre-defined translations from Uploadcare CDN:

```js
// Dynamic import
ClassicEditor
    .create( {
        uploadcare: {
            pubkey: 'YOUR_UPLOADCARE_KEY',
            locale: () => import( 'https://cdn.jsdelivr.net/npm/@uploadcare/file-uploader@v1/locales/file-uploader/de.js' )
                .then( module => module.default )
        }
    } );

// Or static import
import deLocale from 'https://cdn.jsdelivr.net/npm/@uploadcare/file-uploader@v1/locales/file-uploader/de.js';

ClassicEditor
    .create( {
        uploadcare: {
            pubkey: 'YOUR_UPLOADCARE_KEY',
            locale: deLocale
        }
    } );
```

##### Using custom translations

Provide your own translation object:

```js
ClassicEditor
    .create( {
        uploadcare: {
            pubkey: 'YOUR_UPLOADCARE_KEY',
            locale: {
                'locale-id': 'de',
                'social-source-lang': 'de',
                'upload-file': 'Datei hochladen',
                'file__one': 'Datei',
                'file__other': 'Dateien',
                'header-uploading': 'Lade {{count}} {{plural:file(count)}} hoch',
                // More translations.
            }
        }
    } );
```

> **Note**
>
> For detailed information about Uploadcare locale definition format, available languages, and CDN translations, see the [Uploadcare localization documentation](https://uploadcare.com/docs/file-uploader/localization/).

### Common API

The [`Uploadcare`](../../api/module_uploadcare_uploadcare-Uploadcare.html) plugin registers:

* The `'uploadcare'` UI button component for uploading images.
* The `'uploadcare'` command implemented by the [`UploadcareCommand`](../../api/module_uploadcare_uploadcarecommand-UploadcareCommand.html).

You can open Uploadcare upload dialog by executing the following code:

```js
editor.execute( 'uploadcare' );
```

If you want to use the Uploadcare editing capabilities straight from the editor, the [`UploadcareImageEdit`](../../api/module_uploadcare_uploadcareimageedit-UploadcareImageEdit.html) plugin will register the following:

* The `'uploadcareImageEdit'` UI button component in the Image toolbar for the uploadcare image editor.
* The `'uploadcareImageEdit'` command implemented by the [`UploadcareImageEdit`](../../api/module_uploadcare_uploadcareimageedit-UploadcareImageEdit.html).

You can open Uploadcare image edit dialog by executing the following code:

```js
editor.execute( 'uploadcareImageEdit' );
```

### What’s next

See the [image feature](#ckeditor5/latest/features/images/images-overview.html) guide to find out more about handling images in CKEditor 5 in general.

<a id="ckeditor5/latest/features/find-and-replace.html">source file: "ckeditor5/latest/features/find-and-replace.html"</a>

## Find and replace

The find and replace feature lets you find and replace any text in your document. This speeds up your work and helps with the consistency of your content.

### Demo

Use the find and replace toolbar button to open the search dialog. Use it to find and replace words or phrases. You can also use the `Ctrl`/`Cmd`+`F` keyboard shortcut. Try replacing “AI” with “artificial intelligence” to make the content appeal to less tech-savvy users. Be careful to match the case!

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, FindAndReplace } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ FindAndReplace, /* ... */ ],
		toolbar: [ 'findAndReplace', /* ... */ ],
		findAndReplace: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, FindAndReplace } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ FindAndReplace, /* ... */ ],
		toolbar: [ 'findAndReplace', /* ... */ ],
		findAndReplace: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

#### Configuring the UI type

By default, the find and replace form displays inside a dialog. That allows for keeping it open while editing the document at the same time. Alternatively, you can display the feature in a dropdown. To do this, use the [`config.findAndReplace.uiType`](../api/module_find-and-replace_findandreplaceconfig-FindAndReplaceConfig.html) configuration option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        findAndReplace: {
            uiType: 'dropdown'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Related features

* [Automatic text transformation](#ckeditor5/latest/features/text-transformation.html) – Enables automatic turning of snippets such as `(tm)` into `™` and `"foo"` into `“foo”`.

### Common API

The [`FindAndReplace`](../api/module_find-and-replace_findandreplace-FindAndReplace.html) plugin registers the `'findAndReplace'` UI button component and the [`'find'`](../api/module_find-and-replace_findcommand-FindCommand.html), [`'findNext'`](../api/module_find-and-replace_findnextcommand-FindNextCommand.html), [`'findPrevious'`](../api/module_find-and-replace_findpreviouscommand-FindPreviousCommand.html), [`'replace'`](../api/module_find-and-replace_replacecommand-ReplaceCommand.html) and [`'replaceAll'`](../api/module_find-and-replace_replaceallcommand-ReplaceAllCommand.html) commands.

You can execute the commands using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Find all occurrences of a given text.
editor.execute( 'find', 'steam' );
```

You can also move the highlight through all matched results with the [`'findNext'`](../api/module_find-and-replace_findnextcommand-FindNextCommand.html) and [`'findPrevious'`](../api/module_find-and-replace_findpreviouscommand-FindPreviousCommand.html) commands:

```js
// Move the search highlight to the next match.
editor.execute( 'findNext' );
```

You can also replace all occurrences of a given text in the editor instance using the [`'replaceAll'`](../api/module_find-and-replace_replaceallcommand-ReplaceAllCommand.html) command:

```js
editor.execute( 'replaceAll', 'diesel', 'steam' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-find-and-replace>.

<a id="ckeditor5/latest/features/font.html">source file: "ckeditor5/latest/features/font.html"</a>

## Font family, size, and color

The font feature lets you change the font family, size, color, and background color. These are four separate plugins, so you can enable only the ones you need.

### Demo

Use the toolbar dropdowns in the demo below to control the font size and font family . You can also change both the font color and the font background color with predefined palette or color picker .

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The font styles, just like the [basic text styles](#ckeditor5/latest/features/basic-styles.html), can serve many purposes. You can apply the font size setting globally or to a selected part of the text to make it catch the eye of the reader. Using different font families can help differentiate between sections of the content that serve various purposes (like main text and a side quotation or a recap). Different font colors can work as markers and guides just like font background colors that stand out even more and draw attention.

The plugin enables the following features in the rich-text editor:

* [`FontFamily`](../api/module_font_fontfamily-FontFamily.html) – Change the font family by applying inline `<span>` elements with a `font-family` in the `style` attribute.
* [`FontSize`](../api/module_font_fontsize-FontSize.html) – Control the font size by applying inline `<span>` elements that either have a CSS class or a `font-size` in the `style` attribute.
* [`FontColor`](../api/module_font_fontcolor-FontColor.html) – Control the font color by applying inline `<span>` elements with a `color` in the `style` attribute.
* [`FontBackgroundColor`](../api/module_font_fontbackgroundcolor-FontBackgroundColor.html) – Control the font background color by applying inline `<span>` elements with a `background-color` in the `style` attribute.

> **Note**
>
> You can remove all font formatting with the [remove format](#ckeditor5/latest/features/remove-format.html) feature.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Font } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Font, /* ... */ ],
		toolbar: [ 'fontSize', 'fontFamily', 'fontColor', 'fontBackgroundColor', /* ... */ ]
		fontFamily: {
			// Configuration.
		}
		fontColor: {
			// Configuration.
		}
		// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Font } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Font, /* ... */ ],
		toolbar: [ 'fontSize', 'fontFamily', 'fontColor', 'fontBackgroundColor', /* ... */ ]
		fontFamily: {
			// Configuration.
		}
		fontColor: {
			// Configuration.
		}
		// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

You can also add just one or a selected few of the font features to your plugin list and the toolbar configuration:

**NPM**

```js
import { ClassicEditor, FontFamily } from 'ckeditor5';

ClassicEditor
	.create( {
		plugins: [ FontFamily, /* ... */ ],
		toolbar: [ 'fontFamily', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, FontFamily } = CKEDITOR;

ClassicEditor
	.create( {
		plugins: [ FontFamily, /* ... */ ],
		toolbar: [ 'fontFamily', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring the font family feature

You can configure which font family options are supported by the WYSIWYG editor. Use the [`config.fontFamily.options`](../api/module_font_fontconfig-FontFamilyConfig.html#member-options) configuration option to do so.

Use the special `'default'` keyword to use the default font family defined in the web page styles. It removes any custom font family.

For example, the following editor supports two font families besides the default one:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontFamily: {
            options: [
                'default',
                'Ubuntu, Arial, sans-serif',
                'Ubuntu Mono, Courier New, Courier, monospace'
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontFamily', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Accepting all font names

By default, all `font-family` values that are not specified in the `config.fontFamily.options` are stripped. You can enable support for all font names by using the [`config.fontFamily.supportAllValues`](../api/module_font_fontconfig-FontFamilyConfig.html#member-supportAllValues) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontFamily: {
            options: [
                // Font family configuration options are described in the "Configuring the font family feature" section.
                // ...
            ],
            supportAllValues: true
        },
        // More of editor's configuration.
        // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Configuring the font size feature

It is possible to configure which font size options are supported by the WYSIWYG editor. Use the [`config.fontSize.options`](../api/module_font_fontconfig-FontSizeConfig.html#member-options) configuration option to do so.

Use the special `'default'` keyword to use the default font size defined in the web page styles. It removes any custom font size.

The font size feature supports two ways of defining the configuration: using predefined (named) presets or simple numeric values.

#### Using the predefined presets

The font size feature defines 4 named presets:

* `'tiny'`
* `'small'`
* `'big'`
* `'huge'`

Each size is represented in the view as a `<span>` element with the `text-*` class. For example, the `'tiny'` preset looks as follows in the editor data:

```html
<span class="text-tiny">...</span>
```

The CSS definition for the classes (presets) must be included in the web page styles where the edited content is rendered.

Here is an example of the font size CSS classes:

```css
.ck-content .text-tiny {
    font-size: 0.7em;
}

.ck-content .text-small {
    font-size: 0.85em;
}

.ck-content .text-big {
    font-size: 1.4em;
}

.ck-content .text-huge {
    font-size: 1.8em;
}
```

An example of an editor that supports two font sizes:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontSize: {
            options: [
                'tiny',
                'default',
                'big'
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontSize', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Using numerical values

The font size feature also supports numerical values.

In this case, each size is represented in the view as a `<span>` element with the `font-size` style set in `px`. For example, `14` will be represented in the editor data as:

```html
<span style="font-size: 14px">...</span>
```

Here is an example of the WYSIWYG editor that supports numerical font sizes. Note that `'default'` is controlled by the default styles of the web page:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontSize: {
            options: [
                9,
                11,
                13,
                'default',
                17,
                19,
                21
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontSize', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Accepting all font sizes

By default, all `font-size` values that are not specified in the `config.fontSize.options` are stripped. You can enable support for all font sizes by using the [`config.fontSize.supportAllValues`](../api/module_font_fontconfig-FontSizeConfig.html#member-supportAllValues) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontSize: {
            options: [
                // Numerical values.
                // ...
            ],
            supportAllValues: true
        },
        // More of editor's configuration.
        // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> This option can be used only in combination with [numerical values](#ckeditor5/latest/features/font.html--using-numerical-values).

### Configuring the font color and font background color features

Both font color and font background color features are configurable and share the same configuration format.

> **Note**
>
> Please note that [font color](../api/module_font_fontcolor-FontColor.html) and [font background color](../api/module_font_fontbackgroundcolor-FontBackgroundColor.html) are separate plugins. They must be enabled and configured individually.

Check out the WYSIWYG editor below with both features customized using the editor configuration:

#### Specifying available colors

It is possible to configure which colors are available in the color dropdown. Use the [`config.fontColor.colors`](../api/module_font_fontconfig-FontColorConfig.html#member-colors) and [`config.fontBackgroundColor.colors`](../api/module_font_fontconfig-FontColorConfig.html#member-colors) configuration options to do so.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontColor: {
            colors: [
                {
                    color: 'hsl(0, 0%, 0%)',
                    label: 'Black'
                },
                {
                    color: 'hsl(0, 0%, 30%)',
                    label: 'Dim grey'
                },
                {
                    color: 'hsl(0, 0%, 60%)',
                    label: 'Grey'
                },
                {
                    color: 'hsl(0, 0%, 90%)',
                    label: 'Light grey'
                },
                {
                    color: 'hsl(0, 0%, 100%)',
                    label: 'White',
                    hasBorder: true
                },
                // More colors.
                // ...
            ]
        },
        fontBackgroundColor: {
            colors: [
                {
                    color: 'hsl(0, 75%, 60%)',
                    label: 'Red'
                },
                {
                    color: 'hsl(30, 75%, 60%)',
                    label: 'Orange'
                },
                {
                    color: 'hsl(60, 75%, 60%)',
                    label: 'Yellow'
                },
                {
                    color: 'hsl(90, 75%, 60%)',
                    label: 'Light green'
                },
                {
                    color: 'hsl(120, 75%, 60%)',
                    label: 'Green'
                },
                // More colors.
                // ...
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontColor', 'fontBackgroundColor', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Changing the geometry of the color grid

You can configure the number of columns in the color dropdown by setting the [`config.fontColor.columns`](../api/module_font_fontconfig-FontColorConfig.html#member-columns) and [`config.fontBackgroundColor.columns`](../api/module_font_fontconfig-FontColorConfig.html#member-columns) configuration options.

Usually, you will want to use this option when changing the number of [available colors](#ckeditor5/latest/features/font.html--specifying-available-colors).

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontColor: {
            colors: [
                // 9 colors defined here.
                // ...
            ]

columns: 3, // So, you can display them in 3 columns.

// Optional configuration of the number of document colors.
            // ...
        },
        fontBackgroundColor: {
            columns: 6,
            // Background color options.
            // ...
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontColor', 'fontBackgroundColor', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Documents colors

The font and font background color dropdowns contain the “Document colors” section. It lists the colors already used in the document for the users to be able to easily reuse them (for consistency purposes).

By default, the number of displayed document colors is limited to one row, but you can adjust it (or remove the whole section) by using the [`config.fontColor.documentColors`](../api/module_font_fontconfig-FontColorConfig.html#member-documentColors) or [`config.fontBackgroundColor.documentColors`](../api/module_font_fontconfig-FontColorConfig.html#member-documentColors) options.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontColor: {
            // Display 6 columns in the color grid.
            columns: 6,

// And 12 document colors (2 rows of them).
            documentColors: 12,

// Optional available font colors configuration.
            // ...
        },
        fontBackgroundColor: {
            // Remove the "Document colors" section.
            documentColors: 0,

// Background color options.
            // ...
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontColor', 'fontBackgroundColor', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Color picker

You can set colors from outside of the pre-configured palette using the “Color picker” option available at the bottom of the color selection dropdown.

Color picker applies colors in the **HSL** format as it is the default for the font color feature. You can change this using the [`config.fontColor.colorPicker.format`](../api/module_ui_colorpicker_utils-ColorPickerConfig.html) option. Available color formats are defined in the [`ColorPickerOutputFormat`](../api/module_ui_colorpicker_utils-ColorPickerOutputFormat.html) type. This change will not affect the color input – it always accepts only values given in the `hex` format (with or without the `#` sign at the beginning).

To turn off the color picker entirely for the given feature, set the [`config.fontColor.colorPicker`](../api/module_font_fontconfig-FontColorConfig.html#member-colorPicker) (or [`config.fontBackgroundColor.colorPicker`](../api/module_font_fontconfig-FontColorConfig.html#member-colorPicker)) option to `false`.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fontColor: {
            colorPicker: {
                // Use 'hex' format for output instead of 'hsl'.
                format: 'hex'
            }
        },
        fontBackgroundColor: {
            // Do not display the color picker.
            colorPicker: false
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'fontColor', 'fontBackgroundColor', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Email client color format compatibility

When designing content for emails, it is important to be aware that many email clients have limited support for various color formats. For maximum compatibility in email templates, consider the following limitations:

##### Unsupported color formats in most email clients:

* hsl
* hsla
* hwb
* lab
* lch
* oklab
* oklch
* color-mix
* rgba

##### Recommended color formats for email compatibility:

* Hexadecimal (for example, `#FF0000`)
* RGB (for example, `rgb(255, 0, 0)`)
* Named colors (for example, `red`)

Using these compatible formats will ensure your content displays consistently across different email clients.

### Related features

Here are some more CKEditor 5 features that can help you format your content:

* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – The essentials, like **bold**, _italic_, and others.
* [Styles](#ckeditor5/latest/features/style.html) – Apply pre-configured styles to existing elements in the editor content.
* [Text alignment](#ckeditor5/latest/features/text-alignment.html) – Because it does matter whether the content is left, right, centered, or justified.
* [Case change](#ckeditor5/latest/features/case-change.html) – Turn a text fragment or block into uppercase, lowercase, or title case.
* [Headings](#ckeditor5/latest/features/headings.html) – Divide your content into sections.
* [Highlight](#ckeditor5/latest/features/highlight.html) – Mark important words and passages, aiding a review or drawing attention to specific parts of the content.
* [Format painter](#ckeditor5/latest/features/format-painter.html) – Easily copy text formatting and apply it in a different place in the edited document.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.

### Common API

The [`FontFamily`](../api/module_font_fontfamily-FontFamily.html) plugin registers the following components:

* The `'fontFamily'` dropdown.

* The [`'fontFamily'`](../api/module_font_fontfamily_fontfamilycommand-FontFamilyCommand.html) command.

The number of options and their names correspond to the [`config.fontFamily.options`](../api/module_font_fontconfig-FontFamilyConfig.html#member-options) configuration option.

You can change the font family of the current selection by executing the command with a desired value:

```js
  editor.execute( 'fontFamily', { value: 'Arial' } );
  ```

The `value` must correspond to the first font name in the configuration string. For the following default configuration:

```js
  fontFamily.options = [
      'default',
      'Arial, Helvetica, sans-serif',
      'Courier New, Courier, monospace',
      'Georgia, serif',
      'Lucida Sans Unicode, Lucida Grande, sans-serif',
      'Tahoma, Geneva, sans-serif',
      'Times New Roman, Times, serif',
      'Trebuchet MS, Helvetica, sans-serif',
      'Verdana, Geneva, sans-serif'
  ]
  ```

the `'fontFamily'` command will accept the corresponding strings as values:

* `'Arial'`
  * `'Courier New'`
  * `'Georgia'`
  * `'Lucida Sans Unicode'`
  * `'Tahoma'`
  * `'Times New Roman'`
  * `'Trebuchet MS'`
  * `'Verdana'`

Note that passing an empty value will remove the `fontFamily` attribute from the selection (`default`):

```js
  editor.execute( 'fontFamily' );
  ```

The [`FontSize`](../api/module_font_fontsize-FontSize.html) plugin registers the following components:

* The `'fontSize'` dropdown.

* The [`'fontSize'`](../api/module_font_fontsize_fontsizecommand-FontSizeCommand.html) command.

The number of options and their names correspond to the [`config.fontSize.options`](../api/module_font_fontconfig-FontSizeConfig.html#member-options) configuration option.

You can change the font size of the current selection by executing the command with a desired value:

```js
  // For numerical values:
  editor.execute( 'fontSize', { value: 10 } );

// For named presets:
  editor.execute( 'fontSize', { value: 'small' } );
  ```

Passing an empty value will remove any `config.fontSize` set:

```js
  editor.execute( 'fontSize' );
  ```

The [`FontColor`](../api/module_font_fontcolor-FontColor.html) plugin registers the following components:

* The `'fontColor'` dropdown.

* The [`'fontColor'`](../api/module_font_fontcolor_fontcolorcommand-FontColorCommand.html) command.

You can change the font color of the current selection by executing the command with a desired value:

```js
  editor.execute( 'fontColor', { value: 'rgb(30, 188, 97)' } );
  ```

Passing an empty value will remove the font color from the selection:

```js
  editor.execute( 'fontColor' );
  ```

The [`FontBackgroundColor`](../api/module_font_fontbackgroundcolor-FontBackgroundColor.html) plugin registers the following components:

* The `'fontBackgroundColor'` dropdown.

* The [`'fontBackgroundColor'`](../api/module_font_fontbackgroundcolor_fontbackgroundcolorcommand-FontBackgroundColorCommand.html) command.

You can change the font background color of the current selection by executing the command with a desired value:

```js
  editor.execute( 'fontBackgroundColor', { value: 'rgb(30, 188, 97)' } );
  ```

Passing an empty value will remove the font background color from the selection:

```js
  editor.execute( 'fontBackgroundColor' );
  ```

### Content compatibility

The [`Font`](../api/module_font_font-Font.html) plugin provides basic support for the deprecated `<font>` tag.

While `<font color>` is always supported, to use `<font face>` and `<font size>` you need to enable the [`config.fontFamily.supportAllValues`](../api/module_font_fontconfig-FontFamilyConfig.html#member-supportAllValues) and [`config.fontSize.supportAllValues`](../api/module_font_fontconfig-FontSizeConfig.html#member-supportAllValues) options respectively.

Text formatted with `<font>` is accepted by the plugin, but the editor always returns the markup in a modern format, so the transformation is one way.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-font>.

<a id="ckeditor5/latest/features/footnotes.html">source file: "ckeditor5/latest/features/footnotes.html"</a>

## Footnotes

The footnotes feature allows you to add supplementary information, citations, or explanatory notes that appear at the bottom of your document without cluttering the main text. Simply select any content you need annotated and click the footnote button to create a numbered reference that readers can easily navigate to and from.

Due to the differences between printed and digital content, the footnotes in CKEditor 5 are actually grouped together, like endnotes, and not at the bottom of each page.

### Demo

Point your cursor to where you need to add a footnote and use the toolbar footnote button to add one. You can also edit existing footnotes and choose marker style by clicking in the footnotes area.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { Footnotes, FootnotesProperties } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Footnotes, FootnotesProperties, /* ... */ ],
		toolbar: [ 'insertFootnote', /* ... */ ],
		footnotes: {
			multiBlock: false // Turn off the multi-block support (enabled by default).
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { Footnotes, FootnotesProperties } = CKEDITOR_PREMIUM_FEATURES;

Please note that the `FootnotesProperties` plugin is optional. See the [Configuration](#ckeditor5/latest/features/footnotes.html--configuration) section for more details.

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

### Configuration

#### Multi-block footnotes

The footnotes feature can be configured using the `footnotes.multiBlock` option. By default, this option is set to `true`, allowing users to create footnotes that span multiple blocks of content. You can disable this feature by setting `multiBlock` to `false` in the editor configuration:

```ts
ClassicEditor
    .create( {
        footnotes: {
            multiBlock: false // Default: true
        }
    } )
```

When `multiBlock` is set to `true`, users can add footnotes that span multiple blocks of content, such as paragraphs or list items. This allows for more complex annotations and references within the document.

When `multiBlock` is set to `false`, users can only add footnotes to single blocks of content. This is useful for simpler documents where footnotes are only needed for specific points within a block. The content of the footnote definition will be limited to text only.

#### The `FootnotesProperties` contextual balloon

The optional `FootnotesProperties` plugin (as seen imported in the [Installation](#ckeditor5/latest/features/footnotes.html--installation) section) adds a contextual dropdown that appears when you click the footnotes definitions area. It provides quick access to footnote formatting options, allowing users to change the marker numbering style.

The [`FootnotesProperties`](../api/module_footnotes_footnotesproperties-FootnotesProperties.html) plugin provides additional configuration option to choose the default style of the list item markers:

```js
ClassicEditor
    .create( {
        footnotes: {
            footnotesProperties: {
                // The default footnotes list style for newly created footnotes lists.
                // It can be changed using the 'Footnotes style' dropdown in the editor UI.
                defaultListStyle: 'decimal', // Default: 'decimal'

// The starting index for the footnotes list numbering.
                // It can be changed using the 'start' dropdown in the editor UI.
                // Note: The starting index must be a positive integer greater or equal to 0.
                defaultStartIndex: 1, // Default: 1

// Configuration of the footnotes style dropdown shown when the user clicks footnotes definitions list.
                toolbar: [ 'footnotesStyle' ], // Default: [ 'footnotesStyle' ]

// List of styles available in the footnotes style dropdown.
                listStyles: [ 'decimal' ] // Default: [ 'decimal', 'decimal-leading-zero', 'lower-latin', 'upper-latin', 'lower-roman', 'upper-roman' ]
            }
        }
    } )
```

Available list styles: `'decimal'`, `'decimal-leading-zero'`, `'lower-roman'`, `'upper-roman'`, `'lower-latin'`, `'upper-latin'`, `'arabic-indic'`.

The `arabic-indic` style is not shown in the dropdown by default. To enable it, add it to the `listStyles` configuration:

```js
footnotes: {
    footnotesProperties: {
        listStyles: [
            'decimal',
            'decimal-leading-zero',
            'lower-latin',
            'upper-latin',
            'lower-roman',
            'upper-roman',
            'arabic-indic'
        ]
    }
}
```

### Known issues

Moving the footnotes list while [Track Changes](#ckeditor5/latest/features/collaboration/track-changes/track-changes.html) is enabled is not supported - a document can contain at most one footnotes list. As a workaround, temporarily disable track changes or accept/reject the relevant changes, then perform the move.

### Related features

Check out also these CKEditor 5 features to gain better control over your content style and format:

### Common API

The [`Footnotes`](../api/module_footnotes_footnotes-Footnotes.html) plugin registers:

* The [`'insertFootnote'` command](../api/module_footnotes_commands_insertfootnotecommand-InsertFootnoteCommand.html).
* The `'insertFootnote'` UI component – a button to insert footnotes.

The [`FootnotesProperties`](../api/module_footnotes_footnotesproperties-FootnotesProperties.html) plugin registers:

* The [`'footnotesStyle'` command](../api/module_footnotes_footnotesproperties_commands_footnotesstylecommand-FootnotesStyleCommand.html).
* The `'footnotesStyle'` UI component – a dropdown to change footnotes numbering style.

#### Executing commands

You can insert a footnote programmatically by executing the command:

```js
editor.execute( 'insertFootnote' );
```

You can also specify a custom footnote ID:

```js
editor.execute( 'insertFootnote', { footnoteId: 'my-custom-footnote-id' } );
```

If the `footnoteId` parameter is not provided, a unique ID will be generated automatically. The footnote ID must be a non-empty string without spaces that does not start with a digit.

You can change the footnotes style by executing:

```js
editor.execute( 'footnotesStyle', { value: 'lower-roman' } );
```

Available style values: `'decimal'`, `'decimal-leading-zero'`, `'lower-roman'`, `'upper-roman'`, `'lower-latin'`, `'upper-latin'`, `'arabic-indic'`.

<a id="ckeditor5/latest/features/format-painter.html">source file: "ckeditor5/latest/features/format-painter.html"</a>

## Format painter

The format painter feature lets you copy text formatting (such as bold, italic, font size, color, etc.) and apply it in a different place in the edited document. It helps keep the formatting consistent and speeds up the creation of rich content.

### Demo

Click the text that you want to copy the formatting from and use the paint formatting toolbar button to copy the style. Then select the target text with your mouse to apply the formatting. See below the demo for more tips on using the feature.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

* **To copy the formatting**: Place the cursor inside a text with some formatting and click the paint formatting toolbar button. Notice that the mouse cursor changes to the .

* **To paint with the copied formatting**: Click any word in the document and the new formatting will be applied. Alternatively, instead of clicking a single word, you can select a text fragment (like an entire paragraph). Notice that the cursor will go back to the default one after the formatting is applied.

* **To keep painting using the same formatting**: Open the toolbar dropdown and enable the continuous painting mode. Once copied, the same formatting can be applied multiple times in different places until the paint formatting button is clicked (the cursor will then revert to the regular one).

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { FormatPainter } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ FormatPainter, /* ... */ ],
		toolbar: [ 'formatPainter', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { FormatPainter } = CKEDITOR_PREMIUM_FEATURES;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ FormatPainter, /* ... */ ],
		toolbar: [ 'formatPainter', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

### Integration

The format painter feature only supports the [text attributes](#ckeditor5/latest/framework/architecture/editing-engine.html--text-attributes) with the [`isFormatting`](../api/module_engine_model_schema-ModelAttributeProperties.html#member-isFormatting) [property](../api/module_engine_model_schema-ModelSchema.html#function-setAttributeProperties) set to `true`.

If you want your custom feature to become compatible with format painter, make sure you set the `isFormatting` property in your feature’s [schema](#ckeditor5/latest/framework/deep-dive/schema.html) configuration to `true`:

```js
// Allow myAttribute attribute on text nodes.
editor.model.schema.extend( '$text', { allowAttributes: 'myAttribute' } );

// Integration with the format painter feature.
editor.model.schema.setAttributeProperties( 'myAttribute', {
isFormatting: true
} );
```

If you want to enable format painter for existing features that are not supported out of the box, such as the [link feature](#ckeditor5/latest/features/link.html), set the `isFormatting` property to `true` on a related text attribute:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
    } )
    .then( editor => {
        // Enable format painter for links. The link feature uses the "linkHref" text attribute.
        editor.model.schema.setAttributeProperties( 'linkHref', {
            isFormatting: true
        } );
    } );
```

You can use the [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) to learn about the model structure of the content brought by other features.

### Limitations

Not all formatting can be handled by the format painter out of the box.

* Painting with block-level formatting (like [headings](#ckeditor5/latest/features/headings.html) or [image styles](#ckeditor5/latest/features/images/images-styles.html)) is not supported yet.\
  Neither [links](#ckeditor5/latest/features/link.html) nor [text highlights](#ckeditor5/latest/features/highlight.html) are handled by the format painter. This is because, in CKEditor 5, they are considered a part of the content rather than text formatting. However, you can [work around this](#ckeditor5/latest/features/format-painter.html--integration) if needed.

### Related features

Here are some more CKEditor 5 features that can help you format your content:

* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – The essentials, like **bold**, _italic_ and others.
* [Font styles](#ckeditor5/latest/features/font.html) – Control the font [family](#ckeditor5/latest/features/font.html--configuring-the-font-family-feature), [size](#ckeditor5/latest/features/font.html--configuring-the-font-size-feature), and [text or background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features).
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Format the text on the go using Markdown.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.

### Common API

The [`FormatPainter`](../api/module_format-painter_formatpainter-FormatPainter.html) plugin registers:

* The `'formatPainter'` UI button (dropdown) component for the toolbar.
* The `'copyFormat'` command implemented by [`CopyFormatCommand`](../api/module_format-painter_copyformatcommand-CopyFormatCommand.html).
* The `'pasteFormat'` command implemented by [`PasteFormatCommand`](../api/module_format-painter_pasteformatcommand-PasteFormatCommand.html).

You can copy the formatting of the current document selection using the editor API:

```js
editor.execute( 'copyFormat' );
```

The copied formatting is stored in the [value of the `copyFormat` command](../api/module_format-painter_copyformatcommand-CopyFormatCommand.html#member-value):

```js
// Logs the copied formatting.
console.log( editor.commands.get( 'copyFormat' ).value );
```

The previously copied formatting can be applied in a different place using the following code:

```js
editor.execute( 'pasteFormat' );
```

<a id="ckeditor5/latest/features/fullscreen.html">source file: "ckeditor5/latest/features/fullscreen.html"</a>

## Fullscreen mode

The fullscreen mode lets you temporarily expand the editor to the whole browser viewport, giving you more space to comfortably edit content and use editor’s UI features.

### Demo

Use the fullscreen mode toolbar button in the editor below to see the feature in action. Once you enter the fullscreen mode, you will notice the following changes:

* Editor UI is stretched to the whole browser viewport.
* Menu bar is visible by default, regardless of its presence outside fullscreen.
* The editor editable area dimensions are changed.
* Some dialogs are re-positioned to better utilize the increased space.
* Website scroll is disabled.
* Annotations display mode is switched to wide sidebar (this affects only annotations UIs without filter function configured).

Fullscreen mode can also be toggled using the `Ctrl`+`Shift`+`F` (or `Cmd`+`Shift`+`F`) keystroke.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Fullscreen } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Fullscreen, /* ... */ ],
		toolbar: [ 'fullscreen', /* ... */ ]
		fullscreen: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Fullscreen } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Fullscreen, /* ... */ ],
		toolbar: [ 'fullscreen', /* ... */ ]
		fullscreen: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Supported editor types

Fullscreen mode is ready-to-use for [classic](#ckeditor5/latest/getting-started/setup/editor-types.html--classic-editor) and [decoupled](#ckeditor5/latest/getting-started/setup/editor-types.html--decoupled-editor-document) editors. If you want to use it with other editor type, you can use custom callbacks to adjust the layout according to your needs. See the details in the [Enabling other editor types](#ckeditor5/latest/features/fullscreen.html--enabling-other-editor-types) section.

### Configuration

Fullscreen mode is designed to provide a great editing experience without requiring any additional effort from the integrator. It provides integration with most of the official CKEditor 5 features out-of-the-box, detecting which of them are available. At the same time, it is possible to fully customize how the fullscreen mode is displayed, either through configuration flags, custom CSS definitions or by providing a custom callback that will execute more complex changes.

#### Menu bar visibility

By default, menu bar is visible in fullscreen mode for any [supported editor type](#ckeditor5/latest/features/fullscreen.html--supported-editor-types), regardless of their original configuration. To disable it, use the `config.fullscreen.menuBar.isVisible` option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fullscreen: {
            menuBar: {
                isVisible: false
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Note that this setting does not change the original behavior defined in `config.menuBar.isVisible` configuration option.

#### Toolbar grouping

Toolbar grouping in fullscreen mode will behave the same as outside it. To define the behavior explicitly, use `config.fullscreen.toolbar.shouldNotGroupWhenFull` option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fullscreen: {
            toolbar: {
                shouldNotGroupWhenFull: true
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Note that this setting does not change the original behavior defined in `config.toolbar.shouldNotGroupWhenFull` configuration option.

#### Using a custom container

If you want to use the fullscreen mode to enhance the editing experience but still need certain elements of your website layout to remain visible, you can specify a custom container for the editor using the `config.fullscreen.container` property. The editor will be resized to match the dimensions of the specified container.

**Important:** Be sure the container element has a positioning context (meaning, its `position` is not set to `static`) – typically `relative`, `absolute`, or `fixed`. This ensures the editor is correctly positioned and sized within the container.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        fullscreen: {
            container: document.querySelector( '.fullscreen-editor-container' )
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

When using a custom container, the website scroll will not be locked to allow for accessing the rest of the website content.

> **Note**
>
> For more technical details, please check the [plugin configuration API](../api/module_fullscreen_fullscreenconfig-FullscreenConfig.html).

### Further customization

Besides basic configuration, it is possible to do virtually any changes to the fullscreen mode layout using CSS and custom configurable callbacks.

#### Basic template

To change the component styling (like editable area width or background color), you can use the CSS classes (precede each with `.ck.ck-fullscreen__main-wrapper` selector to ensure enough CSS specificity):

* `ck-fullscreen__top-wrapper` - top wrapper holding the menu bar and toolbar.
* `ck-fullscreen__menu-bar` - container with menu bar.
* `ck-fullscreen__toolbar` - container with toolbar.
* `ck-fullscreen__editable-wrapper` - container with sidebars and editable area.
* `ck-fullscreen__sidebar` - this class is assigned to both left and right sidebar.
* `ck-fullscreen__left-sidebar` - class that only left sidebar has.
* `ck-fullscreen__right-sidebar` - class that only right sidebar has.
* `ck-fullscreen__editable` - container with the editable area.
* `ck-fullscreen__bottom-wrapper` - empty container that can be used for footer-like features.

#### Callbacks

If you want to display some additional elements in the fullscreen mode, set the `config.fullscreen.onEnterCallback` and `config.fullscreen.onLeaveCallback` properties.

`onEnterCallback( container )` is fired when you enter fullscreen mode. Passed parameter is the final DOM element container generated by the default fullscreen behavior. It contains the whole fullscreen mode DOM structure, already set up (the editor UI is already injected into the container). You are free to perform any changes, for example, relocate sidebars or append additional UI elements.

`onLeaveCallback( container )` is fired when you leave fullscreen mode. Passed parameter is the container with the fullscreen mode DOM structure. The callback should be used to take care of any of your custom components, for example, if some elements were moved to the fullscreen DOM structure, restore their original locations in the DOM.

#### Demo - customized layout: pageless editor

Below you will find a customized demo:

* Instead of occupying the whole viewport, the editor is stretched only over the main website area, not covering the top and side navigation bars.
* The “piece of paper” view is replaced by the “pageless” view, replicating the [classic editor](#ckeditor5/latest/getting-started/setup/editor-types.html--classic-editor) experience.
* Menu bar is not displayed.

#### Enabling other editor types

This section covers how to provide fullscreen mode integration for other [editor types](#ckeditor5/latest/getting-started/setup/editor-types.html) than classic and decoupled. Please note that only these two editor types are officially supported, so the code snippets below are exemplary and may not solve all technical challenges.

First, you need to create a custom class extending [`FullscreenAbstractEditorHandler`](../api/module_fullscreen_handlers_abstracteditorhandler-FullscreenAbstractEditorHandler.html). Besides the optional typing improvements, the most important thing is to implement its custom [`#defaultOnEnter()`](../api/module_fullscreen_handlers_abstracteditorhandler-FullscreenAbstractEditorHandler.html#function-defaultOnEnter) method. It should move the editor UI elements proper for your editor type to the fullscreen container, preferably using [`#moveToFullscreen()`](../api/module_fullscreen_handlers_abstracteditorhandler-FullscreenAbstractEditorHandler.html#function-moveToFullscreen) helper - it will assure the elements are moved back in DOM when leaving fullscreen mode.

Then, in the editor’s `toggleFullscreen` command, you will need to substitute the [`#fullscreenHandler`](../api/module_fullscreen_fullscreencommand-FullscreenCommand.html#member-fullscreenHandler) property with an instance of your custom class. It can be done by adding a custom plugin that should be later added to the editor configuration (see the full example below).

```ts
import { FullscreenAbstractEditorHandler, FullscreenEditing } from '@ckeditor/ckeditor5-fullscreen';
import { Plugin } from '@ckeditor/ckeditor5-core';

class CustomEditorHandler extends FullscreenAbstractEditorHandler {
    // It's not mandatory to override `#_editor` property, but that will help TypeScript to properly handle the class.
    // Skip if you are not using TS.
    protected override readonly _editor: CustomEditorClass;

// Assign the custom editor class.
    constructor( editor: CustomEditorClass ) {
        super( editor );

this._editor = editor;
    }

public override defaultOnEnter() {
        // Implement your fullscreen logic here.
        // For DOM manipulation, use `this.moveToFullscreen()` helper to ensure the elements are properly cleaned up
        // after leaving fullscreen mode.
    }
}

class CustomFullscreenHandling extends Plugin {
    // Ensure 'toggleFullscreen' command, registered in `FullscreenEditing` plugin, is already available in the editor.
    public static get requires() {
        return [ FullscreenEditing ] as const;
    }

init() {
        // Substitute the default editor handler with a custom one.
        this.editor.commands.get( 'toggleFullscreen' ).fullscreenHandler = new CustomEditorHandler( this.editor );
    }
}

CustomEditorClass
    .create( {
        // Other configuration options.
        plugins: [ Fullscreen, CustomFullscreenHandling,
            // Other plugins.
        ]
    } );
```

### Related features

Here are some CKEditor 5 features that are a perfect match for fullscreen mode:

* [Document outline](#ckeditor5/latest/features/document-outline.html) – Display the list of all document headings next to the editing area.
* [Track changes](#ckeditor5/latest/features/collaboration/track-changes/track-changes.html) – Mark user changes in the content and show them as suggestions in the sidebar for acceptance or rejection.
* [Real-time collaboration](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration.html) – Work on the same document with other users simultaneously.

### Common API

The fullscreen plugin registers:

* the `fullscreen` UI button components for toolbar and menu bar,
* the `toggleFullscreen` command.

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Toggle the fullscreen mode.
editor.execute( 'toggleFullscreen' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-fullscreen>.

<a id="ckeditor5/latest/features/headings.html">source file: "ckeditor5/latest/features/headings.html"</a>

## Headings

The heading feature helps you structure your document by adding headings to parts of the text, making your content easier to scan for both readers and search engines. It provides configurable heading levels, rendered as `<h2>` to `<h4>` by default.

### Demo

Use the toolbar dropdown to style a heading. You can also type one or more `#` characters (depending on the heading level) followed by a space, and the [autoformatting feature](#ckeditor5/latest/features/autoformat.html) will create a new heading.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Heading levels

By default, this feature is configured to support `<h2>`, `<h3>`, and `<h4>` elements which are named: “Heading 1,” “Heading 2,” and “Heading 3,” respectively. The rationale behind starting from `<h2>` is that `<h1>` should be reserved for the [page’s main title](#ckeditor5/latest/features/title.html) and the page content will usually start from `<h2>`.

> **Note**
>
> Support for adding a document title is provided through the [`Title`](../api/module_heading_title-Title.html) plugin. When it is enabled, a `<h1>` element pasted into the editor will be rendered as the [document title](#ckeditor5/latest/features/title.html).

By default, when your editor preset does not include the title plugin, an `<h1>` element pasted into the rich-text editor is converted to `<h2>` (“Heading 1”).

> **Note**
>
> You can read more about why the editor should not create `<h1>` elements for content headings in the [Headings section of Editor Recommendations](http://ckeditor.github.io/editor-recommendations/features/headings.html).

### Heading buttons

The heading feature lets you also use a set of heading buttons instead of the dropdown list. The toolbar buttons are configurable, and it is possible to include a paragraph button, too. Compare the heading toolbar dropdown from the demo above with the heading buttons below to check the functionality and usability of this variation.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Heading } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Heading, /* ... */ ],
		toolbar: [ 'heading', /* ... */ ]
		heading: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Heading } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Heading, /* ... */ ],
		toolbar: [ 'heading', /* ... */ ]
		heading: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Installation with toolbar heading buttons

To configure the toolbar buttons for styling text as headings and paragraphs, you need to import the following into your plugin list and configuration:

**NPM**

```js
import { ClassicEditor, HeadingButtonsUI, ParagraphButtonUI } from 'ckeditor5';
```

**CDN**

```js
const { ClassicEditor, HeadingButtonsUI, ParagraphButtonUI } = CKEDITOR;
```

### Configuration

#### Configuring heading levels

You can configure which heading levels the editor will support and how they should be named in the Headings dropdown. Use the [`heading.options`](../api/module_heading_headingconfig-HeadingConfig.html#member-options) configuration option to do so.

For example, the following editor will support only two levels of headings – `<h1>` and `<h2>`:

```html
<div id="editor">
    <h1>Heading 1</h1>
    <h2>Heading 2</h2>
    <p>This is <a href="https://ckeditor.com">CKEditor 5</a>.</p>
</div>
```

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        heading: {
            options: [
                { model: 'paragraph', title: 'Paragraph', class: 'ck-heading_paragraph' },
                { model: 'heading1', view: 'h1', title: 'Heading 1', class: 'ck-heading_heading1' },
                { model: 'heading2', view: 'h2', title: 'Heading 2', class: 'ck-heading_heading2' }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuring custom heading elements

It is also possible to define fully custom elements for headings by using the [advanced format](../api/module_engine_conversion_conversion-Conversion.html#function-elementToElement) of the [`heading.options`](../api/module_heading_headingconfig-HeadingConfig.html#member-options) configuration option.

For example, the following editor will support the following two heading options at the same time: `<h2 class="fancy">` and `<h2>`:

```html
<style>
    /* Styles for the heading in the content and for the dropdown item. */
    h2.fancy, .ck.ck-button.ck-heading_heading2_fancy {
        color: #ff0050;
        font-size: 17px;
    }
</style>

<div id="snippet-custom-heading-levels">
    <h1>Heading 1</h1>
    <h2>Heading 2</h2>
    <h2 class="fancy">Fancy Heading 2</h2>
    <p>This is <a href="https://ckeditor.com">CKEditor 5</a>.</p>
</div>
```

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        heading: {
            options: [
                { model: 'paragraph', title: 'Paragraph', class: 'ck-heading_paragraph' },
                { model: 'heading1', view: 'h1', title: 'Heading 1', class: 'ck-heading_heading1' },
                { model: 'heading2', view: 'h2', title: 'Heading 2', class: 'ck-heading_heading2' },
                {
                    model: 'headingFancy',
                    view: {
                        name: 'h2',
                        classes: 'fancy'
                    },
                    title: 'Heading 2 (fancy)',
                    class: 'ck-heading_heading2_fancy',

// It needs to be converted before the standard 'heading2'.
                    converterPriority: 'high'
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuring toolbar buttons

To use individual toolbar buttons instead of the heading dropdown, you need to properly configure the feature. You also need to import proper UI elements; see the [installation section](#ckeditor5/latest/features/headings.html--installation-with-toolbar-heading-buttons) for instructions on how to do it.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        toolbar: [ 'paragraph', 'heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6', '|', 'undo', 'redo' ],
        heading: {
            options: [
                { model: 'paragraph', title: 'Paragraph', class: 'ck-heading_paragraph' },
                { model: 'heading1', view: 'h1', title: 'Heading 1', class: 'ck-heading_heading1' },
                { model: 'heading2', view: 'h2', title: 'Heading 2', class: 'ck-heading_heading2' },
                { model: 'heading3', view: 'h3', title: 'Heading 3', class: 'ck-heading_heading3' },
                { model: 'heading4', view: 'h4', title: 'Heading 4', class: 'ck-heading_heading4' },
                { model: 'heading5', view: 'h5', title: 'Heading 5', class: 'ck-heading_heading5' },
                { model: 'heading6', view: 'h6', title: 'Heading 6', class: 'ck-heading_heading6' }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Related features

There are more CKEditor 5 features that can help you format your content:

* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – The essentials, like **bold**, _italic_, and others.
* [Document title](#ckeditor5/latest/features/title.html) – Clearly divide your content into a title and body.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Set indentation for text blocks such as paragraphs or lists.
* [Lists](#ckeditor5/latest/features/lists/lists.html) – Organize your content better with ordered and unordered lists you can style.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Add formatting elements (such as headings) as you type with Markdown code.

### Common API

The [`Heading`](../api/module_heading_heading-Heading.html) plugin registers:

* The `'heading'` dropdown.

* The `'heading'` command that accepts a value based on the [`heading.options`](../api/module_heading_headingconfig-HeadingConfig.html#member-options) configuration option.

You can turn the currently selected block(s) to headings by executing one of these commands:

```js
  editor.execute( 'heading', { value: 'heading2' } );
  ```

The [`HeadingButtonsUI`](../api/module_heading_headingbuttonsui-HeadingButtonsUI.html) plugin registers six UI button components that will execute the `'heading'` command with the proper value of the `value` attribute:

* `'heading1'`
* `'heading2'`
* `'heading3'`
* `'heading4'`
* `'heading5'`
* `'heading6'`

The [`ParagraphButtonUI`](../api/module_paragraph_paragraphbuttonui-ParagraphButtonUI.html) plugin registers the UI button component: `'paragraph'`.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-heading>.

<a id="ckeditor5/latest/features/highlight.html">source file: "ckeditor5/latest/features/highlight.html"</a>

## Highlight

The highlight feature lets you mark text fragments with different colors. You can use it both as a marker (to change the background color) and as a pen (to change the text color).

### Demo

Select the text you want to highlight. Then use the highlight toolbar button to choose a desired color from the dropdown.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Highlight } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Highlight, /* ... */ ],
		toolbar: [ 'highlight', /* ... */ ]
		highlight: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Highlight } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Highlight, /* ... */ ],
		toolbar: [ 'highlight', /* ... */ ]
		highlight: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring the highlight options

The highlight feature comes with flexible configuration options.

However, the plugin has a predefined and limited number of available colors. It also focuses more on functionality than aesthetics. To change the text and background colors, use the [font color and background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features) plugin.

The highlight feature uses inline `<mark>` elements in the view.

#### Dropdown

You can configure which highlight options are supported by the editor. Use the [`highlight.options`](../api/module_highlight_highlightconfig-HighlightConfig.html#member-options) configuration and define your highlight styles.

For example, the following editor supports two styles (a green marker and a red pen):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        highlight: {
            options: [
                {
                    model: 'greenMarker',
                    class: 'marker-green',
                    title: 'Green marker',
                    color: 'var(--ck-content-highlight-marker-green)',
                    type: 'marker'
                },
                {
                    model: 'redPen',
                    class: 'pen-red',
                    title: 'Red pen',
                    color: 'var(--ck-content-highlight-pen-red)',
                    type: 'pen'
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Inline buttons

Instead of using the (default) `'highlight'` button, the feature also supports a configuration with separate buttons available directly in the toolbar:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        toolbar: {
            items: [
                'heading',
                '|',
                'highlight:yellowMarker', 'highlight:greenMarker', 'highlight:pinkMarker',
                'highlight:greenPen', 'highlight:redPen', 'removeHighlight',
                '|',
                'undo', 'redo'
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Colors and styles

> **Note**
>
> See the plugin [options](../api/module_highlight_highlightconfig-HighlightConfig.html#member-options) to learn more about defaults.

##### Using CSS variables

The highlight feature is using the power of [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables) defined in the [style sheet](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-highlight/theme/index-content.css). Thanks to that, both the UI and the content styles share the same color definitions that you can customize:

```css
:root {
    /* Make green a little darker. */
    --ck-content-highlight-marker-green: #199c19;

/* Make the yellow more "dirty". */
    --ck-content-highlight-marker-yellow: #cac407;

/* Make red more pinkish. */
    --ck-content-highlight-pen-red: #ec3e6e;
}
```

##### Inline color definitions

You can use inline color values in the `rgba(R, G, B, A)`, `#RRGGBB[AA]`, or `hsla(H, S, L, A)` formats instead of CSS variables. To do that, customize the [options](../api/module_highlight_highlightconfig-HighlightConfig.html#member-options) and define the `color` property for each option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        highlight: {
            options: [
                {
                    model: 'greenMarker',
                    class: 'marker-green',
                    title: 'Green marker',
                    color: 'rgb(25, 156, 25)',
                    type: 'marker'
                },
                {
                    model: 'yellowMarker',
                    class: 'marker-yellow',
                    title: 'Yellow marker',
                    color: '#cac407',
                    type: 'marker'
                },
                {
                    model: 'redPen',
                    class: 'pen-red',
                    title: 'Red pen',
                    color: 'hsl(343, 82%, 58%)',
                    type: 'pen'
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Then, update the classes in the style sheet so the content corresponds to the UI of the editor. The UI buttons and the actual highlights in the text should be the same color.

```css
.marker-green {
    background-color: rgb(25, 156, 25);
}
.marker-yellow {
    background-color: #cac407;
}
.pen-red {
    color: hsl(343, 82%, 58%);
}
```

### Related features

CKEditor 5 has more features that can help you style your content:

* [Styles](#ckeditor5/latest/features/style.html) – Apply pre-configured styles like highlight or spoiler to existing content elements.
* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – The essentials, like **bold**, _italic_, and others.
* [Font styles](#ckeditor5/latest/features/font.html) – Control the font [family](#ckeditor5/latest/features/font.html--configuring-the-font-family-feature), [size](#ckeditor5/latest/features/font.html--configuring-the-font-size-feature), [text or background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features).
* [Format painter](#ckeditor5/latest/features/format-painter.html) – Easily copy text formatting and apply it in a different place in the edited document.
* [Block quote](#ckeditor5/latest/features/block-quote.html) – Include block quotations or pull quotes in your rich-text content.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.

### Common API

The [`Highlight`](../api/module_highlight_highlight-Highlight.html) plugin registers:

* The `'highlight'` dropdown.

* The [`'highlight'`](../api/module_highlight_highlightcommand-HighlightCommand.html) command.

The number of options and their names correspond to the [`highlight.options`](../api/module_highlight_highlightconfig-HighlightConfig.html#member-options) configuration option.

You can change the highlight of the current selection by executing the command with a desired value:

```js
  editor.execute( 'highlight', { value: 'yellowMarker' } );
  ```

The `value` corresponds to the `model` property in the configuration object. For the default configuration:

```js
  highlight.options = [
      { model: 'yellowMarker', class: 'marker-yellow', title: 'Yellow Marker', color: 'var(--ck-content-highlight-marker-yellow)', type: 'marker' },
      { model: 'greenMarker', class: 'marker-green', title: 'Green marker', color: 'var(--ck-content-highlight-marker-green)', type: 'marker' },
      { model: 'pinkMarker', class: 'marker-pink', title: 'Pink marker', color: 'var(--ck-content-highlight-marker-pink)', type: 'marker' },
      { model: 'blueMarker', class: 'marker-blue', title: 'Blue marker', color: 'var(--ck-content-highlight-marker-blue)', type: 'marker' },
      { model: 'redPen', class: 'pen-red', title: 'Red pen', color: 'var(--ck-content-highlight-pen-red)', type: 'pen' },
      { model: 'greenPen', class: 'pen-green', title: 'Green pen', color: 'var(--ck-content-highlight-pen-green)', type: 'pen' }
  ]
  ```

the `'highlight'` command will accept the corresponding strings as values:

* `'yellowMarker'` – available as the `'highlight:yellowMarker'` button,
  * `'greenMarker'` – available as the `'highlight:greenMarker'` button,
  * `'pinkMarker'` – available as the `'highlight:pinkMarker'` button,
  * `'blueMarker'` – available as the `'highlight:blueMarker'` button,
  * `'redPen'` – available as the `'highlight:redPen'` button,
  * `'greenPen'` – available as the `'highlight:greenPen'` button.

Passing an empty `value` will remove any `highlight` attribute from the selection:

```js
  editor.execute( 'highlight' );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-highlight>.

<a id="ckeditor5/latest/features/horizontal-line.html">source file: "ckeditor5/latest/features/horizontal-line.html"</a>

## Horizontal line

The horizontal line feature lets you visually divide your content into sections by inserting horizontal lines (also known as horizontal rules). It is an easy way to organize the content or indicate a change of topic.

### Demo

To insert a horizontal line in the demo below, use the toolbar button . Alternatively, start a new line with `---`. The [autoformatting feature](#ckeditor5/latest/features/autoformat.html) will turn it into a horizontal line.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, HorizontalLine } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ HorizontalLine, /* ... */ ],
		toolbar: [ 'horizontalLine', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, HorizontalLine } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ HorizontalLine, /* ... */ ],
		toolbar: [ 'horizontalLine', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Related features

CKEditor 5 has more features that can help you better organize your document content:

* [Headings](#ckeditor5/latest/features/headings.html) – Organize your content into thematic sections.
* [Page break](#ckeditor5/latest/features/page-break.html) – Divide your document into pages.
* [Document title](#ckeditor5/latest/features/title.html) – Clearly separate the title from the body.
* [Lists](#ckeditor5/latest/features/lists/lists.html) – Create ordered (numbered) and unordered (bulleted) lists.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Format the content on the go with Markdown code.

### Common API

The [`HorizontalLine`](../api/module_horizontal-line_horizontalline-HorizontalLine.html) plugin registers:

* the UI button component (`'horizontalLine'`),
* the `'horizontalLine'` command implemented by [`HorizontalLineCommand`](../api/module_horizontal-line_horizontallinecommand-HorizontalLineCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Inserts a horizontal line into the selected content.
editor.execute( 'horizontalLine' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-horizontal-line>.

<a id="ckeditor5/latest/features/html/full-page-html.html">source file: "ckeditor5/latest/features/html/full-page-html.html"</a>

## Full page HTML

The full page HTML feature lets you edit entire HTML pages in CKEditor 5 (from `<html>` to `</html>`), including the page metadata. While the [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) feature focuses on elements inside the content (the document’s `<body>`), this feature enables markup mostly invisible to the end user.

### Demo

Use the [Enhanced source code editing feature](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) toolbar button to view and edit the HTML source of the document. Pay attention to the underlying markup.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, FullPage } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ FullPage, /* ... */ ],
		htmlSupport: {
			fullPage: {
				// Configuration.
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, FullPage } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ FullPage, /* ... */ ],
		htmlSupport: {
			fullPage: {
				// Configuration.
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

#### Render styles

By default, the full page HTML feature does not render the CSS from `<style>` that may be located in the `<head>` section edited content. To enable that possibility, set the [`config.htmlSupport.fullPage.allowRenderStylesFromHead`](../../api/module_html-support_generalhtmlsupportconfig-GHSFullPageConfig.html#member-allowRenderStylesFromHead) option to `true`.

Plugin extracts `<style>` elements from the edited content moves them to the main document `<head>`, and renders them. When CSS in `<style>` tag is changed using, for example, the [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) feature, previously added `<style>` elements to the main document `<head>` will be replaced by the new ones.

However, by enabling the ability to render CSS from `<style>` elements located in the `<head>` section of the edited content, you expose the users of your system to the **risk of executing malicious code inside the editor**. Therefore, we highly recommend sanitizing your CSS using some library that will strip the malicious code from the styles before rendering them. You can plug in the sanitizer by defining the [`config.htmlSupport.fullPage.sanitizeCss`](../../api/module_html-support_generalhtmlsupportconfig-GHSFullPageConfig.html#member-sanitizeCss) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        htmlSupport: {
            fullPage: {
                allowRenderStylesFromHead: true,
                // Strip unsafe properties and values, for example:
                // values like url( ... ) that may execute malicious code
                // from an unknown source.
                sanitizeCss( CssString ) {
                    const sanitizedCss = sanitize( CssString );

return {
                        css: sanitizedCss,
                        // true or false depending on whether
                        // the sanitizer stripped anything.
                        hasChanged: true
                    };
                }
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Security

It is a plain security risk. The user may provide a CSS mistakenly copied from a malicious website. It could also end up in the user’s clipboard (as it would usually be copied and pasted) by any other means.

You can instruct some advanced users to never paste CSS code from untrusted sources. However, in most cases, it is highly recommended to secure the system by configuring the Full page HTML feature to use a CSS sanitizer and, optionally, by setting strict Content Security Policy (CSP) rules.

##### Sanitizer

The [`config.htmlSupport.fullPage.sanitizeCss`](../../api/module_html-support_generalhtmlsupportconfig-GHSFullPageConfig.html#member-sanitizeCss) option allows plugging an external sanitizer.

##### CSP

In addition to using a sanitizer, you can use the built-in browser mechanism called [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP). By using CSP, you can let the browser know the allowed sources that CSS can use.

### Additional feature information

Here are some examples of the HTML elements you can enable with this plugin:

* The HTML DOCTYPE preamble: `<!DOCTYPE html>`
* The HTML root element: `<html>`
* The head element: `<head>`
* The document’s title: `<title>`
* Meta tags inside the head element, like: `<meta name="description" content="Meta description">`

### Related features

CKEditor 5 has other features related to HTML editing that you may want to check:

* [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) – Allows you to enable HTML features (elements, attributes, classes, styles) that are not supported by other dedicated CKEditor 5 plugins.
* [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) – Allows for viewing and editing the source code of the document in a handy modal window (compatible with all editor types) with syntax highlighting, autocompletion and more.
* [HTML embed](#ckeditor5/latest/features/html/html-embed.html) – Allows embedding an arbitrary HTML snippet in the editor.

<a id="ckeditor5/latest/features/html/general-html-support.html">source file: "ckeditor5/latest/features/html/general-html-support.html"</a>

## General HTML Support

With the General HTML Support (GHS) feature, developers can enable HTML features that are not supported by any other dedicated CKEditor 5 plugins. GHS lets you add elements, attributes, classes, and styles to the source. It also ensures this markup stays in the editor window and in the output.

### Demo

You can configure the General HTML Support feature using the `config.htmlSupport` property. With this property, you need to list the HTML features that should be handled by GHS.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

Here are some examples of HTML features that you can enable using General HTML Support:

* The `<section>`, `<article>`, and `<div>` elements.

* The `<audio>`, `<video>`, and `<iframe>` elements.

* The `<span>` and `<cite>` elements.

* Some attributes of existing dedicated CKEditor 5 features:

* The `data-*` and `id` attributes on, for example, `<p>` and `<h1-h6>`.
  * The `style` and `classes` attributes on, for example, `<strong>` and `<a>`.

You can load (for example, via `editor.setData()`), paste, output (for example, via `editor.getData()`) the enabled HTML features. They are also visible in the editing area. To a limited extent, you can also edit such content in the editor. Read more about it in the [Level of support](#ckeditor5/latest/features/html/general-html-support.html--level-of-support) section.

### Level of support

The difference between specific CKEditor 5 features such as [basic styles](#ckeditor5/latest/features/basic-styles.html) or [headings](#ckeditor5/latest/features/headings.html) and the HTML features enabled by GHS is that a plugin that supports a specific HTML feature provides a complete user experience for that feature. GHS ensures only that such content is accepted by the editor.

For instance, the dedicated [bold](#ckeditor5/latest/features/basic-styles.html--available-text-styles) feature offers a toolbar button used to make the selected text bold. Together with the [autoformatting feature](#ckeditor5/latest/features/autoformat.html), it also allows for applying bold style to content by typing a Markdown shortcode (`**foo**`) in the editor. The [headings](#ckeditor5/latest/features/headings.html) feature offers a dropdown from which the user can choose a heading level and ensures that pressing `Enter` at the end of a heading creates a new paragraph (and not another heading).

The General HTML Support does not offer any UI for the enabled features and takes only the basic semantics of a given feature into account. If you enable support for `<div>` elements via GHS, the user will not be able to create such elements from the editor UI. The GHS will know that a `<div>` is a container element, so it can wrap other blocks (like paragraphs) but cannot be used inline (next to, for example, a `<strong>` element). In this respect, it is similar to the Advanced Content Filtering (ACF) feature from CKEditor 4 as it lets you create a list of markup tags that the editor will not strip.

Therefore, the main use cases for GHS would be:

* Ensuring backward content compatibility with legacy systems.
* Introducing basic support for missing HTML features at a low cost.

> **Note**
>
> Considering the nature of GHS, you may consider installing the [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) feature alongside it.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, GeneralHtmlSupport } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ GeneralHtmlSupport, /* ... */ ],
		htmlSupport: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, GeneralHtmlSupport } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ GeneralHtmlSupport, /* ... */ ],
		htmlSupport: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

By default, enabling the [`GeneralHtmlSupport`](../../api/module_html-support_generalhtmlsupport-GeneralHtmlSupport.html) plugin does not enable support for any given element. You need to configure the elements the user wants to use via the [`config.htmlSupport`](../../api/module_core_editor_editorconfig-EditorConfig.html#member-htmlSupport) option. List of predefined elements than can be enabled this way is [available further in this guide](#ckeditor5/latest/features/html/general-html-support.html--predefined-supported-elements). It is also possible to define and enable [custom elements](#ckeditor5/latest/features/html/general-html-support.html--enabling-custom-elements).

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        htmlSupport: {
            allow: [ /* HTML features to allow. */ ],
            disallow: [ /* HTML features to disallow. */ ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The notation of the `allow` and `disallow` rules looks as follows:

```js
[
    {
        // The element name to enable or extend with
        // the following styles, classes, and other attributes.
        name: string|regexp,

// Styles to allow (by name, name and value, or just all).
        styles: object<string=>true|string|regexp>|array<string>|true,

// Classes to allow (by name or just all).
        classes: array<string|regexp>|true,

// Other attributes to allow (by name, name and value, or just all).
        attributes: object<string=>true|string|regexp>|array<string>|true,
    }
]
```

Several implementation examples:

```js
htmlSupport: {
    allow: [
        // Enables plain <div> elements.
        {
            name: 'div'
        },

// Enables plain <div>, <section>, and <article> elements.
        {
            name: /^(div|section|article)$/
        },

// Enables <div> elements with all inline styles (but no other attributes).
        {
            name: 'div',
            styles: true
        },

// Enables <div> elements with "foo" and "bar" classes.
        {
            name: 'div',
            classes: [ 'foo', 'bar' ]
        },

// Adds support for "foo" and "bar" classes to the already supported
        // <p> elements (those are enabled by the dedicated paragraph feature).
        {
            name: 'p',
            classes: [ 'foo', 'bar' ]
        },

// Enables <div> elements with foo="true" attribute and "bar" attribute that
        // can accept any value (the Boolean "true" value works as an asterisk).
        {
            name: 'div',
            attributes: {
                foo: 'true',
                bar: true
            }
        },

// Adds support for style="color: *" to the already supported
        // <p> and <h2-h4> elements.
        {
            name: /^(p|h[2-4])$/',
            styles: { 'color': true }
        },
}
```

The General HTML Support feature distinguishes several content types, each treated a bit differently:

* Container elements (like `<section>`, `<div>`).
* Inline elements (like `<span>`, `<a>`).
* Object elements (like `<iframe>`, `<video>`).

The enabled elements will not just be available “anywhere” in the content. They still need to adhere to certain rules derived from the HTML schema and common sense. Also, the behavior of specific types of elements in the editing area will be different. For instance, the object elements will only be selectable as a whole. The inline elements will work the same as other formatting features supported by CKEditor 5 (like bold and italic) do.

#### Enabling all HTML features

Sometimes you might want to enable all HTML features, so the editor will allow all elements and attributes. You can achieve this with a special configuration:

```js
htmlSupport: {
    allow: [
        {
            name: /.*/,
            attributes: true,
            classes: true,
            styles: true
        }
    ]
}
```

> **Note**
>
> Enabling all HTML features creates a security risk. You should pass a list of disallowed elements and attributes to the configuration to make sure that any malicious code will not be saved and executed in the editor.

This configuration will work similarly to the [`allowedContent: true`](/docs/ckeditor4/latest/api/CKEDITOR_config.html#cfg-allowedContent) option from CKEditor 4.

#### Enabling script tags for legacy use cases

> **Warning**
>
> Scripts are blocked by default for [security reasons](#ckeditor5/latest/features/html/general-html-support.html--security). For new implementations, we discourage embedding scripts in editor content.

Scripts are blocked by default because allowing `<script>` tags in editor content would let arbitrary JavaScript run whenever that content is rendered. It creates a serious cross-site scripting (XSS) risk—content from untrusted sources (e.g., copied from a malicious site or supplied by an attacker) could steal session data, modify the page, or perform actions on behalf of the user. If you attempt to place the `<script>` tag in the content, you may see an error like this:

```
view renderer filler not found
```

Blocking scripts by default keeps the editing surface and the published output safe unless you explicitly enable scripts for a controlled, legacy scenario. For example, if you have content from CKEditor 4 and script tags are necessary. For such a case you can explicitly allow `<script>` tags using the configuration:

```js
htmlSupport: {
    allow: [
        {
            name: 'script',
            attributes: true,
            classes: true,
            styles: true
        }
    ]
}
```

This configuration allows `<script>` elements along with their attributes, classes, and styles, preventing the editor from crashing when such content is loaded.

#### Security

When you set up the GHS to allow elements like `<script>` or attributes like `onclick`, you expose the users of your application to a possibly malicious markup. This can be code mistakenly copied from a risky website or purposely provided by a bad actor. An example of that could be: `<div onclick="leakUserData()">`.

The content inside the editor (what you see in the editing area) is filtered by default from typical content that could break the editor. However, the editor does not feature a full XSS filter. We recommend configuring GHS to enable specific HTML markup instead of enabling all markup at once.

Moreover, as a general rule, not exclusive to GHS, there should always be a sanitization process present on the backend side of your application. Even the best filtering done on the browser side of your application can be mitigated, and every network call can be manipulated, thus bypassing the frontend filtering. This can quickly become a security risk.

In addition to the sanitization process and safe GHS configuration, it is highly recommended to set strict [Content Security Policy](#ckeditor5/latest/getting-started/setup/csp.html) rules.

##### Iframe sandbox

`<iframe>` elements can introduce security risks if not properly restricted. To address this, browsers support the [`sandbox` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe#sandbox) on iframes, which restricts what the embedded content is allowed to do.

GHS automatically enforces a `sandbox` attribute on all `<iframe>` elements in the **editing view** via the built-in `IframeElementSupport` plugin. This behavior is controlled by the `htmlSupport.htmlIframeSandbox` configuration option.

> **Note**
>
> The `htmlIframeSandbox` option only affects what is rendered in the editing area. It does **not** modify the document data returned by `editor.getData()`. Your backend sanitization pipeline should independently enforce iframe sandboxing in the output HTML.

The `htmlIframeSandbox` option accepts `true` (the default), an array of allowed [sandbox flag values](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe#sandbox), or `false`. Setting it to `true` enforces the strictest mode — every `<iframe>` in the editing view gets an empty `sandbox=""` attribute, disabling scripts, forms, popups, and all other privileged features. Passing an array limits the sandbox to only the specified flags; any flag not on the list is stripped from existing iframes. Setting the option to `false` disables enforcement entirely and leaves the attribute untouched.

```js
ClassicEditor
    .create( {
        htmlSupport: {
            // Default. Enforces empty sandbox on all iframes.
            htmlIframeSandbox: true,

// Only these flags are kept.
            // htmlIframeSandbox: [ 'allow-scripts', 'allow-same-origin' ],

// No enforcement — attribute is left as-is.
            // htmlIframeSandbox: false
        }
    } );
```

#### Enabling custom elements

You can define custom HTML elements with attributes and classes.

To use a new element, you need to register it with [`DataSchema`](../../api/module_html-support_dataschema-DataSchema.html) as one of the types below:

* Inline element.
* Block element.

To enable such elements and add attributes or classes to them, you need to use the [`allowElement`](../../api/module_html-support_datafilter-DataFilter.html#function-allowElement) and [`allowAttributes`](../../api/module_html-support_datafilter-DataFilter.html#function-allowAttributes) methods from the [`DataFilter`](../../api/module_html-support_datafilter-DataFilter.html) API.

Base implementation example:

**NPM**

```js
import { ClassicEditor, Essentials, Paragraph, Plugin, SourceEditingEnhanced, GeneralHtmlSupport } from 'ckeditor5';

/**
* A plugin extending General HTML Support, for example, with custom HTML elements.
*/
class ExtendHTMLSupport extends Plugin {
	static get requires() {
		return [ GeneralHtmlSupport ];
	}

init() {
		// Extend the schema with custom HTML elements.
		const dataFilter = this.editor.plugins.get( 'DataFilter' );
		const dataSchema = this.editor.plugins.get( 'DataSchema' );

// Inline element.
		dataSchema.registerInlineElement( {
			view: 'element-inline',
			model: 'myElementInline'
		} );

// Custom elements need to be registered using direct API instead of configuration.
		dataFilter.allowElement( 'element-inline' );
		dataFilter.allowAttributes( { name: 'element-inline', attributes: { 'data-foo': false }, classes: [ 'foo' ] } );

// Block element.
		dataSchema.registerBlockElement( {
			view: 'element-block',
			model: 'myElementBlock',
			modelSchema: {
				inheritAllFrom: '$block'
			}
		} );

dataFilter.allowElement( 'element-block' );
	}
}

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		plugins: [
			Essentials,
			Paragraph,
			SourceEditingEnhanced,
			ExtendHTMLSupport
		],
		htmlSupport: {
			allow: [
				{
					name: /.*/,
					attributes: true,
					classes: true,
					styles: true
				}
			]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Essentials, Paragraph, Plugin, SourceEditingEnhanced, GeneralHtmlSupport } = CKEDITOR;

/**
* A plugin extending General HTML Support, for example, with custom HTML elements.
*/
class ExtendHTMLSupport extends Plugin {
	static get requires() {
		return [ GeneralHtmlSupport ];
	}

init() {
		// Extend the schema with custom HTML elements.
		const dataFilter = this.editor.plugins.get( 'DataFilter' );
		const dataSchema = this.editor.plugins.get( 'DataSchema' );

// Inline element.
		dataSchema.registerInlineElement( {
			view: 'element-inline',
			model: 'myElementInline'
		} );

// Block element.
		dataSchema.registerBlockElement( {
			view: 'element-block',
			model: 'myElementBlock',
			modelSchema: {
				inheritAllFrom: '$block'
			}
		} );

dataFilter.allowElement( 'element-block' );
	}
}

You can treat both inline and block elements as object elements. To make it possible, it is necessary to set the [isObject](../../api/module_html-support_dataschema-HtmlSupportDataSchemaDefinition.html#member-isObject) property to `true`.

```js
// Inline object element.
dataSchema.registerInlineElement( {
    view: 'object-inline',
    model: 'myObjectInline',
    isObject: true,
    modelSchema: {
        inheritAllFrom: '$inlineObject'
    }
} );

dataFilter.allowElement( 'object-inline' );

// Block object element.
dataSchema.registerBlockElement( {
    view: 'object-block',
    model: 'myObjectBlock',
    isObject: true,
    modelSchema: {
        inheritAllFrom: '$blockObject'
    }
} );

dataFilter.allowElement( 'object-block' );
```

#### Predefined supported elements

The HTML elements listed below can be turned on directly via the `allow` setting of the `config.htmlSupport` option [mentioned above](#ckeditor5/latest/features/html/general-html-support.html--configuration).

##### Block elements

* address
* article
* aside
* blockquote
* button
* caption
* center
* col
* colgroup
* dd
* details
* dir
* div
* dl
* dt
* fieldset
* figcaption
* figure
* footer
* form
* header
* hgroup
* hr
* hx
* img
* input
* legend
* li
* main
* menu
* nav
* ol
* p
* pre
* section
* summary
* table
* tbody
* td
* tfoot
* th
* thead
* tr
* ul

##### Inline elements

* a
* abbr
* acronym
* audio
* b
* bdi
* bdo
* big
* canvas
* cite
* code
* del
* dfn
* embed
* em
* figure
* font
* i
* iframe
* ins
* kbd
* li
* mark
* meter
* object
* oembed
* ol
* output
* progress
* q
* s
* samp
* script
* select
* small
* span
* strong
* style
* sub
* sup
* tbody
* thead
* time
* tt
* u
* ul
* var
* video

### Known issues

You can add support for arbitrary styles, classes, and other attributes to existing CKEditor 5 features (such as paragraphs, headings, list items, etc.). Most of the existing CKEditor 5 features can already be extended this way; however, some cannot yet.

> **Note**
>
> While the GHS feature is stable, some problems with complex documents may occur if you use it together with [real-time collaboration](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration.html).

We are open to feedback, so if you find any issue, feel free to report it in the [main CKEditor 5 repository](https://github.com/ckeditor/ckeditor5/issues/).

### Related features

CKEditor 5 has other features related to HTML editing that you may want to check:

* [Full page HTML](#ckeditor5/latest/features/html/full-page-html.html) – Allows using CKEditor 5 to edit entire HTML pages, from `<html>` to `</html>`, including the page metadata.
* [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) – Allows for viewing and editing the source code of the document in a handy modal window (compatible with all editor types) with syntax highlighting, autocompletion and more.
* [HTML embed](#ckeditor5/latest/features/html/html-embed.html) – Allows embedding an arbitrary HTML snippet in the editor.

<a id="ckeditor5/latest/features/html/html-comments.html">source file: "ckeditor5/latest/features/html/html-comments.html"</a>

## HTML comment element

The [`HtmlComment`](../../api/module_html-support_htmlcomment-HtmlComment.html) feature lets developers keep HTML comments in the document without displaying them to the user. By default, the editor filters out all HTML comments on initialization.

> **Note**
>
> The support for HTML comments has known limitations – see the [known issues](#ckeditor5/latest/features/html/html-comments.html--known-issues) section below.

### Demo

The editor below is configured to keep HTML comments in the document content. You can view the source of the document using the [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) feature. Toggle the Enhanced source code editing mode to see there is an HTML comment in the document source. Try uncommenting the paragraph below the picture. Once you leave the source editing mode, you will see this paragraph in the editable area.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { HtmlComment } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ HtmlComment, ... ],
	} )
	.then( ... )
	.catch( ... );
```

**CDN**

```js
const { HtmlComment } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ HtmlComment, ... ],
	} )
	.then( ... )
	.catch( ... );
```

HTML comment feature does not require any configuration.

### Known issues

The main issue with the HTML comments feature is that comments can be easily repositioned or lost in various cases (see [#10118](https://github.com/ckeditor/ckeditor5/issues/10118)).

We are open for feedback, so if you find any issue, feel free to report it in the [main CKEditor 5 repository](https://github.com/ckeditor/ckeditor5/issues/).

### Related features

CKEditor 5 has other features related to HTML editing you may want to check:

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-html-support>.

<a id="ckeditor5/latest/features/html/html-embed.html">source file: "ckeditor5/latest/features/html/html-embed.html"</a>

## HTML embed

The HTML embed feature lets you embed any HTML snippet in your content. The feature is meant for more advanced users who want to directly interact with HTML fragments.

### Demo

Use the HTML embed toolbar button in the editor below to see the plugin in action. Click the “Preview editor data” button under the editor to preview the editor content, including the embedded HTML.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

#### Demo content preview

### Additional feature information

This feature lets you embed any HTML code and bypass CKEditor 5’s filtering mechanisms. You can use it to enrich content produced by CKEditor 5 with fragments of HTML that are not supported by any other CKEditor 5 feature.

Some examples of content that you can embed thanks to the HTML embed feature:

* Analytics code (that usually requires embedding `<script>` elements).
* Social page widgets (that also require embedding `<script>` elements).
* Content embeddable by `<iframe>` elements.
* HTML media elements such as `<audio>` and `<video>`.
* HTML snippets produced by external tools (for example, reports or charts).
* Interactive content that requires a combination of rich HTML and scripts.

We recommended using the [media embed](#ckeditor5/latest/features/media-embed/media-embed.html) feature for embeddable media that this feature supports. You can use the HTML embed feature to handle the remaining content.

> **Warning**
>
> Read the [Security](#ckeditor5/latest/features/html/html-embed.html--security) section before installing this plugin.
>
> Incorrect configuration may **lead to security issues**.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, HtmlEmbed } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ HtmlEmbed, /* ... */ ],
		toolbar: [ 'htmlEmbed', /* ... */ ],
		htmlEmbed: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, HtmlEmbed } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ HtmlEmbed, /* ... */ ],
		toolbar: [ 'htmlEmbed', /* ... */ ],
		htmlEmbed: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

#### Content previews

The feature is by default configured to not show previews of the HTML snippets. You can enable the previews by setting the [`config.htmlEmbed.showPreviews`](../../api/module_html-embed_htmlembedconfig-HtmlEmbedConfig.html#member-showPreviews) option to `true`.

However, by showing previews of the embedded HTML snippets, you expose the users of your system to the **risk of executing malicious JavaScript code inside the editor**. Therefore, it is highly recommended to plug in some HTML sanitizer that will strip the malicious code from the created snippets before rendering their previews. You can plug in the sanitizer by defining the [`config.htmlEmbed.sanitizeHtml`](../../api/module_html-embed_htmlembedconfig-HtmlEmbedConfig.html#member-sanitizeHtml) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        htmlEmbed: {
            showPreviews: true,
            sanitizeHtml: ( inputHtml ) => {
                // Strip unsafe elements and attributes, for example:
                // the `<script>` elements and `on*` attributes.
                const outputHtml = sanitize( inputHtml );

return {
                    html: outputHtml,
                    // true or false depending on whether the sanitizer stripped anything.
                    hasChanged: true
                };
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Currently, the [feature does not execute `<script>` tags](https://github.com/ckeditor/ckeditor5/issues/8326) so the content that requires executing JavaScript to generate a preview will not show in the editor. However, other JavaScript code, for example, used in `on*` observers and `src="javascript:..."` attributes will be executed. You still need to enable the sanitizer.

Displaying raw HTML previews can execute malicious JS (for example via `onclick` or `javascript:`) in your site’s context. Read more about the security aspect in the next section.

#### Security

If you configure the HTML embed feature to [show content previews](#ckeditor5/latest/features/html/html-embed.html--content-previews), the HTML that the user inserts into the HTML embed widget is then rendered back to the user. \*\*If the HTML was rendered as-is, **the browser would execute any JavaScript code included in these HTML snippets in the context of your website**.

This, in turn, is a plain security risk. The HTML provided by the user might be mistakenly copied from a malicious website. It could also end up in the user’s clipboard (as it would usually be copied and pasted) by any other means.

You can instruct some advanced users to never paste HTML code from untrusted sources. However, in most cases, it is highly recommended to secure the system by configuring the HTML embed feature to use an HTML sanitizer and, optionally, by setting strict Content Security Policy (CSP) rules.

> **Note**
>
> The tricky part is that some HTML snippets require executing JavaScript to render any meaningful previews (for example, Facebook embeds). Some, in turn, do not make sense to execute (like analytics code).
>
> Therefore, when configuring the sanitizer and CSP rules, you can take these situations into consideration and for instance, allow `<script>` tags pointing only to certain domains (like a trusted external page that requires JavaScript).

##### Sanitizer

> **Important**
>
> Scripts may not run in the `<script>` tags in previews, but inline JS in attributes will. Always sanitize or limit allowed sources to stay safe!

The [`config.htmlEmbed.sanitizeHtml`](../../api/module_html-embed_htmlembedconfig-HtmlEmbedConfig.html#member-sanitizeHtml) option allows plugging an external sanitizer.

Some popular JavaScript libraries that you can use include [`sanitize-html`](https://www.npmjs.com/package/sanitize-html) and [`DOMPurify`](https://www.npmjs.com/package/dompurify).

The default settings of these libraries usually strip all potentially malicious content including `<iframe>`, `<video>`, or similar elements and JavaScript code coming from trusted sources. You may need to adjust their settings to match your needs.

When `showPreviews = true`, use libraries like `DOMPurify` or `sanitize-html` to prevent XSS Attacks. Sample code may look similar to this:

```js
sanitizeHtml: inputHtml => {
  const safe = DOMPurify.sanitize(inputHtml, {...});
  return { html: safe, hasChanged: safe !== inputHtml };
}
```

Adjust allowed tags/attributes (for example: permit `iframe` only from trusted domains) to balance functionality and safety. Consider pairing this with CSP for stronger security. Check the [Content previews](#ckeditor5/latest/features/html/html-embed.html--content-previews) and [Security](#ckeditor5/latest/features/html/html-embed.html--security) sections of this guide for more details.

##### CSP

In addition to sanitizing content, you can utilize the built-in browser mechanism called [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP). By using CSP, the browser recognizes allowed sources and methods of executing JavaScript code. It also allows including other resources such as style sheets, images, and fonts. Check out the dedicated [Content Security Policy](#ckeditor5/latest/getting-started/setup/csp.html) setup guide.

### Related features

CKEditor 5 supports a wider range of embed and code features, including:

* [Media embed](#ckeditor5/latest/features/media-embed/media-embed.html) – Insert embeddable media such as YouTube or Vimeo videos and tweets into your rich text content.
* [Code blocks](#ckeditor5/latest/features/code-blocks.html) – Insert longer, multiline listings of pre-formatted code with a programming language assigned.
* [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) – Enable HTML features (elements, attributes, classes, styles) that are not supported by other dedicated CKEditor 5 plugins.

### Common API

The [`HtmlEmbed`](../../api/module_html-embed_htmlembed-HtmlEmbed.html) plugin registers:

* The UI button component (`'htmlEmbed'`).
* The `'htmlEmbed'` command implemented by [`HtmlEmbedCommand`](../../api/module_html-embed_htmlembedcommand-HtmlEmbedCommand.html).

You can execute the command using the [`editor.execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Inserts an empty HTML embed.
editor.execute( 'htmlEmbed' );

// Inserts an HTML embed with some initial content.
editor.execute( 'htmlEmbed', '<b>Initial content</b>.' );

// Updates the content of a selected HTML embed.
editor.execute( 'htmlEmbed', '<b>New content.</b>' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-html-embed>.

<a id="ckeditor5/latest/features/images/image-upload/base64-upload-adapter.html">source file: "ckeditor5/latest/features/images/image-upload/base64-upload-adapter.html"</a>

## Base64 image upload adapter

The Base64 image upload adapter converts inserted images into [Base64-encoded strings](https://en.wikipedia.org/wiki/Base64) in the [editor output](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html). The images are stored with other content in the database without any server-side processing.

> **Warning**
>
> Remember that while `Base64` upload is an easy solution, it is also highly inefficient. The image file is kept as data in the database, generating a much heavier data load and higher transfer. `Base64` images are never cached by the browser so loading and saving such data will always be slower.
>
> This can be troublesome for some features: [revision history](#ckeditor5/latest/features/collaboration/revision-history/revision-history.html) may hence take longer to load revisions. The same applies to [comments](#ckeditor5/latest/features/collaboration/comments/comments.html). Content with `Base64` images may also exceed the allowed file size when your document is [exported to PDF](#ckeditor5/latest/features/converters/export-pdf.html) or [to Word](#ckeditor5/latest/features/converters/export-word.html).
>
> Therefore using the `Base64` feature is a less efficient option to use than some other available ones. Check out the comprehensive [image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) guide to learn about other ways to upload images into CKEditor 5.

### Demo

Use the editor below to see the adapter in action. Open the web browser console and click the button below the editor to see the base64–encoded image in the editor output data.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Base64UploadAdapter } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Base64UploadAdapter, /* ... */ ],
		toolbar: [ /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Base64UploadAdapter } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Base64UploadAdapter, /* ... */ ],
		toolbar: [ /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

Once enabled in the plugin list, the Base64 image upload adapter works out–of–the–box without any additional configuration.

### Configuration

#### Configuring allowed file types

The allowed file types that can be uploaded should actually be configured in two places:

* On the client side, in CKEditor 5, restricting image upload through the CKEditor 5 UI and commands.
* On the server side, in your server configuration.

##### Client-side configuration

Use the [`image.upload.types`](../../../api/module_image_imageconfig-ImageUploadConfig.html#member-types) configuration option to define the allowed image MIME types that can be uploaded to CKEditor 5.

By default, users can upload `jpeg`, `png`, `gif`, `bmp`, `webp`, and `tiff` files. You can customize this behavior to accept, for example, SVG files (in this case use the `svg+xml` type).

##### Server-side configuration

It is up to you to implement any filtering mechanisms on your server to restrict the types of images allowed to be uploaded.

### What’s next

Check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) to learn more about different ways of uploading images in CKEditor 5.

See the [Image feature guide](#ckeditor5/latest/features/images/images-overview.html) to find out more about handling images in CKEditor 5 WYSIWYG editor.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-upload>.

<a id="ckeditor5/latest/features/images/image-upload/custom-upload-adapter.html">source file: "ckeditor5/latest/features/images/image-upload/custom-upload-adapter.html"</a>

## Custom upload adapter

A custom upload adapter connects CKEditor 5’s file uploads to your own server or storage, giving you control over how files are sent and where they are stored. You might build one to meet server integration, security and authentication, or business-logic requirements.

The CKEditor 5 Framework offers an open API with a set of classes for upload adapters that handle the entire upload process from when a user adds a file (for example, by dragging an image) to when the server responds, acting as a bridge between the editor and your server.

Check out this dedicated [Custom Upload Adapter](#ckeditor5/latest/framework/deep-dive/upload-adapter.html) guide, which explains how to create custom file upload functionality for the editor.

### What’s next

Check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) to learn more about different ways of uploading images in CKEditor 5.

See the [Image feature guide](#ckeditor5/latest/features/images/images-overview.html) to find out more about handling images in CKEditor 5 WYSIWYG editor.

<a id="ckeditor5/latest/features/images/image-upload/image-upload.html">source file: "ckeditor5/latest/features/images/image-upload/image-upload.html"</a>

## Image upload overview

In CKEditor 5, an upload adapter sends uploaded images to your own server or a storage service such as CKBox. In a properly configured editor, there are several ways for users to insert [images](#ckeditor5/latest/features/images/images-overview.html):

* **Pasting** an image from the clipboard.
* **Dragging** a file from the file system.
* Selecting an image through the **file system dialog**.
* Selecting an image from the **media management tool** in your application.
* **Pasting** a URL to an image, either into the editor dialog or directly into the content.

### Demo

This demo is configured to use [CKBox](#ckeditor5/latest/features/file-management/ckbox.html) for image upload and management. Use the image upload button to upload images or the CKBox button to browse and select existing images from the file manager. It also includes the `AutoImage` plugin, which lets you [paste image URLs directly](#ckeditor5/latest/features/images/images-inserting.html--inserting-images-via-pasting-a-url-into-the-editor).

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### How it works

Except for pasting URLs to images, all other solutions mentioned above require the image to be uploaded to a server. The server will then be responsible for providing the image URL used by CKEditor 5 to display the image in the document. The software that makes the image upload possible is called an **upload adapter**. It is a callback that tells the WYSIWYG editor how to send the file to the server. There are two main strategies for getting the image upload to work that you can adopt in your project:

* [**Official upload adapters**](#ckeditor5/latest/features/images/image-upload/image-upload.html--official-upload-adapters) – There are several features providing upload adapters developed and maintained by the CKEditor team. Some of these are simple and only enable uploading, while some, like the [CKBox asset manager](#ckeditor5/latest/features/file-management/ckbox.html), let you upload, browse, manage, and edit images. Pick the best one for your integration and let it handle the image upload in your project.
* [**Custom upload adapters**](#ckeditor5/latest/features/images/image-upload/image-upload.html--implementing-your-own-upload-adapter) – You can also create your upload adapter from scratch using the open API architecture of CKEditor 5.

> **Note**
>
> If you want to get a better look under the hood and learn more about the upload process, you can check out the [“Custom image upload adapter” deep dive guide](#ckeditor5/latest/framework/deep-dive/upload-adapter.html) covering this topic.

### Official upload adapters

#### CKBox

CKBox is the ultimate solution for not just image upload but also file management in CKEditor 5.

It is a modern file uploader with a clean interface, automatic support for responsive images, and top-notch UX. It also provides editing capabilities like cropping, rotating, or flipping.

Thanks to the native CKEditor 5 integration, CKBox supports drag and drop file upload as well as pasting images from the clipboard, Microsoft Word, or Google Docs.

With CKBox, users can upload files and categorize them into different groups. They can also change the way the files are displayed, for example, by setting the image thumbnail size or deciding how many files are shown on one page. Files can be uploaded, deleted, renamed, and tagged. File properties like dimensions, upload date, or size are also easily accessible and can be used to sort the file view alongside a regular search.

The CKBox On-premises version offers various storage options, from local filesystem, through MySQL and Postgres databases, to AWS S3 and Azure Blob Storage solutions. The SaaS version is using a blazing-fast CDN powered by AWS S3.

[**Learn how to use CKBox in your project**](#ckeditor5/latest/features/file-management/ckbox.html).

#### Uploadcare

Uploadcare is the ultimate solution for image upload and editing in CKEditor 5.

It is a modern file uploader with a clean interface, automatic support for responsive images, on-the-fly image optimization, fast delivery through global CDN network, multiple third party integrations and vast image editing capabilities such as cropping, filtering and adjusting image parameters.

Thanks to the native CKEditor 5 integration, Uploadcare supports drag-and-drop file upload as well as pasting images from the clipboard, Microsoft Word, or Google Docs.

With Uploadcare, users can upload files from external services like Dropbox, Facebook, Google Drive, Google Photos, OneDrive or from local computer. Images can be easily adjusted with built-in image editor. The storage is configuration-less for ease of use. It also offers reliable and fast [AWS S3 storage solution](https://uploadcare.com/docs/aws-s3-storage/).

[**Learn how to use Uploadcare in your project**](#ckeditor5/latest/features/file-management/uploadcare.html).

#### CKFinder

The [CKFinder feature](#ckeditor5/latest/features/file-management/ckfinder.html) provides a bridge between the rich-text editor and [CKFinder](https://ckeditor.com/ckfinder/), a browser-based file uploader with server-side connectors (PHP, Java, and ASP.NET).

There are two ways you can integrate CKEditor 5 with CKFinder:

* **With the server-side connector only** – In this scenario, images dropped or pasted into the editor are uploaded to the CKFinder server-side connector running on your server.
* **With both the server-side connector and the client-side file manager** (recommended) – Images dropped and pasted into the editor are uploaded to the server (like in the first option). With access to the file manager, you can browse previously uploaded images, organize them, or edit them.

[**Learn how to integrate CKEditor 5 with CKFinder in your project**](#ckeditor5/latest/features/file-management/ckfinder.html).

#### Simple adapter

The [simple upload adapter](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html) allows uploading images to your server using the [`XMLHttpRequest`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) API with a minimal editor configuration.

[**Learn how to use the simple upload adapter in CKEditor 5**](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html).

#### Base64 adapter

The [Base64 upload feature](#ckeditor5/latest/features/images/image-upload/base64-upload-adapter.html) converts images inserted into the editor into [Base64 strings](https://en.wikipedia.org/wiki/Base64) in the [editor output](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html).

> **Warning**
>
> Please remember that while `Base64` upload is an easy solution, it is also highly inefficient. The image file itself is kept as data in the database, generating a much heavier data load and higher transfer. We recommend using alternative ways to upload images into CKEditor 5.

[**Learn how to use Base64–encoded images in CKEditor 5**](#ckeditor5/latest/features/images/image-upload/base64-upload-adapter.html).

### Implementing your own upload adapter

CKEditor 5 provides an open API that allows you to develop your upload adapters. Tailored to your project, a custom adapter will allow you to take full control over the upload process. This includes both sending the files to the server and passing the response from the server (for example, the URL to the saved file) back to the WYSIWYG editor.

[**Learn how to develop a custom upload adapter for CKEditor 5**](#ckeditor5/latest/framework/deep-dive/upload-adapter.html).

<a id="ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html">source file: "ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html"</a>

## Simple upload adapter

The simple upload adapter lets you upload images to your server using the [`XMLHttpRequest`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) API with a minimal [editor configuration](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html--configuration). See the [Server-side configuration](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html--server-side-configuration) section to learn about the requirements for your server-side application.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, SimpleUploadAdapter } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ SimpleUploadAdapter, /* ... */ ],
		toolbar: [ /* ... */ ],
		simpleUpload: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, SimpleUploadAdapter } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SimpleUploadAdapter, /* ... */ ],
		toolbar: [ /* ... */ ],
		simpleUpload: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

The client side of this feature is configurable using the [`config.simpleUpload`](../../../api/module_upload_uploadconfig-SimpleUploadConfig.html) object.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        simpleUpload: {
            // The URL that the images are uploaded to.
            uploadUrl: 'http://example.com',

// Enable the XMLHttpRequest.withCredentials property.
            withCredentials: true,

// Headers sent along with the XMLHttpRequest to the upload server.
            headers: {
                'X-CSRF-TOKEN': 'CSRF-Token',
                Authorization: 'Bearer <JSON Web Token>'
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuring allowed file types

The allowed file types that can be uploaded should be configured in two places:

* On the client side, in CKEditor 5, restricting image upload through the CKEditor 5 UI and commands.
* On the server side, in your server-side application configuration.

##### Client-side configuration

By default, users are allowed to upload `jpeg`, `png`, `gif`, `bmp`, `webp`, and `tiff` files, but you can customize this behavior to accept, for example, SVG files.

##### Server-side configuration

It is up to you to implement any filtering mechanisms on your server to restrict the types of images that are allowed to be uploaded.

### Server-side configuration

To use this upload adapter, you must provide a server-side application that will handle the uploads and communicate with the editor, as described in the following sections.

#### Communication protocol

When the image upload process is initiated, the adapter sends a [`POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request under [`config.simpleUpload.uploadUrl`](../../../api/module_upload_uploadconfig-SimpleUploadConfig.html#member-uploadUrl).

You can send additional [headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) along with the `XMLHttpRequest` to the upload server, for example, to authenticate the user, using the [`config.simpleUpload.headers`](../../../api/module_upload_uploadconfig-SimpleUploadConfig.html#member-uploadUrl) object.

If you use the [`config.simpleUpload.withCredentials`](../../../api/module_upload_uploadconfig-SimpleUploadConfig.html#member-withCredentials) configuration, you may need some [extra HTTP headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) for the cross-site request to work.

The [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) of the request is always `json`. See the [Successful upload](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html--successful-upload) and [Error handling](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html--error-handling) sections to learn more.

#### Successful upload

If the upload is successful, the server should return:

* An object containing the `url` property which points to the uploaded image on the server:

```json
  {
      "url": "https://example.com/images/foo.jpg"
  }
  ```

* Or an object with the `urls` property, if you want to use [responsive images](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images) and the server supports it:

```json
  {
      "urls": {
          "default": "https://example.com/images/foo.jpg",
          "800": "https://example.com/images/foo-800.jpg",
          "1024": "https://example.com/images/foo-1024.jpg",
          "1920": "https://example.com/images/foo-1920.jpg"
      }
  }
  ```

The `"default"` URL will be used in the `src` attribute of the image in the rich-text editor content. Other URLs will be used in the `srcset` attribute, allowing the web browser to select the best one for the geometry of the viewport.

The URL(s) in the server response are used:

* To display the image during the editing (as seen by the user in the editor).
* In the editor content [saved to the database](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html).

#### Error handling

If something went wrong, the server must return an object that contains the `error` property. This will cancel the upload in the editor, for example, allowing the user to select another image if the previous one was too big or did not meet some other validation criteria.

If the `error` object contains a `message`, it will be passed to the [editor notification system](../../../api/module_ui_notification_notification-Notification.html#function-showWarning) and displayed to the user. For the convenience of the users, use clear and possibly specific error messages.

```json
{
    "error": {
        "message": "The image upload failed because the image was too big (max 1.5MB)."
    }
}
```

If the `message` property is missing in the `error` object, the [editor notification system](../../../api/module_ui_notification_notification-Notification.html#function-showWarning) will display the default “Could not upload file: `[filename]`.” message.

#### Upload progress

This upload adapter will notify users about the [file upload progress](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/progress_event) out–of–the–box.

### What’s next

Check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) to learn more about different ways of uploading images in CKEditor 5.

See the [Image feature guide](#ckeditor5/latest/features/images/images-overview.html) to find out more about handling images in CKEditor 5 WYSIWYG editor.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-upload>.

<a id="ckeditor5/latest/features/images/image-upload/using-file-managers.html">source file: "ckeditor5/latest/features/images/image-upload/using-file-managers.html"</a>

## Using file managers

The most convenient way to upload, manage, and insert images into content in CKEditor is by using file managers. [CKBox](https://ckeditor.com/ckbox/) and [CKFinder](https://ckeditor.com/ckfinder/) are our official file managers and file uploaders that let you upload, manage, and insert images and other files.

> **Note**
>
> CKBox and CKFinder are both premium features. [Contact us](https://ckeditor.com/contact/?sales=true#contact-form) to receive an offer tailored to your needs.

### CKBox file manager

CKBox is a modern file management platform with a clean UI and a top-notch UX.

With CKBox you can:

* Organize images and other files into customizable categories.
* Create, rename, and delete folders.
* Delete, rename, and tag files.
* Search files and filter results by numerous properties.
* Easily access recently used files.
* View images in high-resolution full-page preview.
* Define and reuse alternative text for images.
* Get your images served quickly through global AWS S3 CDN or via local options, such as filesystem or SQL databases.

**Read the [dedicated CKBox feature guide](#ckeditor5/latest/features/file-management/ckbox.html)** to learn about its installation and configuration. The guide also lets you try CKBox in action.

### Uploadcare file manager

Uploadcare is a modern file management platform with multiple integrations with services like Dropbox, Facebook, Google Drive, Google Photos and OneDrive.

With Uploadcare you can:

* Upload images directly from:

* Dropbox,
  * Facebook,
  * Google Drive,
  * Google Photos,
  * OneDrive,
  * Local computer,
  * External URL.

* Manage all uploaded images through a dedicated platform.

* Edit images by changing dimensions, applying filters and adjusting various image parameters.

* Get your images served quickly through global AWS S3 CDN.

**Read the [dedicated Uploadcare feature guide](#ckeditor5/latest/features/file-management/uploadcare.html)** to learn about its installation and configuration. The guide also lets you try Uploadcare in action.

### CKFinder file manager

CKFinder is a powerful file manager with various image editing and image upload options.

With CKFinder you can:

* Group images and other files into folders and subfolders.
* Move or copy files between folders.
* Easily filter files.
* Drag and drop images and paste them from the clipboard into the editor.
* Crop, rotate, edit, and resize images.

**Read the [dedicated CKFinder feature guide](#ckeditor5/latest/features/file-management/ckfinder.html)** to learn about its installation and configuration. The guide also lets you try CKFinder in action.

<a id="ckeditor5/latest/features/images/images-captions.html">source file: "ckeditor5/latest/features/images/images-captions.html"</a>

## Image captions

The [`ImageCaption`](../../api/module_image_imagecaption-ImageCaption.html) plugin lets you add captions to images by providing support for the `<figcaption>` element.

### Demo

Click one of the images below and use the contextual image toolbar to toggle the caption on and off. Click the caption to edit it.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

> **Note**
>
> You can change the placement of the image caption by setting [`caption-side`](https://developer.mozilla.org/en-US/docs/Web/CSS/caption-side) in your [content styles](#ckeditor5/latest/getting-started/setup/css.html) for the `.ck-content .image > figcaption` style. Changing it to `caption-side: top` will display the caption above the image.

### Additional feature information

The [`ImageCaption`](../../api/module_image_imagecaption-ImageCaption.html) plugin adds support for the `<figcaption>` element:

```html
<figure class="image">
    <img src="..." alt="...">
    <figcaption>A caption goes here...</figcaption>
</figure>
```

By default, if the image caption is empty, the `<figcaption>` element is not visible to the user. You can click the image to reveal the caption field and write one.

### Installation

To enable this feature, you need to load the [`LinkImage`](../../api/module_link_linkimage-LinkImage.html) plugin. Read more in the [installation guide](#ckeditor5/latest/features/images/images-installation.html).

### Common API

The [`ImageCaption`](../../api/module_image_imagecaption-ImageCaption.html) plugin registers:

* The `'toggleImageCaption'` button (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).
* The [`'toggleImageCaption'` command](../../api/module_image_imagecaption_toggleimagecaptioncommand-ToggleImageCaptionCommand.html)

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-image-optimizer.html">source file: "ckeditor5/latest/features/images/images-image-optimizer.html"</a>

## Image optimizer

The image optimizer lets you edit and enhance images directly in the editor through the premium [CKBox](#ckeditor5/latest/features/file-management/ckbox.html) and [Uploadcare](#ckeditor5/latest/features/file-management/uploadcare.html) integrations.

### Image optimizer by Uploadcare

Uploadcare provides not only basic image editing capabilities, but also image properties adjustments and photo filters, further extending CKEditor 5 feature set.

#### Demo

Click on the image to invoke the image toolbar, then use the image editing button to access the Uploadcare editor.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

#### Image editing

Image optimizer by Uploadcare provides a handful of image editing capabilities, such as:

* rotation, mirroring and flipping,
* cropping,
* [image parameters adjustment](#ckeditor5/latest/features/images/images-image-optimizer.html--image-parameter-adjustment),
* [filters](#ckeditor5/latest/features/images/images-image-optimizer.html--photo-filters).

What is great about image editing in Uploadcare is that all edits are not changing the original image. You can easily go back to the original after the cropping for examples.

#### Image parameter adjustment

For more advanced image customization, Image optimizer by Uploadcare lets you fine-tune image parameters, ensuring you get the exact image you need. You can easily adjust brightness, exposure, gamma, contrast, saturation, vibrance and warmth.

If you are not sure which of the options would yield best results for a specific image, you can use the enhance functionality, which will adjust the image’s colors, saturation, and levels to unveil previously hidden details and bring colors to life automatically.

#### Photo filters

Image optimizer by Uploadcare also provides a wide range of predefined photo filters that can quickly change the visual style of your image. Each of the over 40 filters can be applied with variable intensity.

#### Configuration

To set up the editing capabilities, read the [Uploadcare documentation](#ckeditor5/latest/features/file-management/uploadcare.html--adding-image-editing-capabilities).

All features listed above are available both for images uploaded to Uploadcare before editing and – if you enable the [external images editing option](#ckeditor5/latest/features/file-management/uploadcare.html--editing-external-images) – for images from other sources (external). Keep in mind that external images will be automatically uploaded to your Uploadcare account, once you click the edit image button to enable all the editing capabilities.

### Image optimizer by CKBox

CKBox provides image editing tools, straight from the asset manager or CKEditor 5, making working on content faster and more efficient. It saves time and resources as there is no need to resort to using a dedicated image editing software.

#### Demo

Click on the image to invoke the image toolbar, then use the image editing button to access the CKBox image editor.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

#### Image editing

CKBox premium feature provides editing capabilities such as:

* rotation, mirroring and flipping,
* cropping (freeform and to defined aspect rations),
* resizing (also to predefined presets).

All edits result in a new image being created on your CKBox account. This is done to preserve the original image, for example if it is used in other places. Editing and overwriting images is possible through the CKBox panel.

#### Configuration

To set up the editing capabilities, read the [CKBox documentation](#ckeditor5/latest/features/file-management/ckbox.html--installation).

All the listed features are available both for images uploaded to CKBox before, and – if you enable the [external images editing option](#ckeditor5/latest/features/file-management/ckbox.html--editing-external-images) – images from other sources (external). Keep in mind that external images will be instantly uploaded to your CKBox account, once you click the edit image button to enable all the editing capabilities.

<a id="ckeditor5/latest/features/images/images-inserting.html">source file: "ckeditor5/latest/features/images/images-inserting.html"</a>

## Inserting images

You can insert images by uploading them directly from your disk, but you can also configure CKEditor 5 to let you insert images using URLs. This way you can save time by adding images that are already online.

### Inserting images via a source URL

#### Demo

To upload an image, use the image toolbar button . If you want to add an image through a URL, click the arrow next to the image button and paste the URL in the dropdown panel. To update an existing image, select it and paste a new URL in the dropdown panel.

> **Note**
>
> These demos in this guide present a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

#### Installation

Using the URL of an image, the user may paste it into the editor. To enable this option, install the `ImageInsert` plugin and add the `insertImage` toolbar item to the toolbar (it replaces the standard `uploadImage` button).

**NPM**

```js
import { ClassicEditor, Image, ImageInsert } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Image, ImageInsert, /* ... */  ],
		toolbar: [ 'insertImage', /* ... */  ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Image, ImageInsert } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Image, ImageInsert, /* ... */  ],
		toolbar: [ 'insertImage', /* ... */  ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

This will add a new **Insert image** dropdown in the toolbar.

### Inserting images via pasting a URL into the editor

#### Demo

You can paste an image URL directly into the editor content, and it will be automatically embedded.

#### Installation

The [`AutoImage`](../../api/module_image_autoimage-AutoImage.html) plugin recognizes image links in the pasted content and embeds them shortly after they are injected into the document to speed up the editing. Accepted image extensions are: `jpg`, `jpeg`, `png`, `gif`, and `ico`. Use the following code to enable the plugin in your editor. There is no toolbar configuration for this feature.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [ /* ... */ , Image, AutoImage ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> The image URL must be the only content pasted to be properly embedded. Multiple links (`"http://image.url http://another.image.url"`) as well as bigger chunks of content (`"This link http://image.url will not be auto–embedded when pasted."`) are ignored.

If the automatic embedding was unexpected, for instance when the link was meant to remain in the content as text, simply undo the action. Click the “Undo” button in the toolbar or use the `Ctrl`/`Cmd`+`Z` keystrokes.

### Common API

The [`Image`](../../api/module_image_image-Image.html) plugin registers:

* The `'insertImage'` toolbar dropdown component that aggregates all image insert methods available in the current editor setup.
* The `'insertImageViaUrl'` toolbar button that opens a modal dialog to let you insert an image by specifying the image URL.
* The [`'insertImage'` command](../../api/module_image_image_insertimagecommand-InsertImageCommand.html) that accepts a source (for example a URL) of an image to insert.

The [`ImageUpload`](../../api/module_image_imageupload-ImageUpload.html) plugin registers:

* The `'uploadImage'` toolbar button that opens the native file browser to let you upload a file directly from your disk (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).
* The [`'uploadImage'` command](../../api/module_image_imageupload_uploadimagecommand-UploadImageCommand.html) that accepts the file to upload.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-installation.html">source file: "ckeditor5/latest/features/images/images-installation.html"</a>

## Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the [subfeatures that you need](#ckeditor5/latest/features/images/images-overview.html--image-features) to your plugin list and to the editor toolbar:

**NPM**

```js
import {
	ClassicEditor,
	Image,
	ImageCaption,
	ImageResize,
	ImageStyle,
	ImageToolbar,
	LinkImage
} from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Image, ImageToolbar, ImageCaption, ImageStyle, ImageResize, LinkImage ],
		toolbar: [ 'insertImage', /* ... */ ],
		image: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const {
	ClassicEditor,
	Image,
	ImageCaption,
	ImageResize,
	ImageStyle,
	ImageToolbar,
	LinkImage
} = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Image, ImageToolbar, ImageCaption, ImageStyle, ImageResize, LinkImage ],
		toolbar: [ 'insertImage', /* ... */ ],
		image: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring the toolbar dropdown

The Image feature comes with the unified image insert dropdown component . It automatically collects installed image insert methods. For example, if you install the `ImageUpload` plugin, the corresponding button will automatically appear in the dropdown. You only need to add a button to the toolbar:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        toolbar: [ 'insertImage', /* ... */ ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The feature is pre-configured to include the following image insertion methods:

* `upload` - Upload image from computer. It uses the configured image upload adapter.
* `assetManager` - Opens the installed asset manager (for example the CKBox).
* `url` - Allows inserting an image by directly specifying its URL. Integration provided by `ImageInsertViaUrl` feature.

Note that the insert methods mentioned above will only be added if you install dedicated features. However, not all features are required. If only one is available, it will be indicated by the toolbar dropdown icon.

If you need to limit the methods included in the dropdown (apart from not installing a specific feature) or change their order you can use the `image.insert.integration` configuration option:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        image: {
            insert: {
                // This is the default configuration, you do not need to provide
                // this configuration key if the list content and order reflects your needs.
                integrations: [ 'upload', 'assetManager', 'url' ]
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Configuring the contextual image toolbar

You also need to configure the desired contextual image toolbar items. Notice the [separators](#ckeditor5/latest/getting-started/setup/toolbar.html--separating-toolbar-items) used to organize the toolbar.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        image: {
            toolbar: [
                'imageStyle:block',
                'imageStyle:side',
                '|',
                'toggleImageCaption',
                'imageTextAlternative',
                '|',
                'linkImage'
            ],
            insert: {
                // If this setting is omitted, the editor defaults to 'block'.
                // See explanation below.
                type: 'auto'
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Inline and block images

Inline images can be inserted in the middle of a paragraph or a link just like regular text. Block images, on the other hand, can be inserted only between other blocks like paragraphs, tables, or media. Being larger and existing as standalone content, block images can also have individual captions. Other than that, both types of images can be resized, linked, etc.

By default, the [`Image`](../../api/module_image_image-Image.html) plugin supports both inline and block images, working as a glue for the [`ImageInline`](../../api/module_image_imageinline-ImageInline.html) and [`ImageBlock`](../../api/module_image_imageblock-ImageBlock.html) plugins.

| Loaded plugin     | Available features           |               |
| ----------------- | ---------------------------- | ------------- |
|                   | Block images (with captions) | Inline images |
| `Image` (default) | ✅ yes                        | ✅ yes         |
| `ImageBlock`      | ✅ yes                        | ❌ no          |
| `ImageInline`     | ❌ no                         | ✅ yes         |

By default, if the `image.insert.type` configuration is not specified, all images inserted into the content will be treated as block images. This means that inserting an image inside a paragraph (or other content blocks) will create a new block for the image immediately below or above the current paragraph or block. After insertion, you can transform the block image into an inline image using the [contextual toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar).

If you wish to modify this behavior, the `type` setting in the editor configuration can be used:

```js
ClassicEditor
    .create( {
        image: {
            insert: {
                type: 'auto'
            }
        }
    } );
```

The `type` setting accepts the following three values:

* `'auto'`: The editor determines the image type based on the cursor’s position. For example, if you insert an image in the middle of a paragraph, it will be inserted as inline. If you insert it at the end or beginning of a paragraph, it becomes a block image.
* `'block'`: Always insert images as block elements, placing them below or above the current paragraph or block.
* `'inline'`: Always insert images as inline elements within the current paragraph or block.

If the `type` setting is omitted from the configuration, the behavior defaults to inserting images as a block.

**Important**: If only one type of image plugin is enabled (for example, `ImageInline` is enabled but `ImageBlock` is not), the `image.insert.type` configuration will be effectively ignored and the supported image type will be used.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-linking.html">source file: "ckeditor5/latest/features/images/images-linking.html"</a>

## Linking images

The [`LinkImage`](../../api/module_link_linkimage-LinkImage.html) plugin lets you use images as links.

### Demo

Click one of the images to open the contextual toolbar. Use the link icon to add a link to the image. After you do this, an icon will appear in the top-right corner of the image, indicating there is a link attached to it.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

Here are some use cases where linking images can be useful:

* Linking to a high-resolution version of an image.
* Using images as thumbnails linking to an article or product page.
* Creating banners linking to other pages.

The image link can be added or edited via the image toolbar. An icon in top right corner of the image indicates the presence of a link.

An example source code for block image would look similar to this one:

```html
<figure class="image">
    <a href="...">
        <img src="..." alt="...">
    </a>
    <figcaption>Image caption</figcaption>
</figure>
```

An inline image code would look more like this:

```html
<a href="...">
    Some text <img src="..." alt="..." style="width: 20px">
</a>
```

### Installation

> **Note**
>
> The [`LinkImage`](../../api/module_link_linkimage-LinkImage.html) plugin is available in the [`@ckeditor/ckeditor5-link`](../../api/link.html) package.

### Common API

The [`LinkImage`](../../api/module_link_linkimage-LinkImage.html) plugin registers:

* The `'linkImage'` button that opens the link UI when an image is selected by the user (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).
* The [`'linkImage'` command](../../api/module_link_linkcommand-LinkCommand.html).

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-link>.

<a id="ckeditor5/latest/features/images/images-overview.html">source file: "ckeditor5/latest/features/images/images-overview.html"</a>

## Images in CKEditor 5 (overview)

CKEditor 5 comes with various tools to insert, upload, resize, style, caption, and link images. All these features work out of the box with block, inline, and responsive images alike.

### Demo

To see all the image features in action, check out the demo below. To learn more about individual plugins (sub-features) of the image ecosystem, see the [**Image features**](#ckeditor5/latest/features/images/images-overview.html--image-features) section.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Base image feature

The base image feature does not support any user interface for inserting or managing images. Its sole purpose is to lay ground for other plugins (listed below) to build the target user experience. This pattern (composition of atomic features) is common for CKEditor 5 and allows the developers to build their own customized experience by implementing specific subfeatures differently.

### Image features

The [`@ckeditor/ckeditor5-image`](https://www.npmjs.com/package/@ckeditor/ckeditor5-image) package contains multiple plugins that implement various image-related features. The [`Image`](../../api/module_image_image-Image.html) plugin is at the core of the ecosystem. It provides the basic support for block and inline images. There are many other features that extend the editor’s capabilities:

* The [contextual toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar) available on mouse click gives access to image features.
* [Image captions](#ckeditor5/latest/features/images/images-captions.html) allow adding descriptive text under the image.
* The [image styles](#ckeditor5/latest/features/images/images-styles.html) help control the placement, size, and other characteristics with predefined styles.
* The [text alternative](#ckeditor5/latest/features/images/images-text-alternative.html) tag aids accessibility and SEO, provides additional image description, and supports better navigation.
* [Image resizing](#ckeditor5/latest/features/images/images-resizing.html) lets the user control the dimensions of images in the content.
* [Linking images](#ckeditor5/latest/features/images/images-linking.html) makes it possible to use them as URL anchors.
* A selection of [image upload methods](#ckeditor5/latest/features/images/image-upload/image-upload.html) allows for the most convenient way of adding images. These include support for [inserting an image via a URL](#ckeditor5/latest/features/images/images-inserting.html--inserting-images-via-pasting-a-url-into-the-editor) and even [via pasting a URL into the editor](#ckeditor5/latest/features/images/images-inserting.html--inserting-images-via-a-source-url) along with custom integrations.
* The [CKBox](#ckeditor5/latest/features/file-management/ckbox.html) and Uploadcare [features/uploadcare](#ckeditor5/latest/features/file-management/uploadcare.html) management platforms provide support for [responsive images](#ckeditor5/latest/features/images/images-responsive.html) in CKEditor 5. Responsive images will display correctly on any viewport, enhancing the accessibility, reach, and user experience.
* Both Uploadcare and CKBox provide [editing and optimization capabilities](#ckeditor5/latest/features/images/images-image-optimizer.html), like cropping, resizing, rotating, and flipping right from the image contextual toolbar.

### Image contextual toolbar

The [`ImageToolbar`](../../api/module_image_imagetoolbar-ImageToolbar.html) plugin introduces a contextual toolbar for images. The toolbar appears when an image is selected and can be configured to contain any buttons you want. Usually, these will be image-related options such as the [text alternative](#ckeditor5/latest/features/images/images-text-alternative.html) button, the [image caption](#ckeditor5/latest/features/images/images-captions.html) button, and [image styles](#ckeditor5/latest/features/images/images-styles.html) buttons. The toolbar can also host the image editing button introduced by the [CKBox asset manager](#ckeditor5/latest/features/file-management/ckbox.html). Shown below is an example contextual toolbar with an extended set of buttons.

The image toolbar is configurable using the [`config.image.toolbar`](../../api/module_image_imageconfig-ImageConfig.html#member-styles) property. For instance, to display the caption toggle, text alternative and editing buttons, use the following configuration:

```js
ClassicEditor
    .create( {
        image: {
            toolbar: [ 'toggleImageCaption', 'imageTextAlternative', 'ckboxImageEdit' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Refer to the [image installation](#ckeditor5/latest/features/images/images-installation.html) guide for more details on configuring the features available in the toolbar and to the `#image-toolbar` section of the `Update to 29.x` guide in the [updating from older versions guide](#ckeditor5/latest/updating/guides/updating-from-older-versions.html), as important changes were introduced in that version. You can also check the [editor toolbar](#ckeditor5/latest/getting-started/setup/toolbar.html) guide.

See the common API of image-related features such as [`ImageStyle`](../../api/module_image_imagestyle-ImageStyle.html), [`ImageResize`](../../api/module_image_imageresize-ImageResize.html), and [`LinkImage`](../../api/module_link_linkimage-LinkImage.html) to learn more about available image toolbar buttons.

### Image `width` and `height` attributes

Starting with v40.0.0, the image’s `width` and `height` attributes are retained by the editor when it is loaded. Adding them is done to ensure that the image dimensions ratio is properly kept when an image is styled or aligned and that it always looks like it should, rather than forcing the image size within the content. This ensures high-quality output.

The attributes are now handled as follows:

* Upon [uploading an image file](#ckeditor5/latest/features/images/image-upload/image-upload.html) or [inserting it](#ckeditor5/latest/features/images/images-inserting.html) into the editor content, the CKEditor 5 image feature fetches these dimensions from the file. The editor then adds these properties to the markup, just like the [text alternative tag](#ckeditor5/latest/features/images/images-text-alternative.html).
* If the user uses an upload adapter and the server sends back the uploaded image with the `width` or `height` parameters already set, these existing values are not overwritten.
* The editor will not change already existing content. It means, loading HTML (that is `setData`) with images does not set up these attributes.
* Changes to an image (such as resize, etc.) will trigger the creation of those attributes. These attributes are crucial to proper content handling, and actions on a current image that does not have these improve this image’s markup.
* The `aspect-ratio` attribute has been added to the image’s properties to handle situations when the file is resized or scaled with a tweaked aspect ratio.

These image properties can be further controlled via CSS styles. If you need to crop, resize, rotate, or mirror flip your images, you can use the [CKBox asset manager](#ckeditor5/latest/features/file-management/ckbox.html) to achieve that.

> **Note**
>
> Due to the introduction of this new behavior in CKEditor 5 v40.0.0, the `width` and `height` attributes are now used to preserve the image’s natural width and height. The information about a resized image is stored in the `resizedWidth` and `resizeHeight` attributes.

### Typing around images

To type before or after an image easily, select the image, then press the Arrow key (`←` or `→`) once, depending on where you want to add content – before or after respectively. The image becomes no longer selected and whatever text you type will appear in the desired position.

You can also use the **Insert paragraph** handles on the bottom or top edge of the selected image to add a paragraph below or above the image, respectively.

### Image editing

While the image feature does not provide native image editing support, the [CKBox](#ckeditor5/latest/features/file-management/ckbox.html) and Uploadcare [features/uploadcare](#ckeditor5/latest/features/file-management/uploadcare.html) premium features provide [editing capabilities](#ckeditor5/latest/features/images/images-image-optimizer.html) such as cropping to presets, flipping, or rotating.

### Common API

The `Image` plugin registers:

* The [`insertImage`](../../api/module_image_image_insertimagecommand-InsertImageCommand.html) command (alias: `imageInsert`).
* The [`insertImage`](../../api/module_image_imageconfig-ImageInsertConfig.html) dropdown component (to use in the toolbar).

> **Note**
>
> The basic image plugin is minimal and provides the foundation for the image ecosystem. Subplugins register most UI components (buttons, toolbars) and additional commands. See the feature guides linked in the [Image features](#ckeditor5/latest/features/images/images-overview.html--image-features) section for more information about their APIs.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-resizing.html">source file: "ckeditor5/latest/features/images/images-resizing.html"</a>

## Resizing images

The image resize feature lets you change the width of images in your content. It is implemented by the [`ImageResize`](../../api/module_image_imageresize-ImageResize.html) plugin.

### Methods to resize images

The editor offers different ways to resize images either by using “resize handles” or by using dedicated UI components – either a dropdown or standalone buttons.

The [`ImageResize`](../../api/module_image_imageresize-ImageResize.html) plugin enables the four resize handles displayed over the selected image. The user can resize the image by dragging them. You can configure the feature to use either percentage (default) or pixel values.

The plugin also gives you the ability to change the size of the image through the on-click image toolbar. You can set an optional static configuration with [`resizeOptions`](../../api/module_image_imageconfig-ImageConfig.html#member-resizeOptions) and choose whether you want to use a dropdown or a set of standalone buttons.

#### Using resize handles

In this case, you can resize an image by dragging square handles displayed in each of its corners. After you enable image resizing, this option does not require any additional configuration.

Use the corner handles to resize the image and adjust it to the text as needed. You can also use the alignment options from the image toolbar to achieve the desired effect.

Images can also be pre-resized using styling, as shown below (the last three images are hard-set to 28% for visual consistency).

> **Note**
>
> For clarity, all demos in this guide present a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

You can configure resizing images by handles in two different ways in the CKEditor 5 WYSIWYG editor:

* By installing the [`ImageResize`](../../api/module_image_imageresize-ImageResize.html) plugin. It contains **all** needed features (`ImageResizeEditing`, `ImageResizeHandles`, `ImageResizeButtons`) as described in the [installation](#ckeditor5/latest/features/images/images-resizing.html--installation) of this guide.

* By installing the combination of [`ImageResizeEditing`](../../api/module_image_imageresize_imageresizeediting-ImageResizeEditing.html) and [`ImageResizeHandles`](../../api/module_image_imageresize_imageresizehandles-ImageResizeHandles.html) plugins. This will not load the unnecessary `ImageResizeButtons` plugin:

**NPM**

```js
import { ClassicEditor, Image, ImageResizeEditing, ImageResizeHandles } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Image, ImageResizeEditing, ImageResizeHandles, /* ... */ ],
		image: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Image, ImageResizeEditing, ImageResizeHandles } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Image, ImageResizeEditing, ImageResizeHandles, /* ... */ ],
		image: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

Both ways enable resize handles by default.

#### Using resize dropdown

In this case, the user can choose from a set of predefined options. You can display these options as a dropdown in the image toolbar available after the user clicks the image.

To use this option, you need to [enable image resizing](#ckeditor5/latest/features/images/images-resizing.html--installation) and configure the available [resize options](../../api/module_image_imageconfig-ImageConfig.html#member-resizeOptions). Then add the dropdown to the image toolbar configuration.

```js
const imageConfiguration = {
    resizeOptions: [
        {
            name: 'resizeImage:original',
            value: null,
            label: 'Original'
        },
        {
            name: 'resizeImage:custom',
            label: 'Custom',
            value: 'custom'
        },
        {
            name: 'resizeImage:40',
            value: '40',
            label: '40%'
        },
        {
            name: 'resizeImage:60',
            value: '60',
            label: '60%'
        }
    ],
    toolbar: [ 'resizeImage', /* ... */ ]
}
```

Try out the live demo of the resize dropdown available in the image toolbar:

> **Note**
>
> Images in the example below were prepared to match the exact aspect ratios, so they can be displayed together, with equal heights.
>
> If you want to define the possible aspect ratios of the inserted images, for example, allow the user to insert 1:1 and 40% width, and 1:2 and 20% width images, you should use the [image style feature](#ckeditor5/latest/features/images/images-styles.html--configuring-the-styles).
>
> The example of CSS fixing the image aspect ratio is in the [last example](#ckeditor5/latest/features/images/images-resizing.html--aspect-ratio-css) of this guide.

#### Using standalone resize buttons

In this case, the resize options are displayed as separate buttons. The benefit of this solution is the smoothest UX as the user needs just one click to resize an image.

```js
const imageConfiguration = {
    resizeOptions: [
        {
            name: 'resizeImage:original',
            value: null,
            icon: 'original'
        },
        {
            name: 'resizeImage:custom',
            value: 'custom',
            icon: 'custom'
        },
        {
            name: 'resizeImage:50',
            value: '50',
            icon: 'medium'
        },
        {
            name: 'resizeImage:75',
            value: '75',
            icon: 'large'
        }
    ],
    toolbar: [
        'resizeImage:50',
        'resizeImage:75',
        'resizeImage:original',
        'resizeImage:custom',
        // More toolbar options.
        // ...
    ]
}
```

Try out the live demo of the individual resize buttons available in the image toolbar:

### Disabling image resize handles

If you want to configure the editor in such a way that the user can only resize images by buttons, you can do so by omitting the [`ImageResizeHandles`](../../api/module_image_imageresize_imageresizehandles-ImageResizeHandles.html) plugin.

As a result, your plugin setup should look like this: `plugins: [ 'ImageResizeEditing', 'ImageResizeButtons', /* ... */ ]` as opposed to `plugins: [ 'ImageResize', /* ... */ ]`.

This will enable the image resize feature only through the chosen UI: either a [dropdown](#ckeditor5/latest/features/images/images-resizing.html--using-resize-dropdown) or [standalone buttons](#ckeditor5/latest/features/images/images-resizing.html--using-standalone-resize-buttons) in the image toolbar.

**NPM**

```js
import { ClassicEditor, Image, ImageResizeButtons, ImageResizeEditing, ImageToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		plugins: [ Image, ImageResizeEditing, ImageResizeButtons, ImageToolbar, /* ... */ ],
		image: {
			resizeOptions: [
			{
				name: 'resizeImage:original',
				value: null,
				icon: 'original'
			},
			{
				name: 'resizeImage:custom',
				value: 'custom',
				icon: 'custom'
			},
			{
				name: 'resizeImage:50',
				value: '50',
				icon: 'medium'
			},
			{
				name: 'resizeImage:75',
				value: '75',
				icon: 'large'
			}
		],
		toolbar: [
			'resizeImage:50',
			'resizeImage:75',
			'resizeImage:original',
			'resizeImage:custom',
			// More toolbar options.
			// ...
		] }
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Image, ImageResizeButtons, ImageResizeEditing, ImageToolbar } = CKEDITOR;

### Markup and styling

When you resize an image, the inline `width` style is used and the editor assigns the `image_resized` class to the `<figure>` element:

```html
<figure class="image image_resized" style="width: 75%;">
    <img src="..." alt="...">
</figure>
```

The `image_resized` class is used to disable `max-width` assigned by the [image styles](#ckeditor5/latest/features/images/images-styles.html) if one is applied to this image. For instance, the “side image” style is defined like this:

```css
.ck-content .image-style-side {
    max-width: 50%;
    float: right;
    margin-left: var(--ck-image-style-spacing);
}
```

And the `max-width` gets overridden by the following rule:

```css
.ck-content .image.image_resized {
    max-width: 100%;
}
```

Another concern when styling resized images is that by default, CKEditor 5 uses `display: table` on `<figure class="image">` elements to make it take up the size of the `<img>` element inside it. Unfortunately, [browsers do not yet support using `max-width` and `width` on the same element if it is styled with `display: table`](https://stackoverflow.com/questions/4019604/chrome-safari-ignoring-max-width-in-table/14420691#14420691). Therefore, `display: block` needs to be used when resizing the image:

```css
.ck-content .image.image_resized {
    display: block;
    box-sizing: border-box;
}

.ck-content .image.image_resized img {
    width: 100%;
}

.ck-content .image.image_resized > figcaption {
    display: block;
}
```

### Using pixel values instead of percentage width

Using percentage widths ensures that the content stays responsive when displayed in places other than the WYSIWYG editor. When the user makes an image take up, for example, 60% of the content’s width in the editor, if you ever change the width of the target page (where this content is displayed), the image will still take up 60% of that space. The same is true if the page is responsive and adjusts to the viewport’s width.

If you configured the editor to use pixel values, the image could take up, for example, too much space after you introduced a new layout for your website.

However, there are cases where you may prefer pixel values. You can thus configure the editor to use them by setting the [`config.image.resizeUnit`](../../api/module_image_imageconfig-ImageConfig.html#member-resizeUnit) option:

```js
ClassicEditor
    .create( {
        image: {
            resizeUnit: 'px',
            resizeOptions: [
                {
                    name: 'resizeImage:original',
                    label: 'Original',
                    value: null
                },
                {
                    name: 'resizeImage:custom',
                    label: 'Custom',
                    value: 'custom'
                },
                {
                    name: 'resizeImage:100',
                    label: '100px',
                    value: '100'
                },
                {
                    name: 'resizeImage:200',
                    label: '200px',
                    value: '200'
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The following demo uses CSS to set up the fixed image aspect ratio, so a 200px wide image automatically gets the same height.

```css
.ck.ck-content .image {
    position: relative;
}
.ck.ck-content .image img {
    position: absolute;
    left: 0;
    top: 0;
    width: 100%;
    height: 100%;
    object-fit: cover;
    border-radius: 50%;
}
.ck.ck-content .image::before {
    content: '';
    padding-top: 100%;
    display: block;
}
```

Check out the difference in the live demo below:

### Image optimization and responsive images

When using the [CKBox file manager](#ckeditor5/latest/features/file-management/ckbox.html) service, it produces sets of resized, optimized images. The users can invoke these resized versions if needed. To learn more about these capabilities, refer to the [responsive images](#ckeditor5/latest/features/images/images-responsive.html) guide and the [CKBox conversion](#ckbox/latest/features/images/conversion.html) guide.

### Installation

To enable it you need to install the [`ImageResize`](../../api/module_image_imageresize-ImageResize.html) plugin, which contains **all** needed features (`ImageResizeEditing`, `ImageResizeHandles`, `ImageResizeButtons`):

**NPM**

```js
import { ClassicEditor, Image, ImageResize } from 'ckeditor5';

ClassicEditor
	.create( {
		// ... Other configuration options ...
		plugins: [ Image, ImageResize, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Image, ImageResize } = CKEDITOR;

ClassicEditor
	.create( {
		// ... Other configuration options ...
		plugins: [ Image, ImageResize, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Common API

The [`ImageResize`](../../api/module_image_imageresize-ImageResize.html) plugin registers:

* Image resize buttons (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).
* The [`'resizeImage'` command](../../api/module_image_imageresize_resizeimagecommand-ResizeImageCommand.html) that accepts the target width.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-responsive.html">source file: "ckeditor5/latest/features/images/images-responsive.html"</a>

## Responsive images

Responsive images adapt to the reader’s screen size, which speeds up loading and saves bandwidth. In CKEditor 5, they are provided by the [CKBox asset manager](#ckeditor5/latest/features/file-management/ckbox.html). With a single image upload, several optimized versions of that image are created, each for a different size of the display. The CKBox feature produces a `<picture>` element with a set of optimized images. The browser will automatically load the image with the dimensions most suitable for the presented page resolution.

### Demo

Observe the responsive image in the demo. You can also add another one with the CKBox toolbar button . Resize your browser window to change the editor viewport and observe how the editor automatically serves the size-adjusted, optimized image.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Why responsive images?

Responsive images have two main advantages over “traditional” image delivery:

* **They save the data transfer**. There are countless device and screen size combinations that can be used to display images in your application (smartphones, tablets, laptops, etc.). You do not need to serve the same full–scale images to all of them, though. Using CKBox guarantees only the particular size variant corresponding to the user’s screen size is served, minimizing the amount of data transferred to the client. For large images, this can save up to 90% of the transferred data.
* **They load faster**. Because only the image matching the size of the screen is transferred, in most cases it can be loaded and displayed much faster than a “regular” full–scale image. The faster it loads, the sooner the users can see it, which greatly improves the user experience of your application. You no longer need to wait for ages for high–resolution photos to load on a tiny smartphone screen.
* **Accessibility**. By catering to different user devices, you may better address the users’ different needs. Paired with the [text alternative](#ckeditor5/latest/features/images/images-text-alternative.html) it makes your content more accessible.

### Responsive images in the markup

The image appears in the editor content as a `<picture>` element. The `<picture>` element contains the original `<img>` and the `<source>` element, which defines alternative versions of images using the `srcset` attribute.

The `srcset` attribute specifies the image variants dedicated to the various screen sizes for the web browser to choose from (360px, 720px, 1080px, 1440px, etc.).

For instance, the `image.jgeg` file uploaded by the user will have the following markup:

```html
    <picture>
        <source srcset="https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/160.webp 160w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/320.webp 320w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/480.webp 480w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/640.webp 640w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/800.webp 800w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/960.webp 960w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/1120.webp 1120w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/1280.webp 1280w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/1440.webp 1440w,
        https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/1600.webp 1600w"
        sizes="(max-width: 1600px) 100vw, 1600px"
        type="image/webp">
        <img src="https://ckbox.cloud/huTfIec9s6SodytaMc9x/assets/1aUrKtJqioMR/images/1600.jpeg" alt="Snowdrop" data-ckbox-resource-id="M0tgMczsDphw">
    </picture>
```

The variety of the image sizes in the `srcset` attribute allows the web browser to choose the best one for the particular screen size. As a result, it loads faster and with less data transferred. Read the [CKBox responsive images](#ckbox/latest/features/images/responsive-images.html) guide to learn how are the intermediate file sizes calculated.

Regardless of the original file format, the responsive versions will be served as `.webp`.

> **Note**
>
> CKBox converts image formats and resizes images on the fly. Refer to the [CKBox image conversion](#ckbox/latest/features/images/conversion.html) guide to find out how to do it.

### Installation

For detailed information on how to configure and use CKBox, please refer to the [CKBox file manager](#ckeditor5/latest/features/file-management/ckbox.html--installation) installation guide.

<a id="ckeditor5/latest/features/images/images-styles.html">source file: "ckeditor5/latest/features/images/images-styles.html"</a>

## Image styles

The image styles feature lets you adjust the appearance of images. It works by applying CSS classes to images or changing their type from inline to block or vice versa.

### Overview

This package allows for adjusting the image appearance by:

* **Applying CSS classes** – Adding a particular [predefined](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles) or [custom](#ckeditor5/latest/features/images/images-styles.html--configuring-the-styles) CSS class or removing any style-related CSS class.
* **Managing the HTML representation** by changing the image type from inline to block and vice versa. Applying a style may change the type of the image, depending on the configuration of the style.

> **Note**
>
> The actual styling of the images is the job of the integrator. CKEditor 5 WYSIWYG editor comes with some default styles, but they will only be applied to the images inside the editor. The integrator needs to style them appropriately on the target pages.
>
> You can find the source of the default styles applied by the editor here: [`ckeditor5-image/theme/index-content.css`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-image/theme/index-content.css).
>
> Read more about [styling the content of the editor](#ckeditor5/latest/getting-started/setup/css.html).

#### Image classes

The styles applied to the image can either add the style-related class or remove it. This behavior depends on the particular configuration of the [`ImageStyleOptionDefinition`](../../api/module_image_imageconfig-ImageStyleOptionDefinition.html). Only the definition with the [`isDefault`](../../api/module_image_imageconfig-ImageStyleOptionDefinition.html#member-isDefault) flag set to true will remove any applied image style-related class.

> **Warning**
>
> The `ImageStyle` plugin does not provide any mechanism to apply a default CSS class to newly inserted images. The integrator should handle the initial image appearance by defining the proper custom [content styles](#ckeditor5/latest/getting-started/setup/css.html). If desired, the default image appearance customization can be done by overriding the following CSS rules:
>
> * `.ck-content .image-inline` for the inline images,
> * `.ck-content .image` for the block images.

#### Inline and block images

You can display images in the editor as either inline or block.

The inline-type images are represented as inline HTML elements. You can insert them in the middle of a paragraph or in a link just like regular text. The HTML representation of the inline image looks like this:

* `<span class=”image-style-class”><img></img></span>` in the editable.
* `<img class=”image-style-class”></img>` in the HTML content retrieved by the [`getData()`](../../api/module_core_editor_editor-Editor.html#function-getData) method.

Block-type images can be inserted only between other blocks like paragraphs, tables, or media. The HTML representation of the block image looks like this:

* `<figure class=”image image-style-class”><img></img></figure>`.

**Switching between these two types of images can be executed by applying or removing a style from the image**. Each of the defined style options provides a list of the image types that it can apply to. Applying a style may change the type of the image, depending on the configuration of the style.

When you insert a new image, the editor will, by default, choose the optimal image type based on the context of the insertion (for example, the current selection/position and [availability of plugins](#ckeditor5/latest/features/images/images-installation.html--inline-and-block-images)). You can control the default type of the newly inserted image using the [`image.insert.type` configuration](../../api/module_image_imageconfig-ImageInsertConfig.html#member-type).

> **Note**
>
> CKEditor 5 supports both block and inline images, but it is also possible to [disable one of these types](#ckeditor5/latest/features/images/images-installation.html--inline-and-block-images).

### UI

You can apply a style by using one of the toolbar buttons created by the `ImageStyle` plugin. Each of the defined styles (both [default](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles) and [custom](#ckeditor5/latest/features/images/images-styles.html--configuring-the-styles)) will be registered under the name `imageStyle:image-style-name` in the [`ComponentFactory`](../../api/module_ui_componentfactory-ComponentFactory.html). You can then add it to the image or main toolbar by referencing this name.

The default image toolbar has its standard configuration already set.

* The default UI of the classic, inline, balloon, and balloon block editor types consists of a set of buttons to apply the [semantical styles](#ckeditor5/latest/features/images/images-styles.html--semantical-styles) to support creating structured content. [**See a live example**](#ckeditor5/latest/features/images/images-styles.html--semantical-example).
* The document editor type UI uses several buttons for applying [presentational styles](#ckeditor5/latest/features/images/images-styles.html--presentational-styles) and also uses the [semantical styles](#ckeditor5/latest/features/images/images-styles.html--semantical-styles) to reset the image appearance to default. [**See a live example**](#ckeditor5/latest/features/images/images-styles.html--presentational-example).

You can also create a completely custom image styles UI, setting your icons and tooltips, and grouping the image style buttons into [custom dropdowns](../../api/module_image_imageconfig-ImageStyleDropdownDefinition.html). Read more about it in the [**configuring the styles**](#ckeditor5/latest/features/images/images-styles.html--configuring-the-styles) section of this guide.

### Approaches to styling images

CKEditor 5 offers two basic approaches to styling the images:

* A particular style can define the image type, so you can style it, for example, as an avatar, a banner, or an emoticon. It will be called a [“semantical style”](#ckeditor5/latest/features/images/images-styles.html--semantical-styles) since it refers to the purpose of the particular image.
* Sometimes the user should be able to granularly control how an image is presented thanks to the ability to set the size and alignment separately and completely arbitrarily. The style that defines the image alignment will be called a [“presentational”](#ckeditor5/latest/features/images/images-styles.html--presentational-styles) one since it refers to the appearance of the image.

> **Note**
>
> The distinction made above is purely theoretical. Setting up both semantical and presentational styles happens in the same way, using the [`ImageConfig#styles`](../../api/module_image_imageconfig-ImageConfig.html#member-styles) configuration.

#### Semantical styles

A semantical style lets the user choose from predefined appearances of the images. The user is not able to set the image border, alignment, margins, width, etc. separately. Instead, they can pick one of the styles defined by the developer who prepared the WYSIWYG editor integration. Check the list of the available semantical styles in the [table](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles) below. Semantical styles give the integrator the ability to put a wide range of predefined image appearances at the user’s disposal. This gives the developer control over how the users style their images and makes the user’s life easier by setting many properties at once.

> **Note**
>
> Try to understand what use cases your system needs to support and define semantic options accordingly. Defining useful and clear styles is one of the steps toward a good user experience and clear, portable output. The “side image” in the example below is displayed as a floated image on wide screens and as a normal image on low-resolution screens (for example, mobile browsers).

> **Warning**
>
> While you can combine semantical styles with manual [image resizing](#ckeditor5/latest/features/images/images-resizing.html), these features were not designed to be used together. Semantical styles usually also affect the image size.
>
> If you want to enable image resizing, use [presentational image styles](#ckeditor5/latest/features/images/images-styles.html--presentational-styles) instead. You can also define custom semantical styles to make sure that there are no conflicts with the image resizing feature.

Most of the editor types support editing structured content. This requires passing the control over the possible image appearances to the developer. We thus introduce a UI containing a set of buttons applying the semantical styles (taken from the [default styles](#ckeditor5/latest/features/images/images-styles.html--styles-table) listed below).

The example below shows an editor with such a basic configuration. There are three types of images:

* **A block image** – A representation of a block image with no style-related CSS class.
* **An inline image** – A representation of an inline image with no style-related CSS class.
* **A side image** – A semantical style with the `image-style-side` CSS class applied to it

You can change the style of an individual image using the contextual toolbar that opens after clicking the image.

#### Presentational styles

Presentational styles do not relate to any special meaning of the content. They directly control the visual aspect of an image. The default available presentational styles determine the image alignment behavior. Check the list of the available semantical styles in the [table](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles) below.

> **Note**
>
> You should combine presentational image styles with the optional [image resizing feature](#ckeditor5/latest/features/images/images-resizing.html) as these features were designed to be used together. The image width is then controlled by the image resize feature, while the alignment is controlled by the image style feature.
>
> If you do not enable the image resize feature in your setup while using the default presentational styles, your images will always retain their original sizes (up to 100% of the editor width). The alignment may thus not be visible.
>
> If you do not want to enable image resizing, you can use [semantical styles](#ckeditor5/latest/features/images/images-styles.html--semantical-styles) to set the image dimensions.

The example editor below uses predefined presentational image styles represented by buttons grouped in the dropdowns according to the way the image is displayed in the document:

* **Inline images** – Displayed inside a line of text. It is the default style for the inline images and it does not apply any CSS class to the image.

* **Images wrapped with text** – These are the images with the CSS `float` property. They can be either in the inline or block mode. To keep the HTML output valid, the block images (wrapped with the `<figure>` tags) can only be placed before or after paragraphs, not in the middle of them. It contains the following image styles:

* `'align-left'` ,
  * `'align-right'` .

* **Images placed between the paragraphs** – Block images without the CSS `float` property. It contains the following image styles:

* `'align-block-left'` ,
  * `'align-block-right'` ,
  * `'block'` – This style is the default one for block images and it does not apply any CSS class to the image.

You can change the style of an individual image using the contextual toolbar invoked after you click an image.

The example is also configured to use the [image resize feature](#ckeditor5/latest/features/images/images-resizing.html) with three [resize options](../../api/module_image_imageconfig-ImageConfig.html#member-resizeOptions) available: `'resizeImage:original'`, `'resizeImage:50'`, and `'resizeImage:75'`. They allow you to set the image width in the editor to the original image size (up to 100% of the editor window width), 50%, and 75%. You can also use the resize handles to set a custom size of the image.

See the result below:

This set of buttons and styles is available by default in the document editor and does not require any additional customization:

```js
import { DecoupledEditor } from 'ckeditor5';

DecoupledEditor.create( {
    root: {
        element: document.querySelector( '#editor' )
    }
} ).then( /* ... */ );
```

> **Warning**
>
> At the moment you cannot apply multiple styles (classes) to the image at the same time. To apply many CSS rules to the image (like a red border and a left alignment), you should probably consider using the [semantical styles](#ckeditor5/latest/features/images/images-styles.html--semantical-styles).

### Configuring the styles

There are three ways of defining the image styles in the editor configuration:

* Using one of the predefined [default styles](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles).
* Modifying one of the styles mentioned above. You can change the class it applies to the image, the icon, the tooltip, and the supported image type.
* Defining a completely custom image style.

> **Note**
>
> Reusing (or modifying) predefined styles has the following advantage: CKEditor 5 will use its official translations provided for the defined button titles.

#### Demo

The editor example below shows what you can achieve by customizing the visual representation of images and the UI for setting image styles (icons, tooltips, and dropdowns).

This editor uses custom image styles, custom image toolbar configuration with [declarative dropdowns](../../api/module_image_imageconfig-ImageStyleDropdownDefinition.html), and some modified [default styles](#ckeditor5/latest/features/images/images-styles.html--ready-to-use-styles). You can find some more examples of using and modifying these styles in the [`config.image.styles`](../../api/module_image_imageconfig-ImageConfig.html#member-styles) API documentation.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        image: {
            styles: {
                // Defining custom styling options for the images.
                options: [ {
                    name: 'side',
                    icon: sideIcon,
                    title: 'Side image',
                    className: 'image-side',
                    modelElements: [ 'imageBlock' ]
                }, {
                    name: 'margin-left',
                    icon: leftIcon,
                    title: 'Image on left margin',
                    className: 'image-margin-left',
                    modelElements: [ 'imageInline' ]
                }, {
                    name: 'margin-right',
                    icon: rightIcon,
                    title: 'Image on right margin',
                    className: 'image-margin-right',
                    modelElements: [ 'imageInline' ]
                },
                // Modifying icons and titles of the default inline and
                // block image styles to reflect its real appearance.
                {
                    name: 'inline',
                    icon: inlineIcon
                }, {
                    name: 'block',
                    title: 'Centered image',
                    icon: centerIcon
                } ]
            },
            toolbar: [ {
                // Grouping the buttons for the icon-like image styling
                // into one dropdown.
                name: 'imageStyle:icons',
                title: 'Alignment',
                items: [
                    'imageStyle:margin-left',
                    'imageStyle:margin-right',
                    'imageStyle:inline'
                ],
                defaultItem: 'imageStyle:margin-left'
            }, {
                // Grouping the buttons for the regular
                // picture-like image styling into one dropdown.
                name: 'imageStyle:pictures',
                title: 'Style',
                items: [ 'imageStyle:block', 'imageStyle:side' ],
                defaultItem: 'imageStyle:block'
            }, '|', 'toggleImageCaption', 'linkImage'
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

It also applies multiple CSS rules to not only display custom image styles (the `'image-margin-right'`, `'image-margin-left'` and `'image-side'` classes) properly, but also to provide the default [content styles](#ckeditor5/latest/getting-started/setup/css.html), so the appearance of headers, paragraphs, links, captions and newly inserted images is consistent.

The most important rules regarding the image styling are presented below. You can see the complete content style sheet [here](https://github.com/ckeditor/ckeditor5/blob/a95554244e9fc71af5aa9e53c6841f114c6d2483/packages/ckeditor5-image/docs/_snippets/features/image-semantical-style-custom.html).

```css
/* Defining the default content styles for the block images.
This is what the newly inserted image without any
style-specific class will look like. */
.ck-content .image {
    margin-top: 50px;
    margin-bottom: 50px;
}
.ck-content .image img {
    border-radius: 50%;
    width: 180px;
    height: 180px;
    object-fit: cover;
    filter: grayscale(100%) brightness(70%);
    box-shadow: 10px 10px 30px #00000078;
}
.ck-content .image::before {
    content: '';
    width: 100%;
    height: 100%;
    background-color: #1138b0;
    top: 5%;
    left: 5%;
    position: absolute;
    border-radius: 50%;
}
.ck-content .image::after {
    content: '';
    width: 200%;
    height: 200%;
    background-image: url(../../assets/img/image-context.svg);
    background-size: contain;
    background-repeat: no-repeat;
    position: absolute;
    top: -60%;
    pointer-events: none;
    left: -60%;
}

/* Defining the default content styles for the inline images.
This is what the newly inserted image without any
style-specific class will look like. */
.ck-content .image-inline {
    margin: 0 4px;
    vertical-align: middle;
    border-radius: 12px;
}
.ck-content .image-inline img {
    width: 24px;
    max-height: 24px;
    min-height: 24px;
    filter: grayscale(100%);
}

/* Defining the custom content styles for the images
placed on the side of the editing area. */
.ck-content .image.image-side {
    float: right;
    margin-right: -200px;
    margin-left: 50px;
    margin-top: -50px;
}
.ck-content .image.image-side img {
    width: 360px;
    height: 360px;
}

/* Defining the custom content styles for the images
placed on the editor margins. */
.ck-content .image-inline.image-margin-left,
.ck-content .image-inline.image-margin-right {
    position: absolute;
    margin: 0;
    top: auto;
}
.ck-content .image-inline.image-margin-left {
    left: calc( -12.5% - var(--icon-size) / 2 );
}
.ck-content .image-inline.image-margin-right {
    right: calc( -12.5% - var(--icon-size) / 2 );
}
.ck-content .image-inline.image-margin-left img,
.ck-content .image-inline.image-margin-right img {
    filter: none;
}

/* Defining the custom content styles for the image captions. */
.ck-content .image > figcaption {
    z-index: 1;
    position: absolute;
    bottom: 20px;
    left: -20px;
    font-style: italic;
    border-radius: 41px;
    background-color: #ffffffe8;
    color: #1138b0;
    padding: 5px 12px;
    font-size: 13px;
    box-shadow: 0 0 18px #1a1a1a26
}
```

#### Ready-to-use styles

The `ImageStyle` plugin provides a set of default styles depending on the loaded plugins. The table below presents the availability of these styles and the image behavior caused by an application of a particular style.

| Style name        | Required plugins | Converts to | Applies class                       | Type           |
| ----------------- | ---------------- | ----------- | ----------------------------------- | -------------- |
| "block"           | `ImageBlock`     | block       | removes all classes (default style) | semantical     |
| "inline"          | `ImageInline`    | inline      | removes all classes (default style) | semantical     |
| "side"            | `ImageBlock`     | block       | `image-style-side`                  | semantical     |
| "alignLeft"       | any              | -           | `image-style-align-left`            | presentational |
| "alignRight"      | any              | -           | `image-style-align-right`           | presentational |
| "alignBlockLeft"  | `ImageBlock`     | block       | `image-style-align-block-left`      | presentational |
| "alignBlockRight" | `ImageBlock`     | block       | `image-style-align-block-right`     | presentational |
| "alignCenter"     | `ImageBlock`     | block       | `image-style-align-center`          | presentational |

### Installation

Check out the [image feature installation guide](#ckeditor5/latest/features/images/images-installation.html) to learn how to enable this feature.

### Common API

The [`ImageStyle`](../../api/module_image_imagestyle-ImageStyle.html) plugin registers:

* A button for each defined style, for example: `'imageStyle:block'` and `'imageStyle:side'` (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).

* The [`'imageStyle'` command](../../api/module_image_imagestyle_imagestylecommand-ImageStyleCommand.html). It accepts a value based on the [`image.styles`](../../api/module_image_imageconfig-ImageConfig.html#member-styles) configuration option (for example, `'block'` and `'side'`):

```js
  editor.execute( 'imageStyle', { value: 'side' } );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/images/images-text-alternative.html">source file: "ckeditor5/latest/features/images/images-text-alternative.html"</a>

## Image text alternative

Image text alternative (the `alt` attribute) helps screen reader users navigate and understand the document. It also provides meaningful image descriptions to search engine crawlers.

### Demo

The editor below has the base image feature enabled. Click any of the images and use the contextual image toolbar to edit the text alternative.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The `alt` attribute is essential for both accessibility and [SEO](https://en.wikipedia.org/wiki/Search_engine_optimization).

CKEditor 5 provides support for alternate image text using the [`ImageTextAlternative`](../../api/module_image_imagetextalternative-ImageTextAlternative.html) plugin. The `alt` attribute is supported by both block and inline images in the editor output data:

```html

<figure class="image">
    <img src="..." alt="Description of an image">
    <figcaption>...</figcaption>
</figure>

<p>Some text followed by an image <img src="..." alt="Description of an image">.</p>
```

> **Note**
>
> This feature follows the markup proposed by the [Editor Recommendations](https://ckeditor.github.io/editor-recommendations/features/image.html) project.

#### Utilizing CKBox to manage text alternatives

When using the [CKBox file manager](#ckeditor5/latest/features/file-management/ckbox.html), you can utilize its [metadata management tools](https://ckeditor.com/docs/ckbox/latest/features/file-management/assets/metadata.html#description) to set or change the text alternative. CKBox automatically adds the metadata `description` to the `alt` tag.

### Installation

Check out the [image features installation guide](#ckeditor5/latest/features/images/images-installation.html) to learn how to enable this feature.

### Common API

The [`ImageTextAlternative`](../../api/module_image_imagetextalternative-ImageTextAlternative.html) plugin registers:

* The `'imageTextAlternative'` button (to use in the [image toolbar](#ckeditor5/latest/features/images/images-overview.html--image-contextual-toolbar)).
* The [`'imageTextAlternative'` command](../../api/module_image_imagetextalternative_imagetextalternativecommand-ImageTextAlternativeCommand.html).

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-image>.

<a id="ckeditor5/latest/features/indent.html">source file: "ckeditor5/latest/features/indent.html"</a>

## Block indentation

The block indentation feature lets you set indentation for text blocks such as paragraphs, headings, or lists. This way you can visually distinguish parts of your content.

### Demo

Use the indent or outdent toolbar buttons in the editor below to change the indentation level. Try this on different elements: paragraphs, headings, and list items.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Indent, IndentBlock } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Indent, IndentBlock, /* ... */ ],
		toolbar: [ 'outdent', 'indent', /* ... */ ]
		indentBlock: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Indent, IndentBlock } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Indent, IndentBlock, /* ... */ ],
		toolbar: [ 'outdent', 'indent', /* ... */ ]
		indentBlock: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring the block indentation feature

This feature offers a few configuration options that can be used to adjust the text block indentation behavior. It is implemented by three plugins: [`Indent`](../api/module_indent_indent-Indent.html), [`IndentBlock`](../api/module_indent_indentblock-IndentBlock.html) and [`List`](../api/module_list_list-List.html).

List block indentation uses the same configuration as block indentation for paragraphs and headings. The default indentation step is `40px`. You can change it through the `indentBlock` configuration option, including switching to CSS classes.

#### Using offset and unit

By default, the block indentation feature increases or decreases the current indentation by the given offset, using the given unit.

The rich-text editor from the [demo](#ckeditor5/latest/features/indent.html--demo) section above uses the default configuration, which defines a `40px` indentation step.

You can change that value to, for example, `1em`:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        indentBlock: {
            offset: 1,
            unit: 'em'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Using CSS classes

If you want more semantics in your content, use CSS classes instead of fixed indentation units. You can then adjust the levels in the style sheets of your application whenever you want.

Here is how you can configure the block indentation feature to set indentation by applying one of the defined CSS classes:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        indentBlock: {
            classes: [
                'custom-block-indent-a', // First step - smallest indentation.
                'custom-block-indent-b',
                'custom-block-indent-c'  // Last step - biggest indentation.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Using classes instead of fixed units (`px` or `em`) has another advantage – you retain control over what indentation levels are used in the documents. For instance, you can limit indentation to 2 or 3 different levels and there is no way the users can go beyond that. In the example above, the `.custom-block-indent-c` class level is the maximum allowed indentation value. This should help keep your content clean and predictable.

In this configuration, the WYSIWYG editor will restrict indentation levels to the set of provided classes. The class with the last index in the array has the biggest indentation.

In the demo below the CSS classes are defined as follows:

```css
.custom-block-indent-a {
    margin-left: 10%;
}

.custom-block-indent-b {
    margin-left: 20%;
}

.custom-block-indent-c {
    margin-left: 30%;
}
```

> **Note**
>
> Note that for RTL content, `'margin-right'` should be used instead. Learn more about [configuring language of the editor content](#ckeditor5/latest/getting-started/setup/ui-language.html--setting-the-language-of-the-content).

### Indenting lists

Besides controlling text block indentation, the same set of buttons (`outdent`, `indent`) allows for indenting list items (nesting them).

This mechanism is completely transparent to the user. From the code perspective, the buttons are implemented by the [`Indent`](../api/module_indent_indent-Indent.html) plugin, but neither these buttons nor the respective commands implement any functionality by default.

The target behavior comes from two other plugins:

* [`IndentBlock`](../api/module_indent_indentblock-IndentBlock.html) – The indent block feature controls the indentation of elements such as paragraphs and headings.
* [`List`](../api/module_list_list-List.html) – The list feature implements the indentation (nesting) of lists.

This means that if you want to allow indenting lists only, you can do that by loading the `Indent` and `List` plugins only. If you want the full behavior – nesting list items, block indentation of paragraphs and headings, and visual block indentation of lists – you need to load all three plugins: `Indent`, `IndentBlock`, and `List`.

When all three plugins are loaded, the editor also supports applying visual block indentation to list containers (`<ol>`, `<ul>`) and list items (`<li>`). This works the same way as block indentation for paragraphs and headings – it adds a `margin-left` style (or a CSS class, depending on the [configuration](#ckeditor5/latest/features/indent.html--configuring-the-block-indentation-feature)) to the list elements. The editor understands `margin-left` styles on all these elements during data loading, across all list types (numbered, bulleted, to-do, multi-level) and at all nesting levels. Negative indentation values (such as `-50px`) are also accepted during data loading.

#### Indenting list containers

Only the topmost list in the content can be indented or outdented. The selection must be at the start of the list (collapsed or non-collapsed). Use one of the following methods:

* Press `Tab` to indent or `Shift`+`Tab` to outdent the list. The indentation changes in steps (by default, `40px`).
* Use the indent and outdent toolbar buttons. The indentation also changes in steps.

> **Note**
>
> When multiple lists are selected, the `Tab` key only changes the indentation of the first list in the selection. The toolbar buttons change the indentation of all selected lists.

It is not possible to outdent a list below `0` as negative values cannot be set through the editor UI. If a list with a negative indentation value was loaded into the editor, indenting it resets the value to `0` in a single step.

You can also remove the list indentation using the [remove format](#ckeditor5/latest/features/remove-format.html) feature, which removes the indentation attribute in one step.

#### Indenting list items

List items cannot be indented through the editor UI. However, indentation values on `<li>` elements are recognized during data loading.

A list item’s indentation can only be reset in a single step by:

* Using the indent button (if the value is negative) or the outdent button (if the value is positive).
* Using the [remove format](#ckeditor5/latest/features/remove-format.html) feature.

The selection must be set inside a list item (or span multiple list items) for these actions to work.

### Related features

Here are some CKEditor 5 features that may help structure your content better:

* [Block quote](#ckeditor5/latest/features/block-quote.html) – Include block quotations or pull quotes in your rich-text content.
* [Headings](#ckeditor5/latest/features/headings.html) – Divide your content into sections.
* [Code block](#ckeditor5/latest/features/code-blocks.html) – Insert longer, multiline code listings.
* [Text alignment](#ckeditor5/latest/features/text-alignment.html) – Because it does matter whether the content is left, right, centered, or justified.

> **Note**
>
> Block indentation can be removed with the [remove format](#ckeditor5/latest/features/remove-format.html) feature.

### Common API

The [`Indent`](../api/module_indent_indent-Indent.html) plugin registers the following components:

* The `'indent'` command.

This command does not implement any indentation behavior by itself. It executes either `indentBlock` (described below) or `indentList`, depending on which of these commands is enabled.

Read more in the [Indenting lists](#ckeditor5/latest/features/indent.html--indenting-lists) section above.

* The `'outdent'` command.

This command does not implement any indentation behavior by itself. It executes either `outdentBlock` (described below) or `outdentList`, depending on which of these commands is enabled.

Read more in the [Indenting lists](#ckeditor5/latest/features/indent.html--indenting-lists) section above.

The [`IndentBlock`](../api/module_indent_indentblock-IndentBlock.html) plugin registers the following components:

* The [`'indentBlock'`](../api/module_indent_indentblockcommand-IndentBlockCommand.html) command.

You can increase the indentation of the text block that contains the selection by:

```js
  editor.execute( 'indentBlock' );
  ```

* The [`'outdentBlock'`](../api/module_indent_indentblockcommand-IndentBlockCommand.html) command.

You can decrease the indentation of the text block that contains the selection by:

```js
  editor.execute( 'outdentBlock' );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-font>.

<a id="ckeditor5/latest/features/index.html">source file: "ckeditor5/latest/features/index.html"</a>

## CKEditor 5 features overview

This article gives you an overview of the features available in CKEditor 5, from basic formatting like bold and italic to advanced capabilities such as tables, images, and real-time collaboration. The set is large and constantly growing, and you can find the most recent list on the left. Newly added or meaningfully updated feature guides are marked with a icon, and premium features, which require an additional license, have a icon.

> **Note**
>
> Use the **main menu button in the upper-left corner** to navigate through the documentation.

### Using CKEditor 5 features

Most of the editor features are accessible from a [highly configurable toolbar](#ckeditor5/latest/getting-started/setup/toolbar.html) (in fact, there are [two of those](#ckeditor5/latest/getting-started/setup/toolbar.html--block-toolbar)) offering buttons and dropdowns. Some features also have a dedicated contextual toolbar. You can also execute plenty of actions with [keyboard shortcuts](#ckeditor5/latest/features/accessibility.html). CKEditor 5 offers a dedicated [accessibility help dialog](#ckeditor5/latest/features/accessibility.html--displaying-keyboard-shortcuts-in-the-editor) that displays a list of all available keyboard shortcuts in a dialog. It can be opened by pressing `Alt` + `0` (on Windows) or `Option` + `0` (on macOS) or via toolbar. The entire user interface comes with a [multitude of translations](#ckeditor5/latest/getting-started/setup/ui-language.html) and it supports Right-to-Left (RTL) languages.

### CKEditor 5 WYSIWYG editor features and functions

CKEditor 5 features cover several functional areas. Listed below are some of the most useful ones.

#### Formatting features

[Basic text styles](#ckeditor5/latest/features/basic-styles.html) include essentials like bold , italics , superscript , and subscript as well as inline code formatting and more.

The [font feature](#ckeditor5/latest/features/font.html) provides support for using different font families , controlling the font size as well as font and background colors .

[Headings](#ckeditor5/latest/features/headings.html) (with configurable levels and styles) and the [text alignment feature](#ckeditor5/latest/features/text-alignment.html) help organize the structure of the document.

You can apply most of these formatting options from the [toolbar](#ckeditor5/latest/getting-started/setup/toolbar.html) or on the go, as you type, thanks to the [autoformatting feature](#ckeditor5/latest/features/autoformat.html) that employs Markdown syntax. You can remove them with the [remove format feature](#ckeditor5/latest/features/remove-format.html) .

#### Advanced content editing

Rich text would not be rich without images. You can upload, caption, edit, or style them. You can even paste them straight from the URL with the help of the [image feature](#ckeditor5/latest/features/images/images-overview.html) and create a responsive design. If that is not enough, [embed media](#ckeditor5/latest/features/media-embed/media-embed.html) into your content.

[Links](#ckeditor5/latest/features/link.html) are an essential feature for online content. You can paste, change, or attribute them.

Provide clear and accessible data using [tables](#ckeditor5/latest/features/tables/tables.html) (you can even nest them to create advanced layouts), ordered and unordered [lists](#ckeditor5/latest/features/lists/lists.html) with various markers to choose from, and [to-do lists](#ckeditor5/latest/features/lists/todo-lists.html) . Use [indents and outdents](#ckeditor5/latest/features/indent.html) and [block quotes](#ckeditor5/latest/features/block-quote.html) to structure the content and draw the reader’s attention to it.

Enrich your content further by [embedding HTML code](#ckeditor5/latest/features/html/html-embed.html) – this one is useful for webmasters. If you need to present code instead of employing it, use the [code block](#ckeditor5/latest/features/code-blocks.html) that lets you produce code listing with a syntax highlight, too!

#### Collaboration

We created the [CKEditor 5 Framework](#ckeditor5/latest/framework/index.html) with [collaboration](#ckeditor5/latest/features/collaboration/collaboration.html) in mind.

All collaboration features manage user data and permissions with the [users API](#ckeditor5/latest/features/collaboration/users.html). [Track changes](#ckeditor5/latest/features/collaboration/track-changes/track-changes.html) allows the users to follow any changes made to the edited document both asynchronously and in real time. The users accept or reject these changes with a single click from a convenient side panel.

Where tracking changes is not enough, the [comments](#ckeditor5/latest/features/collaboration/comments/comments.html) come in, offering a perfect collaborative communication platform for writing and editing as a team. When you resolve a discussion, it moves to the comments archive.

Additionally, CKEditor 5 offers the [restricted editing mode](#ckeditor5/latest/features/restricted-editing.html) where just the selected parts of the content may be edited by some users, based on a permissions system. And when there is a need for even more control, there are the [read-only](#ckeditor5/latest/features/read-only.html) and [comments-only](#ckeditor5/latest/features/collaboration/comments/comments-only-mode.html) modes that let the user access the content, but not edit it.

You can also track the progress and changes done in the content with the [revision history feature](#ckeditor5/latest/features/collaboration/revision-history/revision-history.html) . This robust document versioning tool lets you create named versions, compare changes, and restore previous document versions. It tracks all progress – also when many editors work together.

#### Document conversion

If you need to share the document outside your team, use the [export to PDF feature](#ckeditor5/latest/features/converters/export-pdf.html) to produce industry-standard, portable, cross-platform files.

If you need to work further on the document, choose the [export to Word feature](#ckeditor5/latest/features/converters/export-word.html) instead – and keep your comments and changes in the resulting document, ready to edit further.

The [pagination feature](#ckeditor5/latest/features/pagination/pagination.html) complements the exports to ensure all produced documents will always look the way they should.

If you have any documents in the DOCX format, you can convert them into HTML with the [import from Word feature](#ckeditor5/latest/features/converters/import-word/import-word.html) and then continue editing in CKEditor 5.

#### HTML and Markdown output

The CKEditor 5 WYSIWYG editor by default produces HTML output that you can save into a database. The default output can be also switched to [GitHub-flavored Markdown](#ckeditor5/latest/features/markdown.html) formatted text.

#### Other productivity features

The [AI Assistant](#ckeditor5/latest/features/ai/ai-assistant/ai-assistant-overview.html) will help you rewrite, edit, or translate the existing content to match your needs, or even come up with a completely new one!

The [word and character counter](#ckeditor5/latest/features/word-count.html) will help you track progress and control the volume of the content.

Use [Markdown syntax](#ckeditor5/latest/features/autoformat.html) to format content on the go to speed up the editing process. Thanks to [automatic text transformations](#ckeditor5/latest/features/text-transformation.html) (also known as autocorrect) and the [spell checker](#ckeditor5/latest/features/spelling-and-grammar-checking.html) you can ensure everything is correct. Create multi-language documents and correct them on the go with automatic language detection and [text part language](#ckeditor5/latest/features/language.html) feature.

Keep full control of your work. Be safe and never lose anything thanks to the [autosave plugin](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration-integration.html--the-autosave-plugin). Create and edit content comfortably on larger viewport in the [fullscreen mode](#ckeditor5/latest/features/fullscreen.html) with better access to the UI.

#### Customizable user experience

Work as you like it – choose a user interface approach from several predefined layouts, add features to your preset or remove them with the [Builder](https://ckeditor.com/ckeditor-5/builder/?redirect=docs). Then tailor the user interface to your needs with a customizable [editor toolbar](#ckeditor5/latest/getting-started/setup/toolbar.html), arranging feature buttons, dropdowns, and other items in whatever way you need.

#### Cross-platform interoperability

Do not get stopped by technology differences – CKEditor 5 offers cross-platform interoperability. As a [web-based JavaScript framework](#ckeditor5/latest/framework/index.html) it works in all environments. What is more, you can use documents from other tools: paste content [from Microsoft Office](#ckeditor5/latest/features/pasting/paste-from-office.html) or from [from Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) and preserve all formatting.

The editor supports [pasting plain text](#ckeditor5/latest/features/pasting/paste-plain-text.html) and [Markdown-formatted content](#ckeditor5/latest/features/pasting/paste-markdown.html) to inherit the original document structure.

### Backward feature compatibility

If you want to migrate from CKEditor 4 to CKEditor 5, check the [migration guide](#ckeditor5/latest/updating/ckeditor4/migration-from-ckeditor-4.html).

### Feature examples

We present each rich-text editor feature on a separate page. It includes one or more working demos showcasing a feature along with some customization ideas that you can use in your implementation.

> **Note**
>
> **In most feature demos the number of features enabled is limited** to make the exposed piece of functionality stand out more, as shown in the screenshots above. But in your CKEditor 5 WYSIWYG editor implementation you are free to choose and combine any features you like from those available. You can achieve this by using the [CKEditor 5 Builder](https://ckeditor.com/ckeditor-5/builder/?redirect=docs).

### Looking for more

The examples mentioned here do not present all features included in CKEditor 5, nor does the list on the left panel. Some end-user features are quite self-explanatory. They are mentioned, for example, in the keyboard shortcuts guide.

CKEditor 5 is in active development and we add new features to it all the time. We also work on expanding and improving the existing ones. If you are missing anything in particular, feel free to [suggest a new feature](https://github.com/ckeditor/ckeditor5/issues/new?labels=type%3Afeature\&template=2-feature-request.md) and share your feedback with us. If it has already been reported by someone else, upvote it 👍 to show your support.

### Creating custom features

Probably the most exciting features are the ones you can develop on top of CKEditor 5 Framework!

We are gradually enhancing the [CKEditor 5 Framework documentation](#ckeditor5/latest/framework/index.html) together with the [API documentation](../api/index.html), hoping to give you a solid base for [creating custom features](#ckeditor5/latest/framework/tutorials/crash-course/editor.html).

The official add-ons repository for CKEditor 4 reached an impressive number of over 300 add-ons created and published by the community. Now it is time for you to add your contributions to CKEditor 5!

<a id="ckeditor5/latest/features/language.html">source file: "ckeditor5/latest/features/language.html"</a>

## Text part language

The text part language feature lets you mark the language of text fragments. This way browsers and screen readers can correctly interpret parts written in different languages.

### Demo

In the demo below, select a text fragment. Next, use the language toolbar dropdown to choose from predefined languages.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The text part language feature is especially useful when your content includes text sections written in different text directions, for example, when the whole content is in English but includes some citations in Arabic.

The text part language feature implements the [WCAG 3.1.2 Language of Parts](https://www.w3.org/TR/UNDERSTANDING-WCAG20/meaning-other-lang-id.html) specification.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, TextPartLanguage } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ TextPartLanguage, /* ... */ ],
		toolbar: [ 'textPartLanguage', /* ... */ ]
		language: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, TextPartLanguage } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ TextPartLanguage, /* ... */ ],
		toolbar: [ 'textPartLanguage', /* ... */ ]
		language: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring available languages

To modify the list of available languages displayed in the language dropdown use the [`config.language.textPartLanguage`](../api/module_core_editor_editorconfig-LanguageConfig.html#member-textPartLanguage) configuration option.

The example below shows the configuration used for the [demo](#ckeditor5/latest/features/language.html--demo) above:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        language: {
            textPartLanguage: [
                { title: 'Arabic', languageCode: 'ar' },
                { title: 'French', languageCode: 'fr' },
                { title: 'Hebrew', languageCode: 'he' },
                { title: 'Spanish', languageCode: 'es' }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Related features

There are other language-related CKEditor 5 features you may want to check:

* [UI Language](#ckeditor5/latest/getting-started/setup/ui-language.html) – Set the UI language.
* [Spelling and grammar checking](#ckeditor5/latest/features/spelling-and-grammar-checking.html) – Employ multi-language spell check for flawless content.

### Common API

The [`TextPartLanguage`](../api/module_language_textpartlanguage-TextPartLanguage.html) plugin registers:

* The `'textPartLanguage'` UI dropdown component implemented by the [text part language UI feature](../api/module_language_textpartlanguageui-TextPartLanguageUI.html).
* The `'textPartLanguage'` command implemented by the [text part language editing feature](../api/module_language_textpartlanguageediting-TextPartLanguageEditing.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Applies the language to the selected text part with the given language code.
editor.execute( 'textPartLanguage', { languageCode: 'es' } );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-language>.

<a id="ckeditor5/latest/features/line-height.html">source file: "ckeditor5/latest/features/line-height.html"</a>

## Line height

The line height feature lets you adjust the vertical spacing between lines of text, controlling how tightly or loosely text is packed within paragraphs. This feature is essential for document formatting, helping users create professional-looking content with proper typography spacing.

### Demo

Select content and change the line height using the toolbar button . Please note that the feature can only be applied to whole blocks of content such as paragraphs, tables or lists.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { LineHeight } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ LineHeight, /* ... */ ],
		toolbar: [ 'lineHeight', /* ... */ ],
		lineHeight: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { LineHeight } = CKEDITOR_PREMIUM_FEATURES;

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

### Configuration

The line height feature provides the following predefined values as options in the dropdown:

* `1`
* `1.15`
* `'default'`
* `2`
* `2.5`
* `3`

While rendering the UI layer, the `'default'` option is replaced with a value determined by the editor’s configuration. By default, the `line-height` value is `1.5`, but you can change this by updating the configuration and content styles. The other values are multipliers of the default one.

* Using a CSS variable in the editor’s content styles:

```css
  :root {
      --ck-content-line-height: 1.65;
  }
  ```

* Setting a default value in the editor configuration:

```js
  lineHeight: {
      defaultValue: 1.65
  }
  ```

The [`config.lineHeight.defaultValue`](../api/module_line-height_lineheightconfig-LineHeightConfig.html#member-defaultValue) should be synchronized with the [editor content styles](#ckeditor5/latest/getting-started/setup/css.html).

#### Using the predefined presets

The line height feature defines 2 named presets:

* `'single'`
* `'double'`

Each size assigns a corresponding class to a block element. For example, the `'double'` preset looks as follows in the editor data:

```html
<p class="line-height-double">...</p>
```

The CSS definition for these classes (presets) must be included in the web page styles where the edited content is rendered.

Here is an example of the line height CSS classes:

```css
.ck-content .line-height-single {
    line-height: 1;
}

.ck-content .line-height-double {
    line-height: 2;
}
```

An example of an editor that supports more line height sizes:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        lineHeight: {
            options: [
                'single',
                'default',
                'double',
                {
                    title: 'Triple', // A name displayed in the dropdown UI.
                    model: 'triple', // A value used in the command and stored in the model.
                    view: {
                        key: 'class',
                        value: 'line-height-triple'
                    }
                }
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'lineHeight', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

```css
.ck-content .line-height-triple {
    line-height: 3;
}
```

#### Using numerical values

The line height feature also supports numerical values.

In this case, each size adds the `style` attribute to the block element, which sets the `line-height` CSS property. For example, a line height of `2` will be represented in the editor data as:

```html
<p style="line-height: 2">...</p>
```

Here is an example of a WYSIWYG editor that supports numerical line heights. Note that `'default'` (`1.5`) is controlled by the default styles of the web page:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        lineHeight: {
            options: [
                0.5,
                1,
                'default', // This will be replaced with the default value (1.5).
                1.65,
                2,
                2.5,
                3
            ]
        },
        toolbar: [
            'heading', 'bulletedList', 'numberedList', 'lineHeight', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> The line height feature automatically converts percentage-based values (for example, `100%`) into unitless numeric equivalents (such as `1`) to ensure consistency with CSS standards and editor rendering behavior.

#### Accepting all line-height values

By default, all `line-height` values that are not specified in the `config.lineHeight.options` are stripped. You can enable support for all line heights by using the [`config.lineHeight.supportAllValues`](../api/module_line-height_lineheightconfig-LineHeightConfig.html#member-supportAllValues) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        lineHeight: {
            options: [
                // Numerical values.
                // ...
            ],
            supportAllValues: true
        },
        // More of editor's configuration.
        // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> This option can be used only in combination with [numerical values](#ckeditor5/latest/features/line-height.html--using-numerical-values).

### Related features

Check out also these CKEditor 5 features to gain better control over your content style and format:

* [Font styles](#ckeditor5/latest/features/font.html) – Easily and efficiently control the font [family](#ckeditor5/latest/features/font.html--configuring-the-font-family-feature), [size](#ckeditor5/latest/features/font.html--configuring-the-font-size-feature), [text or background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features).
* [Text alignment](#ckeditor5/latest/features/text-alignment.html) – Because it does matter whether the content is left, right, centered, or justified.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Organize your content into visually separated blocks, indent crucial paragraphs, etc.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.

### Common API

The [`LineHeight`](../api/module_line-height_lineheight-LineHeight.html) plugin registers:

* The `'lineHeight'` dropdown.

* The [`'lineHeight'`](../api/module_line-height_lineheightcommand-LineHeightCommand.html) command.

The number of options and their names correspond to the [`config.lineHeight.options`](../api/module_line-height_lineheightconfig-LineHeightConfig.html#member-options) configuration option.

You can change the line height of the current selection by executing the command with a desired value:

```js
  // For numerical values:
  editor.execute( 'lineHeight', { value: 2 } );

// For named presets:
  editor.execute( 'lineHeight', { value: 'double' } );
  ```

Passing an empty value will remove any `config.lineHeight` set:

```js
  editor.execute( 'lineHeight' );
  ```

<a id="ckeditor5/latest/features/link.html">source file: "ckeditor5/latest/features/link.html"</a>

## Link

The link feature lets you insert hyperlinks into your content and provides a UI to create and edit them. Thanks to the [autolink](#ckeditor5/latest/features/link.html--autolink-feature) plugin, typed or pasted URLs and email addresses are automatically converted into working links.

### Demo

Use the link toolbar button or press `Ctrl`/`Cmd`+`K` to create a new link. Clicking a link opens a contextual toolbar. The toolbar lets you edit existing links or unlink them with a click.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Typing around links

CKEditor 5 allows typing at the inner and outer link boundaries to make editing simpler for the users.

**To type inside a link**, move the caret to its (start or end) boundary. As long as the link remains highlighted (by default: blue), typing and applying formatting happens within its boundaries:

**To type before or after a link**, move the caret to its boundary, then press the Arrow key (`←` or `→`) away from the link once. The link stops from being highlighted, and whatever text you type or formatting apply will not be inside the link:

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, AutoLink, Link } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Link, AutoLink, /* ... */ ],
		toolbar: [ 'link', /* ... */ ],
		link: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, AutoLink, Link } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Link, AutoLink, /* ... */ ],
		toolbar: [ 'link', /* ... */ ],
		link: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Link toolbar configuration

The link UI contains a contextual toolbar that appears when a link is selected. You can configure what items appear in this toolbar using the [`config.link.toolbar`](../api/module_link_linkconfig-LinkConfig.html#member-toolbar) option.

The following toolbar items are available:

* `'linkPreview'` – Shows a preview of the link URL that you can click to open the link in a new tab.
* `'editLink'` – Opens a form to edit the link URL and options.
* `'linkProperties'` – Opens a panel to configure link properties (manual decorators). Only available when at least one manual decorator is defined.
* `'unlink'` – Removes the link.

By default, the link toolbar is configured as follows:

```js
ClassicEditor
    .create( {
        link: {
            toolbar: [ 'linkPreview', '|', 'editLink', 'linkProperties', 'unlink' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Custom toolbar items

You can extend the link toolbar with custom items by registering them in the [component factory](../api/module_ui_componentfactory-ComponentFactory.html) and adding them to the toolbar configuration.

Here is an example of registering a custom component:

```js
class MyCustomPlugin extends Plugin {
    init() {
        const editor = this.editor;

editor.ui.componentFactory.add( 'myCustomLinkInfo', locale => {
            const button = new ButtonView( locale );
            const linkCommand = editor.commands.get( 'link' );

button.bind( 'isEnabled' ).to( linkCommand, 'value', href => !!href );
            button.bind( 'label' ).to( linkCommand, 'value' );

button.on( 'execute', () => {
                // Add your custom component logic here
            } );

return button;
        } );
    }
}
```

Once registered, the component can be used in the toolbar configuration:

```js
ClassicEditor
    .create( {
        plugins: [ MyCustomPlugin, /* ... */ ],
        link: {
            toolbar: [ 'myCustomLinkInfo', '|', 'editLink', 'unlink' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> The `linkProperties` item is only shown when manual decorators are configured through [`config.link.decorators`](../api/module_link_linkconfig-LinkConfig.html#member-decorators). See the [custom link attributes](#ckeditor5/latest/features/link.html--custom-link-attributes-decorators) section for more details.

### Custom link attributes (decorators)

By default, all links created in the editor have the `href="..."` attribute in the [editor data](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html--getting-the-editor-data-with-getdata). If you want your links to have additional link attributes, [link decorators](../api/module_link_linkconfig-LinkConfig.html#member-decorators) provide an easy way to configure and manage them.

There are two types of link decorators you can use:

* [**Automatic**](#ckeditor5/latest/features/link.html--adding-attributes-to-links-based-on-predefined-rules-automatic-decorators) – They match links against predefined rules and manage their attributes based on the results.
* [**Manual**](#ckeditor5/latest/features/link.html--adding-attributes-to-links-using-the-ui-manual-decorators) – They allow users to control link attributes individually using the editor UI.

> **Note**
>
> Link decorators are turned off by default and it takes a proper [configuration](#ckeditor5/latest/features/link.html--configuration) to enable them in your rich-text editor.

#### Demo

In the editor below, all **external** links get the `target="_blank"` and `rel="noopener noreferrer"` attributes ([automatic decorator](#ckeditor5/latest/features/link.html--adding-attributes-to-links-based-on-predefined-rules-automatic-decorators)). Click a link and edit it to see that you can control the `download` attribute of specific links using the switch button in the editing balloon ([manual decorator](#ckeditor5/latest/features/link.html--adding-attributes-to-links-using-the-ui-manual-decorators)).

The following code runs this editor. Learn more about the [configuration](#ckeditor5/latest/features/link.html--configuration) of the feature.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            // Automatically add target="_blank" and rel="noopener noreferrer" to all external links.
            addTargetToExternalLinks: true,

// Let the users control the "download" attribute of each link.
            decorators: [
                {
                    mode: 'manual',
                    label: 'Downloadable',
                    attributes: {
                        download: 'download'
                    }
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Configuration

You can configure decorators through definitions provided in the [`config.link.decorators`](../api/module_link_linkconfig-LinkConfig.html#member-decorators) configuration option.

Each decorator definition must have a unique name. For [manual decorators](#ckeditor5/latest/features/link.html--adding-attributes-to-links-using-the-ui-manual-decorators), the name also represents the decorator in the [document model](#ckeditor5/latest/framework/architecture/editing-engine.html--text-attributes).

> **Warning**
>
> Link decorators work independently of one another and no conflict resolution mechanism exists. For example, configuring the `target` attribute using both an automatic and a manual decorator at the same time could end up with quirky results. The same applies if you define more manual or automatic decorators for the same attribute.

##### Adding `target` and `rel` attributes to external links

A common use case for (automatic) link decorators is adding the `target="_blank"` and `rel="noopener noreferrer"` attributes to all external links in the document. A dedicated [`config.link.addTargetToExternalLinks`](../api/module_link_linkconfig-LinkConfig.html#member-addTargetToExternalLinks) configuration exists for that purpose. When you set this option to `true`, all links starting with `http://`, `https://`, or `//` are “decorated” with `target` and `rel` attributes.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            addTargetToExternalLinks: true
        }
        // More of the editor's configuration.
            // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Internally, this configuration corresponds to an [automatic decorator](#ckeditor5/latest/features/link.html--adding-attributes-to-links-based-on-predefined-rules-automatic-decorators) with the following [definition](../api/module_link_linkconfig-LinkDecoratorAutomaticDefinition.html):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            decorators: {
                addTargetToExternalLinks: {
                    mode: 'automatic',
                    callback: url => /^(https?:)?\/\//.test( url ),
                    attributes: {
                        target: '_blank',
                        rel: 'noopener noreferrer'
                    }
                }
            }
        }
        // More of the editor's configuration.
            // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

If you want to leave the decision whether a link should open in a new tab to the users, do not use the `config.link.addTargetToExternalLinks` configuration. Define a new [manual decorator](#ckeditor5/latest/features/link.html--adding-attributes-to-links-using-the-ui-manual-decorators) with the following definition instead:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            decorators: {
                openInNewTab: {
                    mode: 'manual',
                    label: 'Open in a new tab',
                    attributes: {
                        target: '_blank',
                        rel: 'noopener noreferrer'
                    }
                }
            }
        }
        // More of the editor's configuration.
            // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

##### Adding default link protocol to external links

A default link protocol can be useful when the user forgets to type the full URL address to an external source or website. Sometimes copying the text, like for example `ckeditor.com`, and converting it to a link may cause some issues. As a result, the created link will direct you to `yourdomain.com/ckeditor.com` because of the missing protocol. This makes the link relative to the site where it appears.

After you enable the [`config.link.defaultProtocol`](../api/module_link_linkconfig-LinkConfig.html#member-defaultProtocol) configuration option, the link feature will be able to handle this issue for you. By default, it does not fix the passed link value, but when you set [`config.link.defaultProtocol`](../api/module_link_linkconfig-LinkConfig.html#member-defaultProtocol) to, for example, `http://`, the plugin will add the given protocol to every link that may need it (like `ckeditor.com`, `example.com`, etc. where `[protocol://]example.com` is missing).

See a basic configuration example:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            defaultProtocol: 'http://'
        }
        // More of the editor's configuration.
            // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> With the [`config.link.defaultProtocol`](../api/module_link_linkconfig-LinkConfig.html#member-defaultProtocol) option enabled, you are still able to link things locally using `#` or `/`. The protocol will not be added to these links.
>
> When enabled, this feature also provides the **email address autodetection** feature. When you submit `hello@example.com` in your content, the plugin will automatically change it to `mailto:hello@example.com`.

##### Adding custom protocols in links

By default, a minimal set of protocols is allowed to be used in the links. Any URL with an unrecognized protocol will be changed to ‘#’. You can overwrite the list of protocols by using [`config.link.allowedProtocols`](../api/module_link_linkconfig-LinkConfig.html#member-allowedProtocols).

See a configuration example:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            // You can use `s?` suffix like below to allow both `http` and `https` protocols at the same time.
            allowedProtocols: [ 'https?', 'tel', 'sms', 'sftp', 'smb', 'slack' ]
        }
        // More of the editor's configuration.
        // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Warning**
>
> Please remember that you customize this list at your own risk – adding unsafe protocols like `javascript` can lead to serious security vulnerabilities!

##### Adding attributes to links based on predefined rules (automatic decorators)

Automatic link decorators match all links in the editor content against a [function](../api/module_link_linkconfig-LinkDecoratorAutomaticDefinition.html) which decides whether the link should receive some set of attributes, considering the URL (`href`) of the link. These decorators work silently and the editor applies them during the [data downcast](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion).

For instance, to create an automatic decorator that adds the `download="file.pdf"` attribute to all links ending with the `".pdf"` extension, you should add the following [definition](../api/module_link_linkconfig-LinkDecoratorAutomaticDefinition.html) to [`config.link.decorators`](../api/module_link_linkconfig-LinkConfig.html#member-decorators):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            decorators: {
                detectDownloadable: {
                    mode: 'automatic',
                    callback: url => url.endsWith( '.pdf' ),
                    attributes: {
                        download: 'file.pdf'
                    }
                }
            }
        }
        // More of the editor's configuration.
        // ...
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> If you want add the `target` and `rel` attributes to all external links in your content, we prepared a [dedicated configuration](#ckeditor5/latest/features/link.html--adding-target-and-rel-attributes-to-external-links) for that purpose. Thanks to this, you do not have to define the automatic decorator by yourself.

##### Adding classes and styles to links

In addition to adding custom HTML attributes, link decorators can also apply CSS classes and inline styles to a link. It works for both **automatic** decorators (based on rules) and **manual** decorators (toggled in the UI). You must provide classes and styles through the dedicated `classes` and `styles` properties in the decorator configuration.

Manual decorators add a toggle to the link UI, allowing the user to enable or disable additional link features. The decorator properties are applied to the link element whenever the toggle is enabled.

```js
ClassicEditor
    .create( {
        link: {
            decorators: {
                highlighted: {
                    mode: 'manual',
                    label: 'Highlighted link',
                    defaultValue: false,
                    classes: 'link-highlighted',
                    styles: {
                        background: 'yellow',
                        'font-weight': 'bold'
                    }
                }
            }
        }
    } );
```

When you enable the “Highlighted link” toggle, the editor output adds the class and styles to the link element.

##### Adding attributes to links using the UI (manual decorators)

Manual link decorators are represented in the link editing balloon as switch buttons. The users can use them to control the presence of attributes of a particular link (check out the [demo](#ckeditor5/latest/features/link.html--demo) to learn more). Each manual decorator [definition](../api/module_link_linkconfig-LinkDecoratorManualDefinition.html) has a human-readable label displayed next to the switch button in the link editing balloon. Make sure it is compact and precise for the convenience of the users.

To configure a “Downloadable” switch button in the link editing balloon that adds the `download="file"` attribute to the link when turned on, add the following definition to [`config.link.decorators`](../api/module_link_linkconfig-LinkConfig.html#member-decorators):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        link: {
            decorators: {
                toggleDownloadable: {
                    mode: 'manual',
                    label: 'Downloadable',
                    attributes: {
                        download: 'file'
                    }
                },
                openInNewTab: {
                    mode: 'manual',
                    label: 'Open in a new tab',
                    defaultValue: true,			// This option will be selected by default.
                    attributes: {
                        target: '_blank',
                        rel: 'noopener noreferrer'
                    }
                }
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

##### Deprecated syntax

Older versions of CKEditor 5 allowed classes and styles inside the `attributes` field:

```js
// ❌ Deprecated – do not use:
attributes: {
    class: 'my-class',
    style: 'color: red'
}
```

> **Warning**
>
> This syntax remains compatible for backward purposes but is deprecated and triggers a console warning. Use the `classes` and `styles` properties instead.

### Autolink feature

The [`AutoLink`](../api/module_link_autolink-AutoLink.html) feature will automatically turn URLs or email addresses into working links.

To use the autolink function, press `Space`, `Enter`, or `Shift`+`Enter` after a link.

> **Note**
>
> You can always revert autolinking by the undo feature (`Ctrl`/`Cmd`+`Z`) or the backspace (`⌫`) button.

### Link providers

#### Demo

The link feature integrates with [bookmarks](#ckeditor5/latest/features/bookmarks.html), providing a smooth linking experience. Link providers allow adding predefined lists of links (similar to bookmarks). You can register any links you would like to use frequently in your content in the Link plugin using a custom method. These links will be available in the link UI form for easy access.

#### Configuration

To define a list of links available in the link UI, you can use the `getListItems()` function in the link provider. Opening the group in the link UI calls the function every time. The function should return an array of objects, each representing a link.

The `getItem()` function can resolve the link. Opening the link preview or navigating to the link from the editing view calls the function. It should return an object with the `href`, `icon`, `label`, and `tooltip` parameters. The properties are assigned to the link preview. It is useful when only part of the list items are shown in the list view (for example, in pagination), and the user interacts with a link that is not visible in the list view but is available in the editing.

```js
class SocialLinksPlugin extends Plugin {
    static get requires() {
        return [ Link ];
    }

async init() {
        const linkUI = this.editor.plugins.get( LinkUI );

linkUI.registerLinksListProvider( {
            label: 'Social links',
            getListItems: () => [
                {
                    id: 'facebook',
                    href: 'https://facebook.com',
                    label: 'Facebook',
                    icon: linkIcon
                },
                {
                    id: 'twitter',
                    href: 'https://twitter.com',
                    label: 'Twitter',
                    icon: linkIcon
                }
            ],

// Optionally: You can customize your link preview by custom implementation of link getter.
            getItem: href => {
                return {
                    href,
                    icon: linkIcon,
                    label: 'My custom label in link preview',
                    tooltip: 'My custom tooltip in link preview'
                };
            }
        } );
    }
}
```

### Common API

The [`Link`](../api/module_link_link-Link.html) plugin registers the UI button component (`'link'`) and the following commands:

* The `'link'` command implemented by [`LinkCommand`](../api/module_link_linkcommand-LinkCommand.html).
* The `'unlink'` command implemented by [`UnlinkCommand`](../api/module_link_unlinkcommand-UnlinkCommand.html).

You can execute the commands using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Applies the link to the selected content.
// When the selection is collapsed, it creates new text wrapped in a link.
editor.execute( 'link', 'http://example.com' );

// If there are decorators configured, the command can set their state.
editor.execute( 'link', 'http://example.com', { linkIsExternal: true } );

// Removes the link from the selection (and all decorators if present).
editor.execute( 'unlink' );
```

The package provides a plugin for [linking images](../api/module_link_linkimage-LinkImage.html). See the [Linking images](#ckeditor5/latest/features/images/images-linking.html) guide in the [Images section](#ckeditor5/latest/features/images/images-overview.html).

Links are represented in the [model](../api/module_engine_model_model-Model.html) using the `linkHref` attribute. [Manual link decorators](#ckeditor5/latest/features/link.html--adding-attributes-to-links-using-the-ui-manual-decorators) are represented in the model using text attributes corresponding to their names, as configured in [`config.link.decorators`](../api/module_link_linkconfig-LinkConfig.html#member-decorators).

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-link>.

<a id="ckeditor5/latest/features/lists/lists-editing.html">source file: "ckeditor5/latest/features/lists/lists-editing.html"</a>

## Lists editing behavior

This article explains how lists behave in CKEditor 5 and the options for configuring them. It covers what content a list item can hold, how to nest and indent items, and how to enable skip-level lists. It also explains how to edit lists with the keyboard and how adjacent lists merge.

### Block lists

Lists in CKEditor 5 are not limited to text. Any part of the content – images, tables, paragraphs, headings, and other blocks – can live inside a list item, with the numbering and indentation preserved across the whole structure.

To edit a block inside a list item, press `Enter` to create a new line and then `Backspace` to remove the new list item marker. Keep on entering content. Observe this behavior in the screencast below.

### Indenting lists

Besides controlling [text block indentation](#ckeditor5/latest/features/indent.html), the indent and outdent buttons allow for indenting list items (nesting them).

This mechanism is transparent to the user. From the code perspective, the buttons are implemented by the [`Indent`](../../api/module_indent_indent-Indent.html) plugin. Neither these buttons nor the respective commands implement any functionality by default.

The target behavior comes from two other plugins:

* [`IndentBlock`](../../api/module_indent_indentblock-IndentBlock.html) – The indent block feature controls the indentation of elements such as paragraphs and headings.
* [`List`](../../api/module_list_list-List.html) – The list feature implements the indentation (nesting) of lists.

This means that if you want to allow indenting lists only, you can do that by loading just the `Indent` and `List` plugins.

When both the `IndentBlock` and `List` plugins are loaded, the editor also supports visual block indentation of list containers (`<ol>`, `<ul>`) and list items (`<li>`), applying a `margin-left` style or CSS class. Refer to the [Indenting lists](#ckeditor5/latest/features/indent.html--indenting-lists) section in the block indentation guide for details on the behavior, UX, and configuration.

If you want the full behavior – nesting list items, block indentation of paragraphs, and visual block indentation of lists – you need to load all three plugins: `Indent`, `IndentBlock`, and `List`.

### Skip-level lists

By default, each nested list item can only be one level deeper than its parent. The [`config.list.enableSkipLevelLists`](../../api/module_list_listconfig-ListConfig.html#member-enableSkipLevelLists) option removes this restriction and allows list items to be indented by more than one level at a time. This matches the behavior of word processors such as Microsoft Word and Google Docs, providing a familiar editing experience.

**NPM**

```js
import { ClassicEditor, List } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			enableSkipLevelLists: true
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			enableSkipLevelLists: true
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Warning**
>
> Skip-level lists are not fully compatible with email clients. To represent skipped indentation levels in HTML, the editor inserts placeholder `<li>` elements with `list-style-type: none`. Some email clients ignore the inline style and render these placeholders as visible bulleted or numbered items.

### Simple lists

If your editor does not need this level of richness – for example in short comment fields or small editing areas – you can scale list items back to a single text-level block. Set the [`config.list.multiBlock`](../../api/module_list_listconfig-ListConfig.html#member-multiBlock) configuration setting to `false`. Items keep inline formatting like bold or links, but cannot hold paragraphs, tables, or other block elements. This setup is sometimes referred to as “simple lists.”

**NPM**

```js
import { ClassicEditor, List } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			multiBlock: false // Turn off the multi-block support (enabled by default).
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			multiBlock: false // Turn off the multi-block support (enabled by default).
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Managing lists with keyboard

Press `Enter` to create a new list item. Press `Tab` to nest the item (in multi-level lists) or indent it (in regular lists). Press `Enter` to turn an item into a higher level in the list or to remove it completely.

### Merging adjacent lists

By default, the editor merges two ordered and unordered lists of the same type that are next to each other. This happens to preserve the user intention. Lists that visually appear to be one continuous list should constitute one list even if the user has accidentally created several of them.

Sometimes this can be an undesirable behavior. For example, two adjacent numbered lists, each with two items, will merge into a single list with the numbers 1 through 4.

To prevent this behavior, enable the [`AdjacentListsSupport`](../../api/module_list_list_adjacentlistssupport-AdjacentListsSupport.html) plugin.

**NPM**

```js
import { ClassicEditor, List, AdjacentListsSupport } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ List, AdjacentListsSupport, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List, AdjacentListsSupport } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, AdjacentListsSupport, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

This feature only works for pasted contents or on data load, it does not support entering adjacent lists via the editor UI. Find more about it in the `#changes-to-list-merging` section of `Update to 41.x` guide in the [updating from older versions](#ckeditor5/latest/updating/guides/updating-from-older-versions.html) guide. If you are interested in this functionality, refer to [this issue on GitHub](https://github.com/ckeditor/ckeditor5/issues/14478).

<a id="ckeditor5/latest/features/lists/lists-properties.html">source file: "ckeditor5/latest/features/lists/lists-properties.html"</a>

## List properties

Besides the basic functionality of creating ordered and unordered lists, CKEditor 5 offers formatting tools that let you control the lists. You can enable features such as customizing list markers with additional styles, setting the start index, or reversing the list order separately or all at once. Check out the individual demos below or see all list properties working together in the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html).

### List styles

The list style feature introduces more styles for the list item markers. When [enabled](../../api/module_list_listconfig-ListPropertiesConfig.html#member-styles), it adds three styles for unordered lists and six styles for ordered lists to choose from. The user will be able to set or change the list style via the dropdown. It opens when you click the arrow next to the appropriate list button in the toolbar.

#### Available list styles

The following unordered list styles are available:

* `disk` (•)
* `circle` (◦)
* `square` (▪)

The following ordered list styles are available:

* `decimal` (1.)
* `decimal-leading-zero` (01.)
* `lower-roman` (i.)
* `upper-roman` (I.)
* `lower-latin` (a.)
* `upper-latin` (A.)

Additional numbering style that [needs configuration](#ckeditor5/latest/features/lists/lists.html--enabling-specific-enumerators):

* arabic-indic numbers (١.)

#### Demo

In the editor below, use the ordered or unordered list dropdown to choose the desired marker type for each list.

### List start index

The list start index feature allows the user to choose the starting point of an ordered list. By default, this would be `1` (or `A`, or `I` – see the [list styles section](#ckeditor5/latest/features/lists/lists-properties.html--list-styles)). Sometimes you may want to start a list with some other digit or letter, though.

When this feature is [enabled](../../api/module_list_listconfig-ListPropertiesConfig.html#member-startIndex), an extra dropdown option is available in the ordered list toolbar button. Thanks to it, the user may set or change the starting marker.

#### Demo

In the editor below, notice how the ordering continues in the second list. To achieve continuous numbering of all spaceships from the example, go to the first item of the last list. Then use the ordered list dropdown input field to set the start index.

### Reversed list

The reversed list feature lets the user reverse the numbering order of a list, changing it from ascending to descending. This is useful in countdowns and things-to-do lists that need to reproduce steps in a reversed order (for example, in disassembly instructions).

When this feature is [enabled](../../api/module_list_listconfig-ListPropertiesConfig.html#member-reversed), an extra dropdown switch is available in the ordered list toolbar button. Thanks to it, the user may reverse the order of a list with a single click.

#### Demo

Click the second list and use the ordered list dropdown switch to choose whether to reverse the numbering order.

> **Note**
>
> You can see all the list properties together in action in the [Feature-rich editor](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) and [Document editor](#ckeditor5/latest/examples/builds/document-editor.html) examples.

### List item marker formatting

The list item marker formatting feature automatically applies text formatting to list item markers when the entire content of the list item shares the same formatting. It integrates with the [font feature](#ckeditor5/latest/features/font.html) and [basic styles feature](#ckeditor5/latest/features/basic-styles.html), supporting the following formatting options:

* **Bold** and **italic** (from basic styles),
* **Font color**, **font size**, and **font family** (from font).

When this feature is enabled, if the whole list item content is consistently styled using any of the supported formats, the bullet or number marker will reflect the same style automatically. For example, if a list item is entirely bold, its marker will appear bold as well.

#### Demo

Select the entire content of a list item and apply a format like bold, italic, or a font style. If the whole item is formatted, the list marker will automatically update to match.

#### Disabling marker formatting

This feature is enabled by default. To disable it, use the following configuration:

**NPM**

```js
import { ClassicEditor, List, Bold } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ List, Bold, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', 'bold', /* ... */ ]
		list: {
			enableListItemMarkerFormatting: false
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List, Bold } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, Bold, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', 'bold', /* ... */ ]
		list: {
			enableListItemMarkerFormatting: false
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

<a id="ckeditor5/latest/features/lists/lists.html">source file: "ckeditor5/latest/features/lists/lists.html"</a>

## Ordered and unordered lists

The list feature lets you create ordered (numbered) and unordered (bulleted) lists. The unique thing about them is that you can put any content inside each list item (including block elements like paragraphs and tables), retaining the continuity of numbering and indentation.

> **Warning**
>
> Since version 41.0.0, the list support plugin has changed for CKEditor 5. You can read more about this change in the `#breaking-changes-to-the-list-plugin` section of `Update to 41.x` in [updating from older versions](#ckeditor5/latest/updating/guides/updating-from-older-versions.html) guide.

### Demo

Use the editor below to see the list feature in action. You can use toolbar buttons to insert both ordered and unordered lists .

You can also use Markdown code recognized by the [autoformatting feature](#ckeditor5/latest/features/autoformat.html):

* Start a line with `*` or `-` followed by a space for a bulleted list.
* Start a line with any number followed by `.` or `)` and a space for a numbered list.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

The `List` plugin provides the [ordered (numbered) and unordered (bulleted) features](#ckeditor5/latest/features/lists/lists.html) for CKEditor 5. [Additional list properties](#ckeditor5/latest/features/lists/lists-properties.html), such as list marker styles, start index, or reversed list order, are provided by the `ListProperties` plugin.

#### List feature

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, List } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### List properties

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add `ListProperties` to your plugin list and toolbar configuration:

To enable selected sub-features of the [list properties](#ckeditor5/latest/features/lists/lists-properties.html), add their configuration to your editor. Set `true` for each feature you want to enable:

**NPM**

```js
import { ClassicEditor, List, ListProperties } from 'ckeditor5';

ClassicEditor
	.create( {
		plugins: [ List, ListProperties, /* ... */ ],
		toolbar: [ 'bulletedList', 'numberedList', /* ... */ ],
		list: {
			properties: {
				styles: true,
				startIndex: true,
				reversed: true
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, List, ListProperties } = CKEDITOR;

> **Warning**
>
> The [`ListProperties`](../../api/module_list_listproperties-ListProperties.html) feature overrides UI button implementations from the [`ListUI`](../../api/module_list_list_listui-ListUI.html).

##### Enabling specific enumerators

To enable only selected list item enumerators for the ordered list, you need to explicitly list them in the editor configuration. This can also be used to enable additional, `arabic-indic` numeral enumerators. To achieve this, replace the `styles: true` configuration option with a `styles { }` listing, for example:

```js
list: {
    properties: {
        styles: {
            listStyleTypes: {
                numbered: [
                    'decimal',
                    'decimal-leading-zero',
                    'arabic-indic'
                ],
                bulleted: [
                    'disc',
                    'circle',
                    'square'
                ]
            }
        }
    }
}
```

#### Editor output configuration

Starting with version 45.1.1, list items (`<li>` elements) in the editor data output contain an additional attribute `data-list-item-id`. The attribute is necessary to ensure that the lists feature work correctly with other editor features and mechanisms.

```html
<ul>
    <li data-list-item-id="e72808ee4144975064acb5d66e5cfba13">Hello</li>
    <li data-list-item-id="e5d719ab356409767e9d4358485476358">There!</li>
</ul>
```

If data loaded in the editor does not contain the `data-list-item-id` attributes on list items, they will be automatically added when data is saved.

If you wish to save the editor contents without this attribute, you can set the `skipListItemIds` flag to `true` when calling `editor.getData()` method. **However, please note, that data without IDs should be used only for presentation purposes (such as displaying the document as HTML), and should not be used to initialize the editor.**

```js
editor.getData( { skipListItemIds: true } );
```

Such output will not contain `data-list-item-id` attribute:

```html
<ul>
    <li>Hello</li>
    <li>There!</li>
</ul>
```

### Related features

These CKEditor 5 features provide similar functionality:

* [To-do lists](#ckeditor5/latest/features/lists/todo-lists.html) – Create a list of interactive checkboxes with labels.
* [Multi-level lists](#ckeditor5/latest/features/lists/multi-level-lists.html) – Multi-level lists allow the user to set different markers (symbols, text or numbers) to display at each level of the list.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Set indentation for text blocks such as paragraphs or headings. Also supports [visual block indentation of lists and list items](#ckeditor5/latest/features/indent.html--indenting-lists).
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Format the text on the go with Markdown code.

### Common API

The [`List`](../../api/module_list_list-List.html) plugin registers:

* The [`'numberedList'`](../../api/module_list_list_listcommand-ListCommand.html) command.
* The [`'bulletedList'`](../../api/module_list_list_listcommand-ListCommand.html) command.
* The [`'indentList'`](../../api/module_list_list_listindentcommand-ListIndentCommand.html) command.
* The [`'outdentList'`](../../api/module_list_list_listindentcommand-ListIndentCommand.html) command.
* The `'numberedList'` UI button.
* The `'bulletedList'` UI button.

The [`ListProperties`](../../api/module_list_listproperties-ListProperties.html) plugin registers:

* The [`listStyle`](../../api/module_list_listproperties_liststylecommand-ListStyleCommand.html) command. It accepts the `type` of the list style to set. If not set, it uses the default marker (usually decimal).

```js
  editor.execute( 'listStyle', { type: 'lower-roman' } );
  ```

The available types are:

* For bulleted lists: `'disc'`, `'circle'`, and `'square'`.
  * For numbered lists: `'decimal'`, `'decimal-leading-zero'`, `'lower-roman'`, `'upper-roman'`, `'lower-latin'`, and `'upper-latin'`.

* The [`listStart`](../../api/module_list_listproperties_liststartcommand-ListStartCommand.html) command. It is a number and defaults to `1` (meaning a list starts with `1`). If enabled, it accepts a numerical value for the `start` attribute.

```js
  editor.execute( 'listStart', { startIndex: 3 } );
  ```

* The [`listReversed`](../../api/module_list_listproperties_listreversedcommand-ListReversedCommand.html) command. It is a Boolean and defaults to `false` (meaning the list order is ascending).

```js
  editor.execute( 'listReversed', { reversed: true } );
  ```

* The `numberedList` UI split button. It overrides the UI button registered by the `List` plugin.

* The `bulletedList` UI split button. It overrides the UI button registered by the `List` plugin.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-list>.

<a id="ckeditor5/latest/features/lists/multi-level-lists.html">source file: "ckeditor5/latest/features/lists/multi-level-lists.html"</a>

## Multi-level lists

Multi-level lists with the legal style numbering feature allows for easy creation and modification of numbered lists with counters (1, 1.1, 1.1.1). These are crucial for clear referencing and hierarchical organization in complex documents. The feature offers full compatibility with Microsoft Word. When lists with such formatting are pasted to the editor with the [paste from Office enhanced](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html) feature, the numbering format is retained.

### Demo

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

#### Headings in multi-level lists

Multi-level lists support headings in list items. The marker, which denotes the counter, will insert itself into the heading block to achieve more similar styles.

While creation of a legal document with a list of numbered headings is possible, the editing of long-form documents may not be the best experience. You might want full support for the **numbered headings feature** that Microsoft Word places in the multi-level lists interface. We do not have it yet, but if you are interested, please let us know in [this GitHub issue](https://github.com/ckeditor/ckeditor5/issues/16161) or via our support.

#### Custom multi-level list styles

For now, we provide one style for multi-level lists: legal style numbering. But this first step opens a possibility for us to add more styles in the future or allow integrators to create their own styles. If you are interested, please let us know in [this GitHub issue](https://github.com/ckeditor/ckeditor5/issues/8687) or via our support.

#### Skip-level lists

The [`config.list.enableSkipLevelLists`](../../api/module_list_listconfig-ListConfig.html#member-enableSkipLevelLists) option also applies to multi-level lists. When enabled, items can skip indentation levels, and any skipped levels are filled with `1` in the legal-style marker. For example, an item at indent 0 (`1`) followed directly by an item at indent 2 renders as `1.1.1`. See the [Skip-level lists](#ckeditor5/latest/features/lists/lists-editing.html--skip-level-lists) section of the lists editing behavior guide for the full description.

### Installation

> **Note**
>
> Please note that this plugin requires the [basic `List` plugin](#ckeditor5/latest/features/lists/lists.html) to work properly.

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the features to your plugin list and toolbar configuration:

**NPM**

```js
import { List } from 'ckeditor5';
import { MultiLevelList } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ List, MultiLevelList, /* ... */ ],
		toolbar: [ 'multiLevelList', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { List } = CKEDITOR;
const { MultiLevelList } = CKEDITOR_PREMIUM_FEATURES;

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

### Related features

* [Ordered and unordered lists](#ckeditor5/latest/features/lists/lists.html) – Create ordered and unordered lists with configurable markers.
* [To-do lists](#ckeditor5/latest/features/lists/todo-lists.html) – Create a list of interactive checkboxes with labels.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Set indentation for text blocks such as paragraphs or headings and lists.
* [Paste from Office enhanced](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html) – Paste Office documents with high compatibility.

### Common API

The [`MultiLevelList`](../../api/module_list-multi-level_multilevellist-MultiLevelList.html) registers:

* The `'multiLevelList'` UI dropdown component.
* The `'multiLevelList'` command implemented by [`MultiLevelListCommand`](../../api/module_list-multi-level_multilevellistcommand-MultiLevelListCommand.html).

You can execute the command using the [`editor.execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Change selected content to multi level list.
editor.execute( 'multiLevelList' );
```

<a id="ckeditor5/latest/features/lists/todo-lists.html">source file: "ckeditor5/latest/features/lists/todo-lists.html"</a>

## To-do lists

The to-do list feature lets you create a list of interactive checkboxes with labels. It supports all features of [bulleted and numbered lists](#ckeditor5/latest/features/lists/lists.html), so you can nest a to-do list together with any combination of other lists.

### Demo

Use the to-do list toolbar button to add a list to the editor content. Thanks to the integration with the [autoformatting feature](#ckeditor5/latest/features/autoformat.html), you can also start a line with `[ ]` or `[x]` followed by a space to insert an unchecked or checked list item.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Keyboard support

You can check and clear a list item by using the `Ctrl` + `Enter` (`Cmd` + `Enter` on Mac) shortcut when the selection is in that item.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, TodoList } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ TodoList, /* ... */ ],
		toolbar: [ 'todoList', /* ... */ ],
		list: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, TodoList } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ TodoList, /* ... */ ],
		toolbar: [ 'todoList', /* ... */ ],
		list: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Related features

These CKEditor 5 features provide similar functionality:

* [Ordered and unordered lists](#ckeditor5/latest/features/lists/lists.html) – Create ordered and unordered lists with configurable markers.
* [Multi-level lists](#ckeditor5/latest/features/lists/multi-level-lists.html) – Multi-level lists allow the user to set different markers (symbols, text or numbers) to display at each level of the list.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Format the text on the go with Markdown code.

### Common API

The [`TodoList`](../../api/module_list_todolist-TodoList.html) plugin registers:

* The [`'todoList'`](../../api/module_list_list_listcommand-ListCommand.html) command.
* The [`'checkTodoList'`](../../api/module_list_todolist_checktodolistcommand-CheckTodoListCommand.html) command.
* The `'todoList'` UI button.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-list>.

<a id="ckeditor5/latest/features/markdown.html">source file: "ckeditor5/latest/features/markdown.html"</a>

## Markdown output

The Markdown plugin lets you switch the default output from HTML to Markdown. This way you can produce lightweight text documents with a simple formatting syntax that is popular among developers.

### Demo

The editor below is configured to output GitHub Flavored Markdown. Edit the content and see how the Markdown output changes (you can find it below the editor).

> **Note**
>
> Please note that the Enhanced source code editing feature in the demo below is a [separate plugin](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html). If you would like to use it in your integration, you need to install it separately.

Output:

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

Coupled with the [autoformatting](#ckeditor5/latest/features/autoformat.html) feature, the Markdown plugin offers the full-fledged Markdown WYSIWYG editing experience, as described in the [“CKEditor 5: the best open source Markdown editor”](https://ckeditor.com/blog/CKEditor-5-the-best-open-source-Markdown-editor/) blog post. Visit the [free online Markdown editor](https://onlinemarkdowneditor.dev/) to see this solution implemented.

Please remember that Markdown syntax is really simple and it does not cover all the rich-text features. Some features provided by CKEditor 5 will thus work as intended only when output to HTML as they have no Markdown equivalent.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the [`Markdown`](../api/module_markdown-gfm_markdown-Markdown.html) plugin to the editor configuration. It will change the default [data processor](../api/module_engine_dataprocessor_dataprocessor-DataProcessor.html) to the [`MarkdownGfmDataProcessor`](../api/module_markdown-gfm_gfmdataprocessor-MarkdownGfmDataProcessor.html):

**NPM**

```js
import { ClassicEditor, Bold, Italic, Essentials, Markdown } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [
			Markdown,
			Essentials,
			Bold,
			Italic,
			// More plugins.
		],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Bold, Italic, Essentials, Markdown } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			Markdown,
			Essentials,
			Bold,
			Italic,
			// More plugins.
		],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Extending formatting support

If you need more extensive Markdown support for formatting elements (for example, having the `title` attribute on links represented as `[Foo Bar](https://foo.bar "My link title")`), you can also install [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html). This advanced feature allows the integrators to provide additional tags, elements, and attributes, not yet supported by other CKEditor 5 plugins and extend the formatting capabilities.

### The Markdown data processor

The Markdown plugin uses a [data processor](../api/module_engine_dataprocessor_dataprocessor-DataProcessor.html) (implemented by the [`MarkdownGfmDataProcessor`](../api/module_markdown-gfm_gfmdataprocessor-MarkdownGfmDataProcessor.html) class) which changes the default output from HTML to Markdown. This means that you can [set](../api/module_core_editor_editor-Editor.html#function-setData) or [get](../api/module_core_editor_editor-Editor.html#function-getData) data from the editor in the Markdown format:

```js
editor.getData(); // -> 'This is [CKEditor 5](https://ckeditor.com).'

editor.setData( 'This is **bold**.' );
```

The data processor outputs the GFM Markdown syntax. “GFM” stands for “GitHub Flavored Markdown” – a Markdown dialect used by [GitHub](https://github.com). Markdown lacks any formal specification (although the [CommonMark](https://commonmark.org/) initiative aims to close this gap) and has many dialects, often incompatible with one another.

When converting the output produced by this data processor, make sure to use a compatible Markdown-to-HTML converter (for example, the [marked](https://www.npmjs.com/package/marked) library).

> **Note**
>
> While the CKEditor 5 architecture supports changing the data format, in most scenarios we do recommend sticking to the default format which is HTML (supported by the [`HtmlDataProcessor`](../api/module_engine_dataprocessor_htmldataprocessor-HtmlDataProcessor.html)). HTML remains [the best standard for rich-text data](https://medium.com/content-uneditable/a-standard-for-rich-text-data-4b3a507af552).
>
> And please do remember – using Markdown [does not automatically make your application or website secure](https://github.com/ckeditor/ckeditor5-markdown-gfm/issues/16#issuecomment-375752994).

### Known issues

> **Note**
>
> Please bear in mind that the Markdown data processor does not support all rich text features. The [Markdown syntax](https://daringfireball.net/projects/markdown/syntax) is really simple and only supports limited formatting options.
>
> This means that advanced formatting like list styles, table styles, or page break markers will be stripped in the effecting data. These are not supported by Markdown and therefore cannot be converted from HTML to Markdown.

While the Markdown plugin is stable and ready to use, some issues are still being worked on. Feel free to upvote 👍 these on GitHub if you would like to see this introduced.

* Pasting Markdown-formatted content does not automatically convert the pasted syntax markers into properly formatted content. GitHub issues: [#2321](https://github.com/ckeditor/ckeditor5/issues/2321), [#2322](https://github.com/ckeditor/ckeditor5/issues/2322).
* The Markdown code generated with the Markdown output feature will not properly render [nested tables](#ckeditor5/latest/features/tables/tables.html--nesting-tables). GitHub issue: [#9475](https://github.com/ckeditor/ckeditor5/issues/9475).
* Code blocks inside To-do lists will not properly render. GitHub issue: [#18754](https://github.com/ckeditor/ckeditor5/issues/18754).

### Related features

Some other ways to output the edited content include:

* [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html--markdown-source-view) – Allows for Markdown source edition if configured accordingly.
* [Export to Word](#ckeditor5/latest/features/converters/export-word.html) – Generate editable `.docx` files out of your editor-created content.
* [Export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) – Generate portable PDF files out of your editor-created content.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Use Markdown syntax shortcodes to automatically format your content as you type!
* [Paste Markdown](#ckeditor5/latest/features/pasting/paste-markdown.html) – Paste Markdown-formatted content straight into the editor.

### Contribute

The source code of this feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-markdown-gfm>.

<a id="ckeditor5/latest/features/math-equations.html">source file: "ckeditor5/latest/features/math-equations.html"</a>

## Math equations and chemical formulas

You can add and edit mathematical equations and chemical formulas in CKEditor 5 using [MathType](https://www.wiris.com/en/mathtype), a popular formula editor with classical and handwriting input modes.

> **Note**
>
> This is a premium add-on that is a part of CKEditor Custom Plan, and delivered by our partner, [Wiris](https://www.wiris.com/en/). [Choose the Custom Plan](https://ckeditor.com/pricing/) to enable it.

### Demo

To create math or chemical formulas in the editor below, click the MathType or ChemType buttons in the toolbar. This will open the relevant dialog.

Use the toolbar to write your equation or formula. At any time, you can also click the “Go to handwritten mode” button on the right side of the MathType editor to switch to handwriting.

When you are done creating your scientific content, click the “OK” button to insert your formula into the editor. You can also edit any existing formulas by double-clicking them in your document.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

MathType is based upon standards like MathML for internal representation and the PNG image format for displaying formulas. It can also handle other formats like LaTeX, Flash, SVG, and EPS.

Additionally, MathType offers a special tool designed to help you work with chemical notation. When enabled, ChemType adds a specialized toolbar with the common chemical symbols as well as changes the notation to make it more intuitive to work with chemical formulas.

### Usage

The MathType window is split into two main areas: a [tabbed toolbar](https://docs.wiris.com/mathtype/en/user-interfaces/mathtype-web-interface/toolbar-and-icons.html) that contains a large number of icons that are useful for creating math equations and chemical formulas, and an editing area where you can see your current formula, the location of the cursor, and the text currently selected (if any).

The following resources can come in handy if you want to become proficient at working with this tool:

* [Using MathType Web](https://docs.wiris.com/mathtype/en/user-interfaces/mathtype-web-interface/using-mathtype.html) covers the basics of creating formulas, using your keyboard, moving the cursor in templates, formatting your content, or writing on mobile devices.
* [Introductory tutorials](https://docs.wiris.com/mathtype/en/user-interfaces/mathtype-web-interface/introductory-tutorials.html) are intended to get you started using MathType.
* [ChemType](https://docs.wiris.com/mathtype/en/mathtype-integrations/mathtype-web-interface-features/chemistry.html) explains the features of the dedicated chemistry toolbar.
* [MathType documentation](https://docs.wiris.com/mathtype/index.html) is a complete reference to all MathType features and settings.

### Editing modes

MathType lets you choose between two editing modes:

* **Classic input mode** provides options to choose symbols and templates from the MathType or ChemType toolbars and combine them to build the equation.
* **Handwritten input mode** lets you write the equation in your own handwriting. After checking the equation preview to ensure its accuracy, you can insert the equation or switch to classic input for further editing. [Read more here](https://docs.wiris.com/mathtype/en/mathtype-integrations/mathtype-web-interface-features/handwritten-input.html).

If you visit a page using MathType with your mobile device, the handwriting interface will appear by default. However, if you visit the same page with a laptop or desktop computer, the classic input will be displayed. The user is always free to change between the two interfaces.

### Installation from npm

MathType is delivered as a CKEditor 5 plugin, so it can be combined into an editor preset just like other features. To add this feature to your editor, install the [`@wiris/mathtype-ckeditor5`](https://www.npmjs.com/package/@wiris/mathtype-ckeditor5) package:

```bash
npm install --save @wiris/mathtype-ckeditor5
```

Then add it to your plugin list and the toolbar configuration. Please note, that unlike native CKEditor 5 plugins, this one is imported from its own package. Also, that this import is different than the standard CKEditor 5 plugins import:

```js
import { ClassicEditor } from 'ckeditor5';
import MathType from '@wiris/mathtype-ckeditor5/dist/index.js';

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
        plugins: [ MathType, /* ... */ ],
        toolbar: [ 'MathType', 'ChemType', /* ... */ ],
        mathTypeParameters : {
            // Configuration.
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Installation from CDN

The MathType plugin is provided by an external partner. Hence, after attaching the editor scripts, you cannot access the plugin from the global variable as with other plugins. However, there is a way to use the CKEditor 5 CDN with the MathType plugin. It requires a custom setup.

First, copy the MathType files from the [`@wiris/mathtype-ckeditor5/dist/browser`](https://www.npmjs.com/package/@wiris/mathtype-ckeditor5?activeTab=code) package to your project. It may look like this:

```
├── mathtype
│    ├── index-content.css
│    ├── index-editor.css
│    ├── index.css
│    ├── index.css.map
│    ├── index.js
│    ├── index.js.map
│    ├── index.umd.js
│    └── index.umd.js.map
├── ...
```

Next, attach the MathType script to your page after the editor scripts. This will expose MathType as a global variable, similar to other plugins.

```html
<script src="./mathtype/index.umd.js"></script>
```

Besides the script, you also need to attach the CSS file.

```html
<link rel="stylesheet" href="./mathtype/index.css" />
```

Once the scripts are added, get MathType from the UMD file loaded via the script tag. Use the MathType plugin directly from exports, then add it to the editor.

```js
const { ClassicEditor } = window.CKEDITOR;

const MathTypeExports = window['@wiris/mathtype-ckeditor5'];
const MathType = MathTypeExports.default;

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>',
        plugins: [ MathType, /* ... */ ],
        toolbar: [ 'MathType', 'ChemType', /* ... */ ],
        mathTypeParameters : {
            // Configuration.
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> The above setup uses vanilla JavaScript. Importing editor and other plugins may differ for frameworks. Check the respective [Quick start guide](#ckeditor5/latest/getting-started/index.html) for more information.

### Customizing MathType service

It is possible to use different services for MathType support. There are several ways to deploy it in the CKEditor 5 environment. The following instructions will allow you to customize MathType Web Integration services for CKEditor 5.

#### Java

To install the Java service, follow the steps below:

1. Download the [MathType Web Integration Services - Java](https://store.wiris.com/en/products/downloads/mathtype/integrations) package.

2. Deploy the `pluginwiris_engine` war file.

3. Add `mathTypeParameters` to CKEditor 5 with the configuration shown below:

```js
   ClassicEditor
       .create( {
           // ... Other configuration options ...
           // MathType parameters.
           mathTypeParameters : {
               serviceProviderProperties : {
                   URI : '/pluginwiris_engine/app/configurationjs',
                   server : 'java'
               }
           }
       })
       .then( /* ... */ )
       .catch( /* ... */ );
   ```

#### PHP

To install the PHP service, follow the steps below:

1. Download the [MathType Web Integration Services - PHP](https://store.wiris.com/en/products/downloads/mathtype/integrations) package.

2. Copy the `generic_wiris/integration` folder into your project. In this example, it was assumed the services are located at `DOCUMENT_ROOT/php-services/`.

3. Add `mathTypeParameters` to CKEditor 5 with the following configuration:

```js
   ClassicEditor
       .create( {
           // ... Other configuration options ...
           // MathType parameters.
           mathTypeParameters : {
               serviceProviderProperties : {
                   URI : 'http://localhost/php-services/integration',
                   server : 'php'
               }
           }
       })
   .then( /* ... */ )
   .catch( /* ... */ );
   ```

#### .NET

To install the .NET service, follow the steps below:

1. Download the [MathType Web Integration Services - Aspx](https://www.wiris.com/en/plugins/services/download) package.

2. Copy the `generic_wiris/integration` folder into your project. In this example, it was assumed the services are located at `DOCUMENT_ROOT/aspx-services/`.

3. Add `mathTypeParameters` to CKEditor 5 with this configuration:

```js
   ClassicEditor
       .create( {
           // ... Other configuration options ...
           // MathType parameters.
           mathTypeParameters : {
               serviceProviderProperties : {
                   URI : 'http://localhost/aspx-services/integration',
                   server : 'aspx'
               }
           }
       })
   .then( /* ... */ )
   .catch( /* ... */ );
   ```

#### Ruby on Rails

To install the Ruby on Rails service, follow the steps below:

1. Download the [MathType Web Integration Services - Ruby on Rails](https://www.wiris.com/en/plugins/services/download) package.

2. Install the `wirispluginengine.gem` gem.

```bash
   gem install -l wirispluginengine.gem
   ```

3. Add `mathTypeParameters` to CKEditor 5 with the configuration below:

```js
   ClassicEditor
       .create( {
           // ... Other configuration options ...
           // MathType parameters.
           mathTypeParameters : {
               serviceProviderProperties : {
                   URI : '/wirispluginengine/integrationn',
                   server : 'ruby'
               }
           }
       })
   .then( /* ... */ )
   .catch( /* ... */ );
   ```

### Displaying equations on your website

By default, MathType returns equations in MathML which is [not supported by all browsers](https://developer.mozilla.org/en-US/docs/Web/MathML#browser_compatibility). To display equations on a page, you will need to use an engine that will handle the rendering process.

Fortunately, MathType introduces the full MathML mode that handles the unsupported markup and converts it into a form that can be properly recognized by browsers. You can read more about the full MathML mode [in the documentation](https://docs.wiris.com/mathtype-web-interface-features/full-mathml-mode-wirispluginsjs).

<a id="ckeditor5/latest/features/media-embed/media-embed-configuration.html">source file: "ckeditor5/latest/features/media-embed/media-embed-configuration.html"</a>

## Media embed configuration

You can configure the data output format and the list of supported media providers used by the [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) plugin.

### Data output format

You can configure the data output format of the feature using the [`config.mediaEmbed.previewsInData`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-previewsInData) option.

> **Note**
>
> This option does not change how the media are displayed inside the editor. The previewable ones will still be displayed with previews. It only affects the output data (see below).

#### Semantic data output (default)

By default, the media embed feature outputs semantic `<oembed url="...">` tags for previewable and non-previewable media. That being so, it works best when the application processes (expands) the media on the server side or [directly in the frontend](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html), preserving the versatile database representation:

```html
<figure class="media">
    <oembed url="https://media-url"></oembed>
</figure>
```

You can achieve further customization of the semantic data output through the [`config.mediaEmbed.elementName`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-elementName) configuration. As an example, if you set `elementName` to `o-embed`:

```html
<figure class="media">
    <o-embed url="https://media-url"></o-embed>
</figure>
```

If `elementName` is overridden to something other than the default value, the existing `<oembed>` elements will still be shown for backward compatibility purposes.

#### Including previews in data

Optionally, by setting `mediaEmbed.previewsInData` to `true` you can configure the media embed feature to output media in the same way they look in the editor. If the media element is “previewable,” the media preview (HTML) is saved to the database:

```html
<figure class="media">
    <div data-oembed-url="https://media-url">
        <iframe src="https://media-preview-url"></iframe>
    </div>
</figure>
```

Currently, the preview is only available for content providers for which CKEditor 5 can predict the `<iframe>` code: YouTube, Vimeo, Dailymotion, Spotify, etc. For other providers like X (Twitter) or Instagram, the editor cannot produce an `<iframe>` code. It also does not allow retrieving this code from an external oEmbed service. Therefore, for non-previewable media, it produces the default semantic output:

```html
<figure class="media">
    <oembed url="https://media-url"></oembed>
</figure>
```

This means that, unless you [limit the list of providers](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--media-providers) to only those that are previewable, you need to [make sure that the media are displayed on your website](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html).

Read more about [non-previewable media](#ckeditor5/latest/features/media-embed/media-embed.html--previewable-and-non-previewable-media).

### Media providers

CKEditor 5 comes with several supported media providers that you can extend or alter.

Names of providers **with previews**:

* `'dailymotion'`,
* `'spotify'`,
* `'youtube'`,
* `'vimeo'`.

Names of providers **without previews**:

* `'instagram'`,
* `'twitter'`,
* `'googleMaps'`,
* `'flickr'`,
* `'facebook'`.

> **Note**
>
> The default media provider configuration does not support all possible media URLs – only the most common are included. Services like Iframely or Embedly support thousands of media providers. It is up to you to define which you want to allow.

#### Extending media providers

To extend the default list of providers, use [`config.mediaEmbed.extraProviders`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-extraProviders).

#### Removing media providers

To remove certain providers, use [`config.mediaEmbed.removeProviders`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-removeProviders).

For instance, to leave only the previewable providers, configure this feature as follows:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mediaEmbed: {
            removeProviders: [ 'instagram', 'twitter', 'googleMaps', 'flickr', 'facebook' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Overriding media providers

To override the default providers, use [`config.mediaEmbed.providers`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-providers) and define your set according to the [provider syntax](../../api/module_media-embed_mediaembedconfig-MediaEmbedProvider.html):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mediaEmbed: {
            providers: [
                {
                    // A URL regular expression or an array of URL regular expressions:
                    url: /^example\.com\/media\/(\w+)/,

// To be defined only if the media are previewable:
                    html: match => '...'
                },
                // More providers.
                // ...
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

You can take inspiration from the default configuration of this feature. You can find it in <https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-media-embed/src/mediaembedediting.ts>

<a id="ckeditor5/latest/features/media-embed/media-embed-external-preview.html">source file: "ckeditor5/latest/features/media-embed/media-embed-external-preview.html"</a>

## Using external services for media previews

You can use proxy services like [Iframely](https://iframely.com/) or [Embedly](https://embed.ly/) for two related purposes:

* To show previews of non-previewable providers (X, Instagram, Facebook, and others) **inside the editor**.
* To render the `<oembed>` tags produced by CKEditor 5 as rich previews **on your target website**.

Both use the same underlying services but are set up in different places.

### In the editor

To get around the limitations of showing media embed previews, you can use services like [Iframely](https://iframely.com/). This will allow a rich preview of the content inside CKEditor 5. By inserting an Iframely-hosted `<iframe>`, you can preview the content from hundreds of media providers.

Follow the [Iframely integration with CKEditor 5](https://iframely.com/docs/ckeditor) page for a detailed explanation. You can also check the final result in the demo below. If you are using ad-blocking software, it might also block the previews inside the editor.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### On your website

By default, the media embed feature produces output that does not contain previews of embedded media, called the [semantic output](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--semantic-data-output-default). This means that you need to transform the output `<oembed>` elements into real media on your target website.

There are many ways to do that. The simplest plug-and-play solutions are described here. You can also implement this transformation as part of your backend service, or you can use different services than described in this section.

> **Note**
>
> While the easiest solution (described below) is to replace embedded media on the client side, it is not necessarily the most optimal way. A more powerful and flexible solution is to request these services on your backend. Refer to the documentation of the service of your choice for more information.

#### Iframely

[Iframely](https://iframely.com) offers the [embed.js](https://iframely.com/docs/embedjs) library, which converts [various media](https://iframely.com/docs/providers) URLs into rich previews. It works in the frontend and remains fully compatible with the output produced by CKEditor 5.

First, having [secured the API key](https://iframely.com/docs/allow-origins), load the `embed.js` library from the CDN into your website:

```html
<head>
    ...
    <script charset="utf-8" src="//cdn.iframe.ly/embed.js?api_key={API KEY}"></script>
    ...
</head>
```

##### Semantic data

You can convert all `<oembed>` elements like the following X (Twitter) post produced by CKEditor 5:

```html
<figure class="media">
    <oembed url="https://x.com/ckeditor/status/1021777799844126720"></oembed>
</figure>
```

using this short code snippet:

```html
<script>
    document.querySelectorAll( 'oembed[url]' ).forEach( element => {
        iframely.load( element, element.attributes.url.value );
    } );
</script>
```

##### Non-semantic data

When you configure the feature to [include media previews](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--including-previews-in-data) in the output, you can still use Iframely for media embeds like the following one:

```html
<figure class="media">
    <div data-oembed-url="https://x.com/ckeditor/status/1021777799844126720">
        [Media preview]
    </div>
</figure>
```

You can still convert this data by Iframely with just a few extra lines of code. To achieve that, in addition to the code snippet from the previous section, use a slightly longer code snippet that discards the media preview saved in the database before using `iframely.load()`:

```html
<script>
    document.querySelectorAll( 'div[data-oembed-url]' ).forEach( element => {
        // Discard the static media preview from the database (empty the <div data-oembed-url="...">).
        while ( element.firstChild ) {
            element.removeChild( element.firstChild );
        }

// Generate the media preview using Iframely.
        iframely.load( element, element.dataset.oembedUrl ) ;
    } );
</script>
```

#### Embedly

Just like Iframely, [Embedly](https://embed.ly) offers the client–side API, which converts media URLs into rich previews.

To start using it, load the library from the CDN into your website:

```html
<head>
    ...
    <script async charset="utf-8" src="//cdn.embedly.com/widgets/platform.js"></script>
    ...
</head>
```

##### Semantic data

You can convert `<oembed>` elements like the following Twitter (X) post produced by CKEditor 5:

```html
<figure class="media">
    <oembed url="https://x.com/ckeditor/status/1021777799844126720"></oembed>
</figure>
```

using this code snippet:

```html
<script>
    document.querySelectorAll( 'oembed[url]' ).forEach( element => {
        // Create the <a href="..." class="embedly-card"></a> element that Embedly uses
        // to discover the media.
        const anchor = document.createElement( 'a' );

anchor.setAttribute( 'href', element.getAttribute( 'url' ) );
        anchor.className = 'embedly-card';

element.appendChild( anchor );
    } );
</script>
```

Embedly automatically discovers links like `<a href="..." class="embedly-card"></a>` and replaces them with rich media previews.

##### Non-semantic data

In this case, the code is almost the same as with the semantic data, but you should discard the media preview saved in the database before using Embedly to avoid code duplication:

// Create the <a href="..." class="embedly-card"></a> element that Embedly uses
        // to discover the media.
        const anchor = document.createElement( 'a' );

anchor.setAttribute( 'href', element.dataset.oembedUrl );
        anchor.className = 'embedly-card';

element.appendChild( anchor );
    } );
</script>
```

### Known issues

The [media embed resize feature](#ckeditor5/latest/features/media-embed/media-embed-resize.html) (`MediaEmbedResize`) is not compatible with proxy-based preview providers like Iframely or Embedly. The proxy controls the iframe height at runtime, so a user-applied width on the `<figure>` no longer matches the proxy-chosen height. Remove `MediaEmbedResize` from `plugins` (or pass it via `removePlugins`) in setups that use these providers. If you still need to control the size of these embeds, register a width-applying custom style through [`config.mediaEmbed.styles`](#ckeditor5/latest/features/media-embed/media-embed-styles.html) that sets a `width` on the `<figure>`.

<a id="ckeditor5/latest/features/media-embed/media-embed-resize.html">source file: "ckeditor5/latest/features/media-embed/media-embed-resize.html"</a>

## Resizing media embeds

The media embed resize feature lets you change the width of media embeds (such as YouTube or Vimeo videos) in your content. It is implemented by the [`MediaEmbedResize`](../../api/module_media-embed_mediaembedresize-MediaEmbedResize.html) plugin.

### Demo

Click the media embed in the editor below to select it, then drag any of its corner handles to change the width.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Methods to resize media embeds

You can resize media embeds using any of the following methods:

* [Drag handles](#ckeditor5/latest/features/media-embed/media-embed-resize.html--using-resize-handles) — click and drag the corner handles of a selected media widget.
* [Resize dropdown](#ckeditor5/latest/features/media-embed/media-embed-resize.html--using-the-resize-dropdown) — pick a predefined size or set a custom width via a toolbar dropdown.
* [Standalone resize buttons](#ckeditor5/latest/features/media-embed/media-embed-resize.html--using-standalone-resize-buttons) — place individual buttons for each predefined size in the media toolbar.

Both the dropdown and the standalone buttons are fully keyboard-accessible and satisfy the WCAG 2.1 keyboard navigation requirements.

#### Using resize handles

When enabled, selecting a media widget shows four corner resize handles. Dragging a handle resizes the embed proportionally while preserving its aspect ratio.

#### Using the resize dropdown

Add `'resizeMediaEmbed'` to the `mediaEmbed.toolbar` option to show a dropdown in the media embed toolbar. The dropdown contains a list of predefined sizes, a **Custom** entry that opens a balloon with a numeric input, and an **Original** entry that removes any applied resize.

```js
ClassicEditor
    .create( {
        /* ... */
        mediaEmbed: {
            toolbar: [ 'resizeMediaEmbed' ],
            resizeOptions: [
                { name: 'resizeMediaEmbed:original', value: null,     icon: 'original' },
                { name: 'resizeMediaEmbed:custom',   value: 'custom', icon: 'custom'   },
                { name: 'resizeMediaEmbed:25',       value: '25',     icon: 'small'    },
                { name: 'resizeMediaEmbed:50',       value: '50',     icon: 'medium'   },
                { name: 'resizeMediaEmbed:75',       value: '75',     icon: 'large'    }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Using standalone resize buttons

You can also place individual resize buttons in the toolbar instead of using a dropdown. Each button corresponds to one resize option and can be identified by a `'resizeMediaEmbed:<value>'` name.

```js
ClassicEditor
    .create( {
        /* ... */
        mediaEmbed: {
            toolbar: [
                'resizeMediaEmbed:25',
                'resizeMediaEmbed:50',
                'resizeMediaEmbed:75',
                'resizeMediaEmbed:original',
                'resizeMediaEmbed:custom'
            ],
            resizeOptions: [
                { name: 'resizeMediaEmbed:original', value: null,     icon: 'original' },
                { name: 'resizeMediaEmbed:custom',   value: 'custom', icon: 'custom'   },
                { name: 'resizeMediaEmbed:25',       value: '25',     icon: 'small'    },
                { name: 'resizeMediaEmbed:50',       value: '50',     icon: 'medium'   },
                { name: 'resizeMediaEmbed:75',       value: '75',     icon: 'large'    }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Disabling resize handles

You can load `MediaEmbedResizeEditing`, `MediaEmbedResizeButtons`, and `MediaEmbedCustomResizeUI` without `MediaEmbedResizeHandles` to get a keyboard-only resize setup:

**NPM**

```js
import {
	ClassicEditor,
	MediaEmbed,
	MediaEmbedToolbar,
	MediaEmbedResizeEditing,
	MediaEmbedResizeButtons,
	MediaEmbedCustomResizeUI
} from 'ckeditor5';

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedResizeEditing, MediaEmbedResizeButtons, MediaEmbedCustomResizeUI, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			toolbar: [ 'resizeMediaEmbed' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const {
	ClassicEditor,
	MediaEmbed,
	MediaEmbedToolbar,
	MediaEmbedResizeEditing,
	MediaEmbedResizeButtons,
	MediaEmbedCustomResizeUI
} = CKEDITOR;

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedResizeEditing, MediaEmbedResizeButtons, MediaEmbedCustomResizeUI, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			toolbar: [ 'resizeMediaEmbed' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

This setup also needs [`MediaEmbedToolbar`](../../api/module_media-embed_mediaembedtoolbar-MediaEmbedToolbar.html), which is not loaded by [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) either. It renders the `'resizeMediaEmbed'` entry from `config.mediaEmbed.toolbar` in the media widget toolbar.

### Markup and styling

When a media embed is resized, the editor adds a `media_resized` class and an inline `width` style to the `<figure>` element (regardless of the `previewsInData` setting):

```html
<figure class="media media_resized" style="width:50%;">...</figure>
```

### Using pixel values instead of percentage width

By default, the resize values are expressed as percentages. To use pixel values instead, set `mediaEmbed.resizeUnit` to `'px'` and adjust the `resizeOptions` accordingly:

```js
ClassicEditor
    .create( {
        /* ... */
        mediaEmbed: {
            resizeUnit: 'px',
            resizeOptions: [
                { name: 'resizeMediaEmbed:original', value: null,  icon: 'original' },
                { name: 'resizeMediaEmbed:custom',   value: 'custom', icon: 'custom' },
                { name: 'resizeMediaEmbed:200',      value: '200', icon: 'small'    },
                { name: 'resizeMediaEmbed:400',      value: '400', icon: 'medium'   },
                { name: 'resizeMediaEmbed:600',      value: '600', icon: 'large'    }
            ],
            toolbar: [ 'resizeMediaEmbed' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Installation

The [`MediaEmbedResize`](../../api/module_media-embed_mediaembedresize-MediaEmbedResize.html) plugin is not loaded by default. Add it explicitly alongside [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) to enable the feature. The `MediaEmbedResize` glue plugin loads all four sub-plugins automatically:

**NPM**

```js
import { ClassicEditor, MediaEmbed, MediaEmbedToolbar, MediaEmbedResize } from 'ckeditor5';

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedResize, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			toolbar: [ 'resizeMediaEmbed' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, MediaEmbed, MediaEmbedToolbar, MediaEmbedResize } = CKEDITOR;

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedResize, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			toolbar: [ 'resizeMediaEmbed' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

Similarly, [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) doesn’t load [`MediaEmbedToolbar`](../../api/module_media-embed_mediaembedtoolbar-MediaEmbedToolbar.html) by default. Add `MediaEmbedToolbar` to your `plugins` list, otherwise the entries you put in `config.mediaEmbed.toolbar` never reach the media widget toolbar.

### Common API

The [`MediaEmbedResize`](../../api/module_media-embed_mediaembedresize-MediaEmbedResize.html) plugin registers:

* [`MediaEmbedResizeButtons`](../../api/module_media-embed_mediaembedresize_mediaembedresizebuttons-MediaEmbedResizeButtons.html) — the toolbar buttons and dropdown plugin.

* [`MediaEmbedCustomResizeUI`](../../api/module_media-embed_mediaembedresize_mediaembedcustomresizeui-MediaEmbedCustomResizeUI.html) — the balloon with the custom-width input.

* the `'resizeMediaEmbed'` dropdown component registered in the component factory.

* standalone `'resizeMediaEmbed:<value>'` button components (one for each entry in `config.mediaEmbed.resizeOptions`).

* the `'resizeMediaEmbed'` command implemented by [`ResizeMediaEmbedCommand`](../../api/module_media-embed_mediaembedresize_resizemediaembedcommand-ResizeMediaEmbedCommand.html).

You can resize the selected media embed or remove a previously-applied resize by executing the following code:

```js
  // Resize the selected media to 50% width.
  editor.execute( 'resizeMediaEmbed', { width: '50%' } );

// Remove the width to return to the default size.
  editor.execute( 'resizeMediaEmbed', { width: null } );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-media-embed>.

<a id="ckeditor5/latest/features/media-embed/media-embed-styles.html">source file: "ckeditor5/latest/features/media-embed/media-embed-styles.html"</a>

## Media embed styles

The media embed styles feature lets you apply a style (for example, an alignment) to a media embed such as a YouTube or Vimeo video, a Spotify player, and so on. It is implemented by the [`MediaEmbedStyle`](../../api/module_media-embed_mediaembedstyle-MediaEmbedStyle.html) plugin.

Out of the box the plugin ships five alignment styles. You can pick a subset of the built-ins, override their labels or icons, or register completely new styles through [`config.mediaEmbed.styles`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-styles).

### Installation

The [`MediaEmbedStyle`](../../api/module_media-embed_mediaembedstyle-MediaEmbedStyle.html) plugin is not loaded by default. Add it explicitly alongside [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) to enable the feature:

**NPM**

```js
import { ClassicEditor, MediaEmbed, MediaEmbedToolbar, MediaEmbedStyle } from 'ckeditor5';

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedStyle, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, MediaEmbed, MediaEmbedToolbar, MediaEmbedStyle } = CKEDITOR;

ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ MediaEmbed, MediaEmbedToolbar, MediaEmbedStyle, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

Similarly, [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) doesn’t load [`MediaEmbedToolbar`](../../api/module_media-embed_mediaembedtoolbar-MediaEmbedToolbar.html) by default. The toolbar contains style buttons for media embed features. Add `MediaEmbedToolbar` to your `plugins` list, otherwise the entries you put in `config.mediaEmbed.toolbar` never reach the media widget toolbar.

### Built-in styles

The plugin provides the following five style options out of the box. Each option registers a toolbar button under the name `mediaEmbed:<style-name>` (used to place it in `config.mediaEmbed.toolbar`) and, for non-default styles, applies a CSS class to the media `<figure>` element. The default `alignCenter` option emits no class.

**Block alignments** – the media takes a full line, with surrounding text appearing above and below.

* **Left aligned** – button `mediaEmbed:alignBlockLeft`, class `media-style-block-align-left`.
* **Centered** – button `mediaEmbed:alignCenter`; default, no class.
* **Right aligned** – button `mediaEmbed:alignBlockRight`, class `media-style-block-align-right`.

**Wrap-text alignments** – the media floats to one side and surrounding text wraps around it.

* **Left aligned** – button `mediaEmbed:alignLeft`, class `media-style-align-left`.
* **Right aligned** – button `mediaEmbed:alignRight`, class `media-style-align-right`.

> **Note**
>
> The actual styling of the media embeds is the job of the integrator. CKEditor 5 comes with some default styles, but they will only be applied to the media inside the editor. The integrator needs to style them appropriately on the target pages.
>
> You can find the source of the default styles applied by the editor here: [`ckeditor5-media-embed/theme/index-content.css`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-media-embed/theme/index-content.css).
>
> Read more about [styling the content of the editor](#ckeditor5/latest/getting-started/setup/css.html).

The demo below shows the five built-in alignment styles, wired through the two compact split-button dropdowns and combined with the [media embed resize feature](#ckeditor5/latest/features/media-embed/media-embed-resize.html). Select a figure and try the **Wrap text** and **Break text** dropdowns in its contextual toolbar – the action button reflects whichever alignment is currently applied.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Configuring the styles

You can customize the set of available styles through [`config.mediaEmbed.styles`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-styles). The configuration accepts an `options` array whose entries can be:

* a **string** referencing a built-in style by name (`'alignLeft'`, `'alignBlockLeft'`, `'alignCenter'`, `'alignBlockRight'`, `'alignRight'`),
* an **object** whose `name` matches a built-in (its fields are shallow-merged on top of the built-in),
* an **object** with a new `name` (a fully custom style). See [`MediaStyleOptionDefinition`](../../api/module_media-embed_mediaembedconfig-MediaStyleOptionDefinition.html) for the required and optional fields.

When `config.mediaEmbed.styles` is not provided, all five built-in styles are available. This is the default behavior.

> **Warning**
>
> When a configured style option misses a required field (`name`, `title`, `icon`, or `className` for non-default styles), or references an unknown built-in name, the entry is dropped from the resolved options and a console warning is emitted under the `media-style-configuration-definition-invalid` error code. The other valid entries continue to work as configured.

#### Picking a subset of built-in styles

Pass only the styles you want to expose. Filtered-out styles disappear from the toolbar and cannot be applied through the `'mediaStyle'` command.

```js
mediaEmbed: {
    styles: {
        options: [ 'alignBlockLeft', 'alignCenter', 'alignBlockRight' ]
    }
}
```

In the example above the wrap-text floats (`alignLeft`, `alignRight`) are dropped. The `mediaEmbed:wrapText` dropdown auto-skips because both of its items were filtered out, and only the three block alignments remain.

#### Overriding a built-in style

To customize a built-in style, pass an object whose `name` matches the built-in plus the fields you want to change. Fields you set replace the built-in’s defaults. Fields you omit are inherited.

```js
mediaEmbed: {
    styles: {
        options: [
            'alignLeft',
            { name: 'alignCenter', title: 'Center' },
            'alignRight'
        ]
    }
}
```

#### Adding a custom style

To add a custom style, supply an object with a fresh `name`, a `title`, an `icon`, and a `className`. You own the CSS for the resulting class. The plugin only writes the class to the figure when the style is applied.

```js
import sideMediaIcon from 'path/to/side-media.svg';

ClassicEditor
    .create( {
        // ... Other configuration options ...
        mediaEmbed: {
            toolbar: [ 'mediaEmbed:alignCenter', 'mediaEmbed:side' ],
            styles: {
                options: [
                    'alignCenter',
                    {
                        name: 'side',
                        title: 'Side media',
                        icon: sideMediaIcon,
                        className: 'media-style-side'
                    }
                ]
            }
        }
    } );
```

> **Note**
>
> The `icon` field accepts either a full SVG XML string (as shown above) or one of the short aliases shipped with the plugin: `'inlineLeft'`, `'left'`, `'center'`, `'right'`, `'inlineRight'`.

```css
/* Your CSS for the custom style. */
.ck-content .media.media-style-side {
    float: right;
    margin: 0 0 1em 1.5em;
    clear: none;
    box-shadow: 0 4px 16px rgba( 0, 0, 0, 0.2 );
}
```

The same mechanism supports purely semantical styles. There is no requirement that a custom style be alignment-flavored.

To group several custom styles under a single split button in the toolbar, see [Custom split-button dropdowns](#ckeditor5/latest/features/media-embed/media-embed-styles.html--toolbar-configuration) below.

#### Custom default style

To mark a style as the default, set `isDefault: true`. Default styles do not need a `className` because the default state is encoded on the model as the absence of the `mediaStyle` attribute, so no class is written to the view. Applying a default style clears any other style that was previously set.

```js
import naturalIcon from 'path/to/natural.svg';

mediaEmbed: {
    styles: {
        options: [
            'alignBlockLeft',
            {
                name: 'natural',
                title: 'Natural position',
                icon: naturalIcon,
                isDefault: true
            },
            'alignBlockRight'
        ]
    }
}
```

> **Warning**
>
> Only one style should be marked as the default. If multiple are marked, the first one in the resolved options wins. If none is marked, the command has no default. In that case, `command.value` is `false` whenever the selected media has no `mediaStyle` attribute.

#### Demo

The demo below replaces the built-in alignments with three custom semantic styles – a Featured frame and two side asides grouped in a custom split-button dropdown. Select a figure to open the contextual toolbar.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Toolbar configuration

Each entry in [`config.mediaEmbed.toolbar`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-toolbar) is either a built-in component name (string) or an inline split-button dropdown definition (object). You can mix them freely.

**Built-in dropdowns**: `mediaEmbed:wrapText` groups the wrap-text alignments and `mediaEmbed:breakText` groups the block alignments. Each dropdown’s action button reflects whichever option from its group is currently applied to the selected media, falling back to the dropdown’s default (`alignLeft` for wrap, `alignCenter` for break) when none is applied. A dropdown is skipped automatically when fewer than two of its items survive your style configuration.

```js
mediaEmbed: {
    toolbar: [ 'mediaEmbed:wrapText', 'mediaEmbed:breakText' ]
}
```

**Flat buttons**: every style is also exposed as an individual button named `mediaEmbed:<style-name>`.

```js
mediaEmbed: {
    toolbar: [
        'mediaEmbed:alignLeft', 'mediaEmbed:alignBlockLeft',
        'mediaEmbed:alignCenter',
        'mediaEmbed:alignBlockRight', 'mediaEmbed:alignRight'
    ]
}
```

**Custom split-button dropdowns**: declare your own grouping inline, alongside built-in entries. The definition follows the [`MediaStyleDropdownDefinition`](../../api/module_media-embed_mediaembedconfig-MediaStyleDropdownDefinition.html) shape – `name`, `title`, `items`, `defaultItem` – and all names use the full `mediaEmbed:` prefix.

```js
mediaEmbed: {
    toolbar: [
        'mediaEmbed:alignCenter',
        {
            name: 'mediaEmbed:myAlignments',
            title: 'Alignment',
            items: [ 'mediaEmbed:alignBlockLeft', 'mediaEmbed:alignBlockRight' ],
            defaultItem: 'mediaEmbed:alignBlockLeft'
        }
    ]
}
```

Custom dropdowns inherit the same item-filtering and skip behavior as the built-in dropdowns:

* Items referencing styles that are not in the resolved `config.mediaEmbed.styles.options` list are filtered out at registration time. For custom dropdowns this also emits a console warning under `media-style-configuration-definition-invalid` so you know the config was not fully honored. Built-in dropdowns auto-skip silently.
* A dropdown that ends up with fewer than two items is skipped entirely.
* If the configured `defaultItem` was filtered out, the first surviving item becomes the new default.

A dropdown definition is also dropped (with the same warning) when its `name` lacks the `mediaEmbed:` prefix, `items` is empty or contains non-prefixed entries, `defaultItem` is not one of `items`, or `title` is empty.

### Interaction with resizing

> **Note**
>
> If you use the built-in alignment styles, you should combine them with the optional [media embed resize feature](#ckeditor5/latest/features/media-embed/media-embed-resize.html) as the two features were designed to be used together: resizing controls the width, alignment controls the position.
>
> Without the resize feature, embeds span the full width of the editor by default and the alignment classes have no visible effect, because the figure already occupies the full row. Alignment starts producing a visible effect once the figure is narrower than its container (via the resize feature, your own CSS, or `style` preserved by other means).
>
> Custom non-alignment styles (for example, a drop shadow or border treatment) do not depend on width and work regardless of whether resizing is enabled.

The HTML representation of an aligned and [resized](#ckeditor5/latest/features/media-embed/media-embed-resize.html) media embed looks like this:

```html
<figure class="media media_resized media-style-align-left" style="width:50%;">...</figure>
```

### Common API

The [`MediaEmbedStyle`](../../api/module_media-embed_mediaembedstyle-MediaEmbedStyle.html) plugin registers:

* A button for each style option, for example `'mediaEmbed:alignLeft'` and `'mediaEmbed:alignCenter'` (to use in the media embed contextual toolbar).

* Two built-in split-button dropdowns: `'mediaEmbed:wrapText'` and `'mediaEmbed:breakText'`. Each is skipped automatically when fewer than two of its items survive your style configuration.

* Any custom split-button dropdowns declared inline in [`config.mediaEmbed.toolbar`](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-toolbar).

* The [`'mediaStyle'` command](../../api/module_media-embed_mediaembedstyle_mediaembedstylecommand-MediaEmbedStyleCommand.html). It accepts a value matching one of the resolved [configured options](../../api/module_media-embed_mediaembedconfig-MediaEmbedConfig.html#member-styles):

```js
  // Float the selected media to the left so text wraps around it.
  editor.execute( 'mediaStyle', { value: 'alignLeft' } );

// Clear the style to return to the default state.
  editor.execute( 'mediaStyle', { value: null } );
  ```

Values outside the resolved options are silently rejected. Passing the effective default name (or `null`) always clears the attribute.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-media-embed>.

<a id="ckeditor5/latest/features/media-embed/media-embed.html">source file: "ckeditor5/latest/features/media-embed/media-embed.html"</a>

## Media embed

The media embed feature lets you insert embeddable media such as YouTube or Vimeo videos and tweets into your rich text content.

### Demo

You can use the insert media button in the toolbar to embed media. You can also paste a media URL directly into the editor content, and it will be [automatically embedded](#ckeditor5/latest/features/media-embed/media-embed.html--automatic-media-embed-on-paste). Try both approaches with the following URLs:

*
*
*

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, MediaEmbed } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ MediaEmbed, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, MediaEmbed } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ MediaEmbed, /* ... */ ],
		toolbar: [ 'mediaEmbed', /* ... */ ],
		mediaEmbed: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Depending on how you will configure this feature, you may need to use services like [Iframely](https://iframely.com/) or [Embedly](https://embed.ly/) to display content of embedded media on your target website. Read more about [displaying embedded media](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html).

### Media embed features

The [`@ckeditor/ckeditor5-media-embed`](https://www.npmjs.com/package/@ckeditor/ckeditor5-media-embed) package contains multiple plugins that implement media-related features:

* [Configuration](#ckeditor5/latest/features/media-embed/media-embed-configuration.html) – set the data output format and extend, remove, or override the default media providers.
* [External services](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html) – use Iframely or Embedly to render rich previews inside the editor and on your target website.
* [Resizing media embeds](#ckeditor5/latest/features/media-embed/media-embed-resize.html) – enable drag handles, a toolbar dropdown, or standalone buttons for predefined sizes plus a custom-width balloon for media widgets (premium).
* [Media embed styles](#ckeditor5/latest/features/media-embed/media-embed-styles.html) – alignment and other configurable styles applied to the media `<figure>` (alignment built-ins, customizable per integrator).
* [Styling non-previewable media](#ckeditor5/latest/features/media-embed/styling-non-previewable-media.html) – create dedicated styles for specific non-previewable media providers.

### Previewable and non-previewable media

When the media embed feature is asked to embed a specific media element via its URL, it needs to decide about how the media will be displayed in the editor.

#### Previewable media

If, for instance, the URL to embed is `https://www.youtube.com/watch?v=H08tGjXNHO4`, the feature can predict that it needs to produce the following HTML to show this YouTube video:

```html
<div>
    <iframe src="https://www.youtube.com/embed/${ videoId }"
        width="1280" height="720"
        style="width: 100%; height: auto; aspect-ratio: 16 / 9; border: 0; display: block;"
        frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
    </iframe>
</div>
```

The CSS `aspect-ratio` property keeps the video responsive, while the HTML `width` and `height` attributes provide an intrinsic size so the iframe behaves well in table cells and other layout contexts. The crucial part is the iframe element’s `src` which the media embed feature predicts based on the given video URL.

Thanks to the ability to hardcode this URL to HTML transformation, the media embed feature can show previews of YouTube, Dailymotion, or Vimeo videos, and Spotify widgets without requesting any external service.

#### Non-previewable media

Unfortunately, to show previews of media such as tweets, Instagram photos, or Facebook posts, the editor would need to retrieve the content of these from an external service. Some of these media providers expose [oEmbed endpoints](https://oembed.com/) but not all. These endpoint responses often require further processing to be embeddable. Most importantly, though, the media embed feature is often not able to request these services due to the [same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy).

Also, the media embed feature [does not support asynchronous preview providers](https://github.com/ckeditor/ckeditor5-media-embed/issues/16) yet. Therefore, to still allow embedding tweets or Instagram photos, we chose to:

1. Show a placeholder of the embedded media in the editor (see how a tweet is presented in the [demo](#ckeditor5/latest/features/media-embed/media-embed.html--demo) above).
2. Produce a [semantic `<oembed url="...">` tag](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--semantic-data-output-default) in the data output from the editor. This output makes it possible to later use proxy services to [display the content of these media on your website](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html).

You can overcome these limitations with the help of proxy services like Iframely or Embedly. See [Using external services for media previews](#ckeditor5/latest/features/media-embed/media-embed-external-preview.html).

### Automatic media embed on paste

By default, the [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) plugin loads the [`AutoMediaEmbed`](../../api/module_media-embed_automediaembed-AutoMediaEmbed.html) as a dependency.

The [`AutoMediaEmbed`](../../api/module_media-embed_automediaembed-AutoMediaEmbed.html) plugin recognizes media links in the pasted content and embeds them shortly after they are injected into the document to speed up the editing. Just like the “traditional” embedding (using the toolbar button), automatic embedding works for all media providers specified in the [configuration](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--media-providers).

> **Note**
>
> The media URL must be the only content pasted to be properly embedded. Multiple links (`"http://media.url http://another.media.url"`) as well as bigger chunks of content (`"This link http://media.url will not be auto–embedded when pasted."`) are ignored.

If the automatic embedding was unexpected, for instance when the link was meant to remain in the content as text, undo the action (by clicking the “Undo” button in the toolbar or using the `Ctrl`/`Cmd`+`Z` keystrokes).

### Common API

The [`MediaEmbed`](../../api/module_media-embed_mediaembed-MediaEmbed.html) plugin registers:

* the `'mediaEmbed'` UI button component,

* the `'mediaEmbed'` command implemented by [`MediaEmbedCommand`](../../api/module_media-embed_mediaembedcommand-MediaEmbedCommand.html).

You can insert a new media element or update the selected media URL by executing the following code:

```js
  editor.execute( 'mediaEmbed', 'http://url.to.the/media' );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-media-embed>.

<a id="ckeditor5/latest/features/media-embed/styling-non-previewable-media.html">source file: "ckeditor5/latest/features/media-embed/styling-non-previewable-media.html"</a>

## Styling non-previewable media

You can create additional styles for non-previewable media in your editor content to help users identify them. The editor styles popular providers such as Facebook, Instagram, and X by default, but leaves media it cannot preview without a distinct look.

The HTML structure of every non-previewable media in the editor is as follows:

```html
<figure class="media ck-widget" contenteditable="false">
    <div class="ck-media__wrapper" data-oembed-url="[ URL of the media ]">
        <div class="ck ck-reset_all ck-media__placeholder">
            <div class="ck-media__placeholder__icon">
                <svg class="ck ck-icon">...</svg>
            </div>
            <a class="ck-media__placeholder__url" target="new" href="[ URL of the media]">
                <span class="ck-media__placeholder__url__text">[ URL of the media]</span>
            </a>
        </div>
    </div>
</figure>
```

For example, you can create a dedicated style for media coming from the [ckeditor.com](https://ckeditor.com) domain. To accomplish that, you will need some additional styles included in your website.

First, you must hide the generic media icon displayed for non-previewable media:

```css
.ck-media__wrapper[data-oembed-url*="ckeditor.com"] .ck-media__placeholder__icon * {
    display: none;
}
```

Then, give the media a distinctive background color:

```css
.ck-media__wrapper[data-oembed-url*="ckeditor.com"] .ck-media__placeholder {
    background: hsl(282, 44%, 47%);
}
```

and introduce the custom icon identifying the media:

```css
.ck-media__wrapper[data-oembed-url*="ckeditor.com"] .ck-media__placeholder__icon {
    background-image: url(data:image/svg+xml;base64,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);
}
```

Finally, make sure the URL in the placeholder has the right contrast:

```css
.ck-media__wrapper[data-oembed-url*="ckeditor.com"] .ck-media__placeholder__url .ck-media__placeholder__url__text {
    color: hsl(282, 100%, 93%);
}

.ck-media__wrapper[data-oembed-url*="ckeditor.com"] .ck-media__placeholder__url .ck-media__placeholder__url__text:hover {
    color: hsl(0, 100%, 100%);
}
```

Before you load the data, make sure the `ckeditor.com` provider is [enabled in your configuration](#ckeditor5/latest/features/media-embed/media-embed-configuration.html--extending-media-providers). In its most basic form, it could look like this:

```js
mediaEmbed: {
    extraProviders: [
        {
            name: 'ckeditor',
            url: /^ckeditor\.com/
        }
    ]
}
```

Having your styles defined and the media provider configured, insert the new media into your editor, for example, the following URL: `https://ckeditor.com/path/to/media`. You should see something like this:

<a id="ckeditor5/latest/features/mentions.html">source file: "ckeditor5/latest/features/mentions.html"</a>

## Mentions (autocompletion)

The mention feature enables smart autocompletion based on user input. When you type a pre-configured marker, such as `@` or `#`, a panel displays with autocomplete suggestions.

### Demo

You can type the “@” character to invoke the mention autocomplete UI. The demo below is configured to suggest a static list of names (`Barney`, `Lily`, `Marry Ann`, `Marshall`, `Robin`, and `Ted`).

> **Note**
>
> This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.
>
> You can also check out the [more advanced example](#ckeditor5/latest/examples/framework/chat-with-mentions.html) of the mention feature used in a chat application.

You can read more about possible implementations of the mention feature in a [dedicated blog post](https://ckeditor.com/blog/mentions-in-ckeditor-5-feature-of-the-month/).

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Mention } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Mention, /* ... */ ],
		mention: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Mention } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Mention, /* ... */ ],
		mention: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Unsupported contexts

The mention autocompletion is automatically disabled inside [code blocks](#ckeditor5/latest/features/code-blocks.html). Typing a mention marker (such as `@`) inside a code block will not trigger the autocomplete panel. This also applies to features built on top of mentions, such as [slash commands](#ckeditor5/latest/features/slash-commands.html) and [emoji](#ckeditor5/latest/features/emoji.html) autocompletion.

If you want to disable this behavior and allow mention autocompletion inside code blocks, you can override it using the [`Schema#checkAttribute`](../api/module_engine_model_schema-ModelSchema.html#event-checkAttribute) event:

```js
editor.model.schema.on( 'checkAttribute', ( evt, args ) => {
    const context = args[ 0 ];
    const attributeName = args[ 1 ];

if ( attributeName === 'mention' && context.endsWith( 'codeBlock $text' ) ) {
        evt.stop();
        evt.return = true;
    }
}, { priority: 'high' } );
```

### Configuration

The minimal configuration of the mention feature requires defining a [`feed`](../api/module_mention_mentionconfig-MentionFeed.html) and a [`marker`](../api/module_mention_mentionconfig-MentionFeed.html). You can also define the `minimumCharacters` parameter, setting the number of letters after which the autocomplete panel will show up. Moreover, feed items’ IDs may include whitespaces.

The code snippet below was used to configure the demo above. It defines the list of names that the editor will autocomplete after the user types the “@” character.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mention: {
            feeds: [
                {
                    marker: '@',
                    feed: [ '@Barney', '@Lily', '@Marry Ann', '@Marshall', '@Robin', '@Ted' ],
                    minimumCharacters: 1
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Additionally, you can configure:

* How the item is rendered in the autocomplete panel (via setting [`itemRenderer`](../api/module_mention_mentionconfig-MentionFeed.html)). See [Customizing the autocomplete list](#ckeditor5/latest/features/mentions.html--customizing-the-autocomplete-list).
* How the item is converted during the [conversion](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion). See [Customizing the output](#ckeditor5/latest/features/mentions.html--customizing-the-output).
* Multiple feeds. The demo above uses only one feed, which is triggered by the `'@'` character. You can define multiple feeds but they must use different markers. For example, you can use `'@'` for people and `'#'` for tags.

#### Providing the feed

The [`feed`](../api/module_mention_mentionconfig-MentionFeed.html) can be provided as:

* A static array – Good for scenarios with a relatively small set of autocomplete items.
* A callback – Provides more control over the returned list of items.

When using a callback you can return a `Promise` that resolves with the list of [matching feed items](../api/module_mention_mentionconfig-MentionFeedItem.html). These can be simple strings or plain objects with at least the `name` property. The other properties of this object can later be used when [customizing the autocomplete list](#ckeditor5/latest/features/mentions.html--customizing-the-autocomplete-list) or [customizing the output](#ckeditor5/latest/features/mentions.html--customizing-the-output).

> **Note**
>
> When using external resources to obtain the feed it is recommended to add some caching mechanism so subsequent calls for the same suggestion would load faster.
>
> You can also consider adding the `minimumCharacters` option to the feed configuration so the editor will call the feed callback after some minimum number of characters typed instead of an action on a marker alone.

The callback receives the query text which should be used to filter item suggestions. It should return a `Promise` and resolve it with an array of items that match the feed text.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mention: {
            feeds: [
                {
                    marker: '@',
                    feed: getFeedItems
                }
            }
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );

const items = [
    { id: '@swarley', userId: '1', name: 'Barney Stinson', link: 'https://www.imdb.com/title/tt0460649/characters/nm0000439' },
    { id: '@lilypad', userId: '2', name: 'Lily Aldrin', link: 'https://www.imdb.com/title/tt0460649/characters/nm0004989' },
    { id: '@marry', userId: '3', name: 'Marry Ann Lewis', link: 'https://www.imdb.com/title/tt0460649/characters/nm1130627' },
    { id: '@marshmallow', userId: '4', name: 'Marshall Eriksen', link: 'https://www.imdb.com/title/tt0460649/characters/nm0781981' },
    { id: '@rsparkles', userId: '5', name: 'Robin Scherbatsky', link: 'https://www.imdb.com/title/tt0460649/characters/nm1130627' },
    { id: '@tdog', userId: '6', name: 'Ted Mosby', link: 'https://www.imdb.com/title/tt0460649/characters/nm1102140' }
];

function getFeedItems( queryText ) {
    // As an example of an asynchronous action, return a promise
    // that resolves after a 100ms timeout.
    // This can be a server request or any sort of delayed action.
    return new Promise( resolve => {
        setTimeout( () => {
            const itemsToDisplay = items
                // Filter out the full list of all items to only those matching the query text.
                .filter( isItemMatching )
                // Return 10 items max - needed for generic queries when the list may contain hundreds of elements.
                .slice( 0, 10 );

resolve( itemsToDisplay );
        }, 100 );
    } );

// Filtering function - it uses the `name` and `username` properties of an item to find a match.
    function isItemMatching( item ) {
        // Make the search case-insensitive.
        const searchString = queryText.toLowerCase();

// Include an item in the search results if the name or username includes the current user input.
        return (
            item.name.toLowerCase().includes( searchString ) ||
            item.id.toLowerCase().includes( searchString )
        );
    }
}
```

A full, working demo with all possible customizations and its source code is available [at the end of this section](#ckeditor5/latest/features/mentions.html--fully-customized-mention-feed).

#### Customizing the autocomplete list

##### Styling

The items displayed in the autocomplete list can be customized by defining the [`itemRenderer`](../api/module_mention_mentionconfig-MentionFeed.html) callback.

This callback takes a feed item (it contains at least the `name` property) and must return a new DOM element.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mention: {
            feeds: [
                {
                    feed: [ /* ... */ ],
                    // Define the custom item renderer.
                    itemRenderer: customItemRenderer
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );

function customItemRenderer( item ) {
    const itemElement = document.createElement( 'span' );

itemElement.classList.add( 'custom-item' );
    itemElement.id = `mention-list-item-id-${ item.userId }`;
    itemElement.textContent = `${ item.name } `;

const usernameElement = document.createElement( 'span' );

usernameElement.classList.add( 'custom-item-username' );
    usernameElement.textContent = item.id;

itemElement.appendChild( usernameElement );

return itemElement;
}
```

A full, working demo with all possible customizations and its source code is available [at the end of this section](#ckeditor5/latest/features/mentions.html--fully-customized-mention-feed).

##### List length

The number of items displayed in the autocomplete list can be customized by defining the [`dropdownLimit`](../api/module_mention_mentionconfig-MentionConfig.html#member-dropdownLimit) option.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mention: {
            // Define the custom number of visible mentions.
            dropdownLimit: 4
            feeds: [
                { /* ... */ }
                // More feeds.
                // ...
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

A full, working demo with all possible customizations and its source code is available [at the end of this section](#ckeditor5/latest/features/mentions.html--fully-customized-mention-feed).

#### Customizing the text inserted into the editor

You can control the text inserted into the editor when creating a mention via the [`text`](../api/module_mention_mentionconfig-MentionFeedObjectItem.html) property in the mention configuration.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mention: {
            feeds: [
                // Feed items as objects.
                {
                    marker: '@',
                    feed: [
                        {
                            id: '@Barney',
                            fullName: 'Barney Stinson',
                            // Custom text to be inserted into the editor
                            text: 'Swarley'
                        },
                        // ...
                    ]
                },
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The string that you specify in this property will be displayed in the editor when a mention is created.

#### Customizing the output

To change the markup generated by the editor for mentions, you can overwrite the default converter of the mention feature. To do that, you must specify both [upcast](../api/module_engine_conversion_upcastdispatcher-UpcastDispatcher.html) and [downcast](../api/module_engine_conversion_downcastdispatcher-DowncastDispatcher.html) converters using [`ViewAttributeElement`](../api/module_engine_view_attributeelement-ViewAttributeElement.html).

The example below defines a plugin that overrides the default output:

```html
<span data-mention="@Ted" class="mention">@Ted</span>
```

To a link:

```html
<a class="mention" data-mention="@Ted" data-user-id="5" href="https://www.imdb.com/title/tt0460649/characters/nm1102140">@tdog</a>
```

The converters must be defined with a `'high'` priority to be executed before the [link](#ckeditor5/latest/features/link.html) feature’s converter and before the default converter of the mention feature. A mention is stored in the model as a [text attribute](#ckeditor5/latest/framework/architecture/editing-engine.html--text-attributes) that stores an object (see [`MentionFeedItem`](../api/module_mention_mentionconfig-MentionFeedItem.html)).

To control how the mention element is wrapped by other attribute elements (like bold, italic, etc) set its [`priority`](../api/module_engine_view_attributeelement-ViewAttributeElement.html#member-priority). To replicate default plugin behavior and make mention to be wrapped by other elements set priority to `20`.

By default, attribute elements that are next to each other and have the same value will be rendered as a single HTML element. To prevent this, the model attribute value object exposes a unique ID of each inserted mention to the model as `uid`. To prevent merging subsequent mentions, set it as [`id`](../api/module_engine_view_attributeelement-ViewAttributeElement.html#member-id). The `uid` is persisted in the data output as the `data-mention-uid` attribute to guarantee that the same HTML always produces the same model. During clipboard (copy/cut) output, `data-mention-uid` is omitted so that pasted mentions receive fresh unique IDs.

**Note:** The feature prevents copying fragments of existing mentions. If only a part of a mention is selected, it will be copied as plain text. The internal converter with the [`'highest'` priority](../api/module_utils_priorities-PrioritiesType.html#member-highest) controls this behavior. We do not recommend adding mention converters with the `'highest'` priority to avoid collisions and quirky results.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [ Mention, MentionCustomization, /* ... */ ], // Add the custom mention plugin function.
        mention: {
            // Configuration.
            // ...
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );

function MentionCustomization( editor ) {
    // The upcast converter will convert view <a class="mention" href="" data-user-id="">
    // elements to the model 'mention' text attribute.
    editor.conversion.for( 'upcast' ).elementToAttribute( {
        view: {
            name: 'a',
            key: 'data-mention',
            classes: 'mention',
            attributes: {
                href: true,
                'data-user-id': true
            }
        },
        model: {
            key: 'mention',
            value: viewItem => {
                // The mention feature expects that the mention attribute value
                // in the model is a plain object with a set of additional attributes.
                // In order to create a proper object use the toMentionAttribute() helper method:
                const mentionAttribute = editor.plugins.get( 'Mention' ).toMentionAttribute( viewItem, {
                    // Add any other properties that you need.
                    link: viewItem.getAttribute( 'href' ),
                    userId: viewItem.getAttribute( 'data-user-id' )
                } );

return mentionAttribute;
            }
        },
        converterPriority: 'high'
    } );

// Downcast the model 'mention' text attribute to a view <a> element.
    editor.conversion.for( 'downcast' ).attributeToElement( {
        model: 'mention',
        view: ( modelAttributeValue, { writer, options } ) => {
            // Do not convert empty attributes (lack of value means no mention).
            if ( !modelAttributeValue ) {
                return;
            }

return writer.createAttributeElement( 'a', {
                class: 'mention',
                'data-mention': modelAttributeValue.id,
                'data-user-id': modelAttributeValue.userId,
                'href': modelAttributeValue.link,
                // Omit `data-mention-uid` in clipboard (copy/cut) to prevent UIDs duplication.
                ...( !options.isClipboardPipeline && { 'data-mention-uid': modelAttributeValue.uid } )
            }, {
                // Make mention attribute to be wrapped by other attribute elements.
                priority: 20,
                // Prevent merging mentions together in clipboard (when `data-mention-uid` is not available).
                id: modelAttributeValue.uid
            } );
        },
        converterPriority: 'high'
    } );
}
```

A full, working demo with all possible customizations and its source code is available [at the end of this section](#ckeditor5/latest/features/mentions.html--fully-customized-mention-feed).

#### Fully customized mention feed

Below is an example of a customized mention feature that:

* Uses a feed of items with additional properties (`id`, `username`, `link`).
* Renders custom item views in the autocomplete panel.
* Converts a mention to an `<a>` element instead of a `<span>`.
* Limits the number of mentions to four elements.

##### Source code

```js
ClassicEditor
    .create( {
        attachTo: document.querySelector( '#snippet-mention-customization' ),
        // ... Other configuration options ...
        plugins: [ Mention, MentionCustomization, /* ... */ ],
        mention: {
            dropdownLimit: 4,
            feeds: [
                {
                    marker: '@',
                    feed: getFeedItems,
                    itemRenderer: customItemRenderer
                }
            ]
        }
    } )
    .then( editor => {
        window.editor = editor;
    } )
    .catch( err => {
        console.error( err.stack );
    } );

function MentionCustomization( editor ) {
    // The upcast converter will convert <a class="mention" href="" data-user-id="">
    // elements to the model 'mention' attribute.
    editor.conversion.for( 'upcast' ).elementToAttribute( {
        view: {
            name: 'a',
            key: 'data-mention',
            classes: 'mention',
            attributes: {
                href: true,
                'data-user-id': true
            }
        },
        model: {
            key: 'mention',
            value: viewItem => {
                // The mention feature expects that the mention attribute value
                // in the model is a plain object with a set of additional attributes.
                // In order to create a proper object, use the toMentionAttribute helper method:
                const mentionAttribute = editor.plugins.get( 'Mention' ).toMentionAttribute( viewItem, {
                    // Add any other properties that you need.
                    link: viewItem.getAttribute( 'href' ),
                    userId: viewItem.getAttribute( 'data-user-id' )
                } );

return mentionAttribute;
            }
        },
        converterPriority: 'high'
    } );

resolve( itemsToDisplay );
        }, 100 );
    } );

// Filtering function - it uses `name` and `username` properties of an item to find a match.
    function isItemMatching( item ) {
        // Make the search case-insensitive.
        const searchString = queryText.toLowerCase();

// Include an item in the search results if name or username includes the current user input.
        return (
            item.name.toLowerCase().includes( searchString ) ||
            item.id.toLowerCase().includes( searchString )
        );
    }
}

function customItemRenderer( item ) {
    const itemElement = document.createElement( 'span' );

itemElement.classList.add( 'custom-item' );
    itemElement.id = `mention-list-item-id-${ item.userId }`;
    itemElement.textContent = `${ item.name } `;

const usernameElement = document.createElement( 'span' );

usernameElement.classList.add( 'custom-item-username' );
    usernameElement.textContent = item.id;

itemElement.appendChild( usernameElement );

return itemElement;
}
```

#### Colors and styles

##### Using CSS variables

The mention feature uses the power of [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables) which are defined in the [default theme style sheet](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-mention/theme/index-content.css). Thanks to that, mention styles can be [easily customized](#ckeditor5/latest/framework/deep-dive/ui/theme-customization.html):

```css
:root {
    /* Make the mention background blue. */
    --ck-content-color-mention-background: hsla(220, 100%, 54%, 0.4);

/* Make the mention text dark grey. */
    --ck-content-color-mention-text: hsl(0, 0%, 15%);
}
```

#### Comments with mentions

It is possible to configure the Mentions feature to work with the [Comments feature](#ckeditor5/latest/features/collaboration/comments/comments.html). Here you can find [detailed guidance on that matter](#ckeditor5/latest/features/collaboration/annotations/annotations-custom-configuration.html--comment-editor-configuration).

### Related features

In addition to enabling mentions, you may want to check the following productivity features:

* [Automatic text transformation](#ckeditor5/latest/features/text-transformation.html) – Lets you automatically turn snippets such as `(tm)` into `™` and `"foo"` into `“foo”`.
* [Autolink](#ckeditor5/latest/features/link.html--autolink-feature) – Turns the links and email addresses typed or pasted into the editor into active URLs.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Lets you quickly apply formatting to the content you are writing.
* [Emoji](#ckeditor5/latest/features/emoji.html) – Lets you quickly insert desired emoji.

### Common API

The [`Mention`](../api/module_mention_mention-Mention.html) plugin registers:

* The `'mention'` command implemented by [`MentionCommand`](../api/module_mention_mentioncommand-MentionCommand.html).

You can insert a mention element by executing the following code:

```js
  editor.execute( 'mention', { marker: '@', mention: '@John' } );
  ```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-mention>.

<a id="ckeditor5/latest/features/merge-fields.html">source file: "ckeditor5/latest/features/merge-fields.html"</a>

## Merge fields

Merge fields are visually distinct placeholder elements, which you may put into the content to mark places, where real values should be inserted. This is perfect for creating document templates and other kinds of personalized content. Merge fields are sometimes also referred to as **merge tokens**, **merge tags**, or simply **tokens** — the terms are equivalent and refer to the same concept.

The feature is highly customizable, offers text, block and image placeholders, a preview mode, and is integrated with our document export and import plugins. Using these tools allows for highly efficient automation of mass document creation (especially in connection with [document export plugins](#ckeditor5/latest/features/merge-fields.html--document-export-plugins)). It can be employed to improve efficiency, shorten the production time, and optimize the workflow.

Below we present the typical use cases for the feature. Choose the setup that fits your needs the best.

### Template editing

The most popular use case is creating templates of documents, e-mails, invoices, and other kinds of personalized content.

The user can insert one of the pre-configured merge field elements in various ways:

* from a toolbar dropdown ,
* from the menu bar, under “Insert” → “Merge field,”
* or by typing the opening bracket (`{{` by default), and choosing one of the merge fields from the list.

To enable this use case, simply configure the merge fields definitions and add a button to the toolbar.

You can learn more about configuring the feature in the Configuration section of this guide.

> **Note**
>
> Presented demos show a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Preview mode

Enhance the template creation experience by defining example preview data sets.

As the user prepares the template, they will be able to switch to a data preview mode. In this mode, merge fields labels are replaced with values taken from the chosen data set. This way, the user will have a better understanding how the actual, final content may look like.

The default initial preview mode is “labels.” When the data for other preview modes is provided, the preview modes can be switched using a toolbar dropdown , or through the menu bar (“View” → “Merge fields preview”).

### Data-only setup

Instead of showing the labels, the editor can be configured to always display the merge fields values, without a way to switch it. The user will insert the merge fields into the content as previously, but they will always see the defined data.

This setup is perfect when you want to use a previously prepared template to create a concrete piece of content, in the context of a specific data set (for example customer data), possibly editing it along the way to further personalize the content.

Using merge fields in this configuration is useful even when you start from scratch! The user avoids typos and has convenient access to correct values, while the created document is always up-to-date, in case the related data set changes.

To enable this use case, use feature configuration to provide a data set, set the initial preview mode and disable other preview modes.

Apart from providing data sets, you can also define default values for the merge fields. The default value is used when the data set is missing a value for a given merge field. Additionally, an error indicator is displayed, to make the user aware of a possible problem. This is useful when you cannot guarantee that your data sets are always complete.

### Installation

> **Note**
>
> The merge fields feature uses the [mentions feature](#ckeditor5/latest/features/mentions.html) under the hood, so ensure you [install it](#ckeditor5/latest/features/mentions.html--installation) too.

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Mention } from 'ckeditor5';
import { MergeFields } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ MergeFields, Mention, /* ... */ ],
		mergeFields: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Mention } = CKEDITOR;
const { MergeFields } = CKEDITOR_PREMIUM_FEATURES;

#### Activating the feature

### Configuration

> **Note**
>
> For more technical details, check the [plugin configuration reference](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html).

To make the most out of the merge fields feature, it has to be properly configured. Some options (such as prefix and suffix or preview modes) have a reasonable default set, but it is essential to at least define the list of the available merge fields.

#### Merge fields definitions

To make the merge fields appear in the editor UI you have to specify them in the [`mergeFields.definitions`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-definitions) property.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mergeFields: {
            definitions: [
                {
                    id: 'guestName',
                    label: 'Guest name', // Optional.
                    defaultValue: 'Guest' // Optional.
                },
                {
                    id: 'guestSpecialOffersBox',
                    label: 'Special offers', // Optional.
                    type: 'block', // Optional.
                    height: 150 // Optional.
                },
                {
                    id: 'companyLogo',
                    label: 'Company logo', // Optional.
                    type: 'image', // Optional.
                    width: 300, // Optional.
                    height: 300 // Optional.
                },
                // More merge field definitions.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The merge field id is the only required value, and it is used in the document data returned by the editor. It may include letters, numbers and `_`, `.`, `-` special characters.

The merge field label is displayed in the editor, if defined. If not, the id is used instead.

[Custom (non-defined) merge fields](#ckeditor5/latest/features/merge-fields.html--custom-merge-fields) may be inserted into the document as well.

Use the [source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) toolbar button in the [presented demos](#ckeditor5/latest/features/merge-fields.html--template-editing) to see an example of the editor output.

##### Merge field type

The feature supports three different types of merge fields:

1. Typical, inline, text merge fields, most often replaced by textual data. For example, a customer name or invoice number.
2. Block merge fields, which represent a bigger piece of content, replaced by an arbitrary HTML structure. For example, a row with box presenting top selling products or an email footer.
3. Image merge fields, which behave just like native images – they can be resized, align to the side etc.

You can define the merge field type using `type` property. Possible values are: `'text'` (default), `'block'` and `'image'`.

```js
ClassicEditor
    .create( {
        mergeFields: {
            definitions: [
                {
                    id: 'guestAddress',
                    type: 'block',
                    label: 'Guest address' // Optional.
                },
                {
                    id: 'companyLogo',
                    type: 'image',
                    label: 'Company logo' // Optional.
                },
                // More merge field definitions.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

In the editor, text merge fields are treated like text. They can be placed only where text is allowed, can be formatted, or be a link. Block merge fields behave like other block-level widgets, and can be placed only where blocks are allowed. Image merge fields behave like images and have identical features, like alternative text, resizing etc., but their `src` attribute is set to the merge field ID.

###### Block merge fields

For block merge fields, it is possible to configure how much vertical space should they occupy. This makes it easier to better visualize how the actual content will look like, or predict the page breaks. Set it using the `height` property (150px by default). Note, that this setting is used only if data for given merge field is not displayed. In a preview mode, the merge field height will depend on the merge field content.

```js
ClassicEditor
    .create( {
        mergeFields: {
            definitions: [
                {
                    id: 'guestAddress',
                    type: 'block',
                    height: '100', // In pixels. Defaults to 150.
                    label: 'Guest address' // Optional.
                },
                // More merge field definitions.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

When it comes to document data, the block merge fields are not wrapped in any HTML structure. It is assumed that the merge field will be replaced by some block-level HTML structure. See example document data below:

```html
    <p>
        See the order details below.
    </p>
    {{orderDetails}}
    <p>
        
    </p>
```

###### Image merge fields

When defining an image merge field in the configuration, you should specify its width and height. Thanks to that it will have a proper aspect ratio and look well in the editor even if you decide to resize it. Set it using the `width` and `height` properties. Note, that this property is used only if data for given merge field is not displayed.

```js
ClassicEditor
    .create( {
        mergeFields: {
            definitions: [
                {
                    id: 'companyLogo',
                    type: 'image',
                    width: 400, // In pixels.
                    height: 200, // In pixels.
                    label: 'Company logo' // Optional.
                },
                // More merge field definitions.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

In the document data, the image merge fields are simply images with the `src` attribute value set to the merge field ID (`<img>` element is wrapped with the `<figure class="image"></figure>` element if it is a block image).

```html
    <p>
        See the inline merge field image here: <img src="{{companyLogoSmall}}" />.
        And a block merge field image below:
    </p>
    <figure class="image"><img src="{{companyLogo}}" /></figure>
    <p>
        
    </p>
```

**Note:** If you want to load the image merge fields to the editor, you should use [`config#initialData` property](../api/module_core_editor_editorconfig-EditorConfig.html#member-initialData) to set the initial content. Otherwise, you may get warnings in the browser console.

##### Grouping merge fields

To better organize the merge fields in the dropdown, you can divide the definitions into groups.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mergeFields: {
            definitions: [
                {
                    groupId: 'guest',
                    groupLabel: 'Guest',
                    definitions: [
                        {
                            id: 'guestName',
                            label: 'Guest name',
                            defaultValue: 'Guest'
                        },
                        {
                            id: 'guestTitle',
                            label: 'Guest title',
                            defaultValue: 'Ms./Mr.'
                        },
                        // More merge field definitions
                        // inside the "Guest" group.
                    ]
                },
                // More merge field groups.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Prefix and suffix

The [`mergeFields.prefix`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-prefix) and [`mergeFields.suffix`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-suffix) (characters combinations used to indicate the start and end of the merge field) can be configured as well. The defined values will be returned in the editor output.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        // Use different kind of brackets for merge fields indicators.
        mergeFields: {
            prefix: '[[',
            suffix: ']]'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The default merge fields brackets are `{{` and `}}`. The following characters are allowed in prefix and suffix: ``'"`!#%:;=@{}~$()*+/?[\]^|``. Additionally, they cannot be longer than 8 characters.

**Note:** The prefix and suffix must be different.

**Note:** The brackets that are used in the stored document data will not automatically update after you change the `prefix` or `suffix` configuration. The change will affect only the newly inserted merge fields. Additionally, old merge fields will not be recognized and will be displayed as plain text. If you need to change brackets configuration, you should also process the document data for all documents created in your application so far.

#### Preview modes

The preview modes change how the merge fields are displayed in the editor area. The editor may display either merge fields labels (or ids), or data values, for preview purposes.

To be able to change preview modes, you will need to define either [merge fields default values](#ckeditor5/latest/features/merge-fields.html--merge-fields-definitions) or [data sets](#ckeditor5/latest/features/merge-fields.html--data-sets) (described later on).

##### Available preview modes

Use [`mergeFields.previewModes`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-previewModes) configuration option to specify which preview modes should be available for the user. It should be specified as any combination of the three possible values:

* The “labels” view (`'$labels'` value) - displays labels (or ids, if not specified).
* The “default values” view (`'$defaultValues'`) - displays default values, if specified.
* All the configured data sets (`'$dataSets'`) - displays values for a chosen data set.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mergeFields: {
            // The user will be allowed only to switch between defined data sets,
            // and the merge fields will always display the data related to one of
            // the defined data sets. If there is only one data set, the user will
            // be forced to see the data from that set and will not be able to switch.
            previewModes: [ '$dataSets' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

**Note:** At least one option must be defined.

**Note:** If only one preview mode is available (meaning, the passed value is `[ '$labels' ]`, or `[ '$defaultValues' ]`, or `[ '$dataSets' ]` with only one data set defined), the “Merge fields preview” button will not be added to the “View” menu.

##### Initial preview mode

The [`mergeFields.initialPreviewMode`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-initialPreviewMode) option specifies which preview mode should be active when the editor is loaded. By default, merge field labels will be shown.

The passed value can be either of: `'$labels'`, `'$defaultValues'`, or one of the IDs of the defined data sets.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mergeFields: {
            // ID of a data set (see an example below).
            initialPreviewMode: '158673'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

**Note:** The initial preview mode must be also specified as one of the [available preview modes](#ckeditor5/latest/features/merge-fields.html--available-preview-modes). Otherwise, an error will be thrown.

#### Data sets

To be able to preview data in place of merge fields, you must define at least one [data set](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-dataSets). A data set should define values according to defined merge fields ids. If some values are not available, the merge fields default value will be used instead (if defined).

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        mergeFields: {
            dataSets: [
                {
                    id: '158673',
                    label: 'David Lee',
                    values: {
                        guestName: 'David Lee',
                        guestTitle: 'Mr.'
                        // Other values in this data set.
                    }
                },
                // More data sets.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Dynamic merge fields values

##### Using callbacks to define values

Some merge field values may require to be dynamically calculated, for example if they are based on other values. It can be achieved by defining a value (either a default one or in a data set) as a callback. The callback is executed when the merge field is inserted into a document, when a preview mode changes, or when document is exported to PDF or Word file.

For example, you can create a simple plugin fetching data when it is initialized:

```js
class ExternalFetcher extends Plugin {
    static get pluginName {
        return 'ExternalFetcher';
    }

mergeFieldsData = {};

init() {
        this._setMergeFieldsData();
    }

async _setMergeFieldsData() {
        const response = await fetch( externalUrl ); // Replace `externalUrl` with your data endpoint.

// Adjust the data here if necessary, e.g. parse JSON or add time stamp.
        // You can expose it in `window` object, public plugin property, or through `localStorage`.
        this.mergeFieldsData = response;

// Refresh the editor so it displays the updated merge fields values.
        this.editor.plugins.get( 'MergeFieldsEditing' ).refreshMergeFields();
    }
}
```

And define the merge field that will look for the data in that plugin property to calculate its default value (the editor instance is passed as the callback parameter):

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [ ExternalFetcher, /* ... */ ],
        mergeFields: {
            definitions: [
                {
                    id: 'bitcoinRate',
                    label: 'Bitcoin rate',
                    defaultValue: editor => {
                        if ( !editor.plugins.has( 'ExternalFetcher' ) ) {
                            return 'Data is not available';
                        }

return editor.plugins.get( 'ExternalFetcher' ).mergeFieldsData.bitcoinRate || 'Fetching data...'
                    }
                }
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

##### Refreshing callbacks values

If the merge field value comes from an external source, you may want to refresh it after it changes, so the editor displays correct values. You can use the [`#refreshMergeFields()`](../api/module_merge-fields_mergefieldsediting-MergeFieldsEditing.html#function-refreshMergeFields) method to trigger recalculation of all the merge fields.

For example, if you want to refresh the values periodically, you can use `setInterval()`. First, create a similar plugin as before, but this time trigger the fetching function periodically to update the data for merge fields:

```js
class IntervalFetcher extends Plugin {
    static get pluginName {
        return 'IntervalFetcher';
    }

mergeFieldsData = {};

init() {
        // Initial data setup.
        this._updateMergeFieldsData();

// Updating data every 5 seconds.
        setInterval( () => this._updateMergeFieldsData(), 5000 )
    }

async _updateMergeFieldsData() {
        const response = await fetch( externalUrl ); // Replace `externalUrl` with your data endpoint.

// Adjust the data here if necessary.
        // You can expose it in `window` object, public plugin property, or through `localStorage`.
        this.mergeFieldsData = response;

// Refresh the editor so it displays the updated merge fields values.
        this.editor.plugins.get( 'MergeFieldsEditing' ).refreshMergeFields();
    }
}
```

The merge field configuration will look the same as before:

```js
ClassicEditor
    .create( {
        plugins: [ IntervalFetcher, /* ... */ ],
        mergeFields: {
            definitions: [
                {
                    id: 'bitcoinRate',
                    label: 'Bitcoin rate',
                    defaultValue: editor => {
                        if ( !editor.plugins.has( 'IntervalFetcher' ) ) {
                            return 'Data is not available';
                        }

editor.plugins.get( 'IntervalFetcher' ).mergeFieldsData.bitcoinRate || 'Fetching data...'
                    }
                },
                // More merge field definitions.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

In the demo below, the merge field containing the current Bitcoin rate will automatically update every 5 seconds.

#### Using HTML tags in merge fields values

It is possible to use HTML code inside merge fields values, both in default values and the data set values.

By default, this behavior is disabled and merge fields values will be treated as plain text (HTML tags will get encoded). To enable HTML merge fields values:

* set [`config.mergeFields.previewHtmlValues`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-previewHtmlValues) configuration flag to `true`,
* provide an HTML sanitization function in [`config.mergeFields.sanitizeHtml`](../api/module_merge-fields_mergefieldsconfig-MergeFieldsConfig.html#member-sanitizeHtml) property.

**It is strongly recommended to provide an HTML sanitization function**.

If you enable HTML merge fields values, the HTML assigned to merge field will be rendered as-is when the user switches to the preview mode. As a result, **the browser will execute any JavaScript code included in this HTML in the context of your website**. This may lead to a security vulnerability, if the merge fields values are provided from an external source that cannot be fully trusted (for example users provide them in a different part of your application).

If you do not provide a sanitization function, a warning will be logged to the console.

You can provide your custom sanitization function or use one of the popular JavaScript libraries, like [`sanitize-html`](https://www.npmjs.com/package/sanitize-html) and [`DOMPurify`](https://www.npmjs.com/package/dompurify).

The default settings of these libraries usually strip all potentially malicious content including `<iframe>`, `<video>`, or similar elements, as well as JavaScript code. You may need to adjust their settings to match your needs.

### Integration

#### Editor data output

Merge fields (tokens) are returned by [`editor.getData()`](../api/module_core_editor_editor-Editor.html#function-getData) as the merge field id enclosed in the specified prefix and suffix, for example: `<p>Dear {{guestTitle}} {{guestName}}</p>`. It is an industry standard format for representing merge fields, which makes it convenient to replace the tokens with actual data.

**Note:** Switching preview mode to display data set values **does not** affect the editor output. In most regular cases, you will always want to save the document data with the merge fields placeholders, not the values. The data replacement should happen in your application logic when needed.

#### Data output with filled-in merge fields

In some cases, it may be useful to get the document data with the merge fields replaced by some actual data.

You may pass the values as an option to `editor.getData()` call:

```js
const data = editor.getData( {
    mergeFieldsData: {
        guestName: 'Joe Doe',
        guestTitle: 'Mr.'
    }
} );
```

And the editor will use these values in place of given merge fields.

If data for a given merge field is not specified, the default data form will be used (`[PREFIX][MERGE_FIELD_ID][SUFFIX]`, for example `{{guestName}}`).

Most likely, you will want to save the data with merge fields replaced by values from the currently previewed data set:

```js
const mergeFieldsEditing = editor.plugins.get( 'MergeFieldsEditing' );

const mergeFieldsData = mergeFieldsEditing.getDataSetValues(
    mergeFieldsEditing.previewMode, true
);

const data = editor.getData( { mergeFieldsData } );
```

#### Custom merge fields

The editor will **convert every piece of text matching the merge field pattern to a merge field element**. This behavior cannot be currently turned off.

Please note, that from the point of view of the editor output, it is indifferent whether the merge field matching text is recognized by the editor, as both defined and custom merge fields are represented the same in the editor output.

Custom merge fields can be added to the editor content by:

* typing the merge field pattern, for example typing `{{myMergeField}}`,
* loading the document data with merge fields that were not specified in the [merge fields definitions](#ckeditor5/latest/features/merge-fields.html--merge-fields-definitions) (including situations where previously existing merge field definition was later removed from the configuration),
* pasting external content that includes text matching the merge field pattern.

Custom merge field will behave like a merge field for which only an id was defined.

#### Document export plugins

You can easily combine merge fields with CKEditor 5’s export features, namely [export to Word](#ckeditor5/latest/features/converters/export-word.html) and [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html). Employing this solution will allow for batch generation of `docx` and `pdf` files and automation (for example automated invitations generation from a client list or personalized envelope labels). Using these output formats will also greatly aid cross-platform interoperability, accessibility and compatibility with various editing solutions, boosting productivity and optimizing the workflow.

Using the [export to Word](#ckeditor5/latest/features/converters/export-word.html) or [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) features for a document with merge fields will produce different results, depending on the current [preview mode](#ckeditor5/latest/features/merge-fields.html--preview-modes). The export features will follow “what you see is what you export” logic.

While export is used in the “labels” preview mode:

* The exported Word document will contain Word document merge fields (it will be exported as a “template” document).
* The exported PDF file will contain merge fields in the default data form `[PREFIX][MERGE_FIELD_ID][SUFFIX]`, for example `{{guestName}}`.
* Image merge fields will not be displayed.

While export is used when default values or data set values are previewed, the merge fields will be replaced by corresponding values, as previewed in the editor. In this case, image merge fields will be preserved.

You can learn more about integrating merge fields with the converter in the dedicated [merge fields integration](#cs/latest/guides/export-to-word/merge-fields.html) guide in the Export to Word documentation.

#### The email feature

Merge fields can also be integrated with the [email editing toolset](#ckeditor5/latest/features/email-editing/email.html). Introducing templates and content placeholders allows for highly efficient and automated mail merge. By combining these features, you can easily create precisely targeted newsletters, mailing lists, personalized email messages and other mail merge solutions. This is a great tool not only for e-commerce but also all other business fields.

#### Import from Word

The [import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) feature will recognize Word document merge fields and will seamlessly convert them to the editor merge fields.

#### Using merge fields with templates

Merge fields can be used together with the template feature. Use the “Insert template” dropdown to add a template into the editor.

> **Note**
>
> For more information about creating and using templates, visit the [templates documentation](#ckeditor5/latest/features/template.html).

### Common API

The [`MergeFields`](../api/module_merge-fields_mergefields-MergeFields.html) plugin registers:

* The `'insertMergeField'` and `'previewMergeFields'` toolbar and menu bar buttons.
* The `'mergeFieldsData'` option for the [`getData()`](../api/module_core_editor_editor-Editor.html#function-getData) method (see the [Data output with filled-in merge fields](#ckeditor5/latest/features/merge-fields.html--data-output-with-filled-in-merge-fields) section for the details).

> **Note**
>
> If you have any further comments or suggestions about this feature, we will be happy if you [contact us](https://ckeditor.com/contact/) and share them!

<a id="ckeditor5/latest/features/mermaid.html">source file: "ckeditor5/latest/features/mermaid.html"</a>

## Creating flowcharts and diagrams using Mermaid

You can create flowcharts and diagrams in CKEditor 5 thanks to the experimental integration with the [Mermaid](https://mermaid.js.org/) library. Mermaid uses a Markdown-inspired syntax to create and dynamically modify flowcharts, Gantt diagrams, pie or quadrant charts, graphs, mindmaps, and more.

> **Warning**
>
> This is an **experimental feature**, and as such it is not recommended for production use. For more information, comments, and feature requests, please refer to the [package repository on GitHub](https://github.com/ckeditor/ckeditor5-mermaid).

### Demo

The example below lets you test creating diagrams and flowcharts right during the content creation – no more screenshots that need to be re-created and re-uploaded each time something needs a change!

### Using Mermaid syntax

Mermaid offers an extensive and flexible syntax allowing users to create a variety of diagrams, charts, and graphs. Find the complete syntax reference on [Mermaid.js](https://mermaid.js.org/intro/). You can also check out more examples online in [Mermaid Live Editor](https://mermaid.live/).

Learn more about Mermaid syntax and usage in a [dedicated article](https://ckeditor.com/blog/basic-overview-of-creating-flowcharts-using-mermaid/) on our company blog.

### Installation

Please note that this plugin is not imported from the main CKEditor 5 file, but from its own package.

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration. Please note, that unlike native CKEditor 5 plugins, this one is imported from its own package. Also, that this import is different than the standard CKEditor 5 plugins import:

```js
import { ClassicEditor } from 'ckeditor5';
import { Mermaid } from '@ckeditor/ckeditor5-mermaid';

import '@ckeditor/ckeditor5-mermaid/index.css';

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
        plugins: [ Mermaid, /* ... */ ],
        toolbar: [ 'mermaid', /* ... */ ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

<a id="ckeditor5/latest/features/minimap.html">source file: "ckeditor5/latest/features/minimap.html"</a>

## Content minimap

The content minimap feature shows a miniature overview of your content. It helps you navigate a document that is too long to fit on the screen.

> **Warning**
>
> This is a **feature preview**, and as such it is not recommended for production use. For more information, comments, and feature requests, please refer to the [issue on GitHub](https://github.com/ckeditor/ckeditor5/issues/10089).

### Demo

Scroll the content, and the minimap in the sidebar will show your current location. To quickly navigate the document, drag the box marking the visible portion of the content. You can also click anywhere on the minimap to move around instantly.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { DecoupledEditor, Minimap } from 'ckeditor5';

DecoupledEditor
	.create( {
		root: {
			element: document.querySelector( '#editor' )
		},
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Minimap, /* ... */ ],
		minimap: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { DecoupledEditor, Minimap } = CKEDITOR;

DecoupledEditor
	.create( {
		root: {
			element: document.querySelector( '#editor' )
		},
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Minimap, /* ... */ ],
		minimap: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

> **Note**
>
> For more technical details, please check the [plugin configuration API](../api/module_minimap_minimapconfig-MinimapConfig.html).

#### Minimap container

The container element is essential for the minimap to render. You should pass the reference to the container element in [`config.minimap.container`](../api/module_minimap_minimapconfig-MinimapConfig.html#member-container). Note that it must have a fixed `width` and `overflow: hidden` when the editor is created:

```js
DecoupledEditor
    .create( {
        root: {
            element: document.querySelector( '#editor' )
        },
        // ... Other configuration options ...
        minimap: {
            container: document.querySelector( '.minimap-container' )
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Content styles and classes

The minimap feature uses `<iframe>` internally. For a proper look and operation, it is essential for the content (clone) inside the `<iframe>` to have exactly the same styles as the main editor document. If the content of your editor inherits styles from parent containers, you may need to pass the class names of these containers in the feature configuration to maintain style parity. See the [detailed classes documentation](../api/module_minimap_minimapconfig-MinimapConfig.html#member-extraClasses) to learn more.

#### Demo configuration

To configure the editor as [presented above](#ckeditor5/latest/features/minimap.html--demo), you can use the following DOM structure:

```html
<div id="document-container">
    <div id="toolbar-container">
        
    </div>
    <div class="minimap-wrapper">
        <div class="editor-container">
            <div id="editor-content">
                
            </div>
        </div>
        <div class="minimap-container">
            
        </div>
    </div>
</div>
```

Employ the following CSS:

```css
.document-container {
    display: flex;
    flex-direction: column;
    align-items: center;
    position: relative;
    flex-grow: 1;
    max-width: 1280px;
    margin: 0 auto;
}

.toolbar-container {
    width: 100%;
}

.minimap-wrapper {
    display: flex;
    flex-direction: row;
    flex-wrap: nowrap;
    max-height: calc( 100vh - 400px );
    width: 100%;
    position: relative;
    top: -1px;
}

.editor-container {
    width: 100%;
    border: 1px solid hsl( 0, 0%, 80% );
    border-right: 0;
    background: hsl( 0, 0%, 95% );
    box-sizing: border-box;
    position: relative;
    overflow: auto;
}

.minimap-container {
    width: 120px;
    flex: 0 0 auto;
    border: 1px solid var(--ck-color-toolbar-border);
    position: relative;
    overflow: hidden;
    max-height: 100%;
}

#editor-content {
    width: calc( 180mm + 2px );
    min-height: calc( 210mm + 2px );
    height: auto;
    padding: 20mm 12mm;
    box-sizing: border-box;
    background: hsl( 0, 0%, 100% );
    border: 1px solid hsl( 0, 0%, 88% );
    box-shadow: 0 2px 8px hsla( 0, 0%, 0%, .08 );
    margin: 40px auto;
    overflow: hidden;
}
```

Finally, the JavaScript to run the editor (learn how to [install](#ckeditor5/latest/features/minimap.html--installation) the feature):

```js
DecoupledEditor
    .create( {
        root: {
            element: document.querySelector( '#editor-content' )
        },
        // ... Other configuration options ...
        minimap: {
            container: document.querySelector( '.minimap-container' ),
        }
    } )
    .then( editor => {
        const toolbarContainer = document.querySelector( '#toolbar-container' );

toolbarContainer.appendChild( editor.ui.view.toolbar.element );
    } );
```

### Related features

Here are some other CKEditor 5 features that you can use to navigate content better:

* [Document outline](#ckeditor5/latest/features/document-outline.html) – Display a navigable list of sections (headings) of the document next to the editor.
* [Table of contents](#ckeditor5/latest/features/table-of-contents.html) – Insert a table of contents into the document with a single click.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-minimap>.

<a id="ckeditor5/latest/features/page-break.html">source file: "ckeditor5/latest/features/page-break.html"</a>

## Page break

The page break feature lets you insert page breaks into your content. This gives you more control over the final structure of a document that is printed or [exported to PDF](#ckeditor5/latest/features/converters/export-pdf.html) or [Word](#ckeditor5/latest/features/converters/export-word.html).

### Demo

Use the insert page break toolbar button to see the feature in action. Use the “Open print preview” button below the editor to preview the content.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, PageBreak } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ PageBreak, /* ... */ ],
		toolbar: [ 'pageBreak', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, PageBreak } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ PageBreak, /* ... */ ],
		toolbar: [ 'pageBreak', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Related features

Here are some useful CKEditor 5 features that you can use together with the page break plugin for an all-around paged editing experience:

* The [pagination feature](#ckeditor5/latest/features/pagination/pagination.html) allows you to see where page breaks would be after the document is [exported to PDF](#ckeditor5/latest/features/converters/export-pdf.html) or [to Word](#ckeditor5/latest/features/converters/export-word.html).
* The [export to Word](#ckeditor5/latest/features/converters/export-word.html) feature will allow you to generate editable, paged `.docx` files out of your editor-created content.
* The [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) feature will allow you to generate portable, paged PDF files out of your editor-created content.

### Common API

The [`PageBreak`](../api/module_page-break_pagebreak-PageBreak.html) plugin registers:

* the UI button component (`'pageBreak'`),
* the `'pageBreak'` command implemented by [`PageBreakCommand`](../api/module_page-break_pagebreakcommand-PageBreakCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Inserts a page break into the selected content.
editor.execute( 'pageBreak' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-page-break>.

<a id="ckeditor5/latest/features/pagination/pagination-integration.html">source file: "ckeditor5/latest/features/pagination/pagination-integration.html"</a>

## Integration with Export to PDF/Word

### Integration with Export to PDF/Word

The [pagination](#ckeditor5/latest/features/pagination/pagination.html) feature works together with [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) and [export to Word](#ckeditor5/latest/features/converters/export-word.html) so users can see where page breaks will fall in the exported document while editing. This guide is a reference for integrating all three, covering the whole process from creating a custom editor to a working configuration.

We strongly advise you to get familiar with all three mentioned plugins’ user guides before reading this guide.

> **Warning**
>
> While it is possible to integrate the pagination feature with the Export to Word feature, this combination is prone to errors. Therefore, pagination in the Export to Word should be based solely on page breaks. We strongly recommend reviewing your document’s structure before exporting and manually applying the page breaks to maintain the preferred structure.

### Using CKEditor 5 Builder

If you do not wish to go through this tutorial, and just want to get a working editor, we recommend using our [Builder](https://ckeditor.com/ckeditor-5/builder/?redirect=docs). It offers a set of editor presets, a catalog of editor features to choose from, and many more useful options.

Choose the Document Editor preset to get the exports and pagination features. CKEditor 5 Builder will provide the necessary HTML, CSS, and JavaScript files for your editor setup.

If you want to get a better understanding of this setup, read the tutorial below.

### Before you start

#### Activating the feature

For the export plugins, you will need a special [token endpoint](https://ckeditor.com/docs/cs/latest/guides/security/token-endpoint.html). To get it, log into your CKEditor Ecosystem Dashboard account and [follow the guide on creating a token URL](https://ckeditor.com/docs/trial/latest/guides/export-to-pdf/quick-start.html#account-dashboard). If the export features are used without this token, all generated documents will contain a watermark at the bottom of every page.

After obtaining all the credentials needed, create a custom editor and configure it.

### Let’s start!

The easiest way to get started is to grab the starter project using the commands below.

```bash
npx -y degit ckeditor/ckeditor5-tutorials-examples/pagination-and-exports/starter-files pagination-and-exports
cd pagination-and-exports

npm install
npm run dev
```

This will create a new directory called `pagination-and-exports` with the necessary files. The `npm install` command will install all the dependencies, and `npm run dev` will start the development server.

The editor with some basic plugins is created in the `main.js` file.

Open the URL displayed in your terminal. If everything goes well, you will see an initial text on the screen and errors in the console. It is expected, and we will fix it in the following steps.

### Configuration

#### Adding licenses

You need to provide a license key for the pagination feature as well as the Cloud Services configuration for the export plugins (which you obtained in [step one](#ckeditor5/latest/features/pagination/pagination-integration.html--activating-the-feature)).

> **Note**
>
> This guide assumes that you do not use any other plugins that need a `cloudServices` configuration. If you used, for example, real-time collaboration, you would have to provide `webSocketUrl`.

Go to the `src/main.js`, and fill the required configuration.

```js
// More editor's configuration.
// ...
cloudServices: {
    // Provide a correct value here. You can find it in the CKEditor Ecosystem Dashboard:
    // https://dashboard.ckeditor.com/login
    tokenUrl: 'https://example.com/cs-token-endpoint'
},
licenseKey: '<YOUR_LICENSE_KEY>',
// More editor's configuration.
// ...
```

After adding those values, the editor should allow writing in it, but the browser’s console will inform us about the missing configuration.

#### Adding plugins’ configuration

The pagination configuration has to be in sync with the configuration of the export plugins. All three configurations need to have the same margin values and page format set. This is due to the handling of default editor styles. In this guide, you will use the A4 format, but you can use other paper sizes as well.

Open again the `src/main.js`, and add additional configuration:

```js
// More editor's configuration.
// ...
pagination: {
    // Page width and height reflect the A4 format.
    pageWidth: '21cm',
    pageHeight: '29.7cm',

pageMargins: {
        top: '20mm',
        bottom: '20mm',
        right: '12mm',
        left: '12mm'
    }
},
exportPdf: {
    fileName: 'my-sample-file.pdf',
    converterOptions: {
        document: {
            size: 'A4',
            orientation: 'portrait',
            margins: {
                top: '20mm',
                bottom: '20mm',
                right: '12mm',
                left: '12mm'
            }
        }
    }
},
exportWord: {
    fileName: 'my-sample-file.docx',
    converterOptions: {
       document: {
            size: 'A4',
            margin: {
                top: '20mm',
                bottom: '20mm',
                right: '12mm',
                left: '12mm'
            }
        }
    }
},
```

After adding the configuration, the exports work but we still need to work on the styles.

#### Styling the editor

When using the [decoupled editor (document editor)](../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html), you need to make sure that the editor styles match precisely the configuration options that you provided to the feature and the [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html--configuration) or [export to Word](#ckeditor5/latest/features/converters/export-word.html--configuration) features. Additionally, you just want the editor to look good.

To address this issue, open the `style.css` file, and add the following declarations:

```css
/* Editor styles */
.document-container {
    width: 1000px;
    margin: auto;
    background-color: rgb(238, 238, 238);
}
.editor-container {
    border: 1px solid hsl( 0, 0%, 80% );
    max-height: calc( 100vh - 100px );
    overflow: auto;
}
.ck.ck-editor__editable_inline {
    /*
        A4 size.
        Expand the width by 2px because of the border and "box-sizing: border-box".
    */
    width: calc( 210mm + 2px );
    height: auto;
    padding: 20mm 12mm;
    box-sizing: border-box;
    border: 1px solid hsl( 0, 0%, 88% );
    background: hsl( 0, 0%, 100% );
    box-shadow: 0 2px 8px hsla( 0, 0%, 0%, .08 );
    margin: 40px auto;
}
```

Our `main.js` already imports `style.js`, so after saving the CSS file, you should see a nicely styled editor in your browser.

#### Styling the content

Try to add a block quote, and export the content to a PDF. It works, but the content in the file looks different.

Our `main.js` imports the styles of CKEditor 5. Apart from styling the editor’s editable element, they also have styles that control how the content inside the editor looks. When using the pagination feature together with export to PDF and export to Word, you need to make sure that these styles are sent to the converters. This means they will be actually applied to the content when generating the document. They should also not create a discrepancy between the pagination lines in the editor and page breaks in the generated document.

```js
// More editor's configuration.
// ...
exportPdf: {
    stylesheets: [
        // We will add links to stylesheets here.
    ],
    // More configuration of the Export to PDF.
    // ...
},
exportWord: {
    stylesheets: [
        // We will add links to stylesheets here.
    ],
    // More configuration of the export to Word.
    // ...
}
// More editor's configuration.
// ...
```

Before we add a proper configuration, let’s add a few new declarations that are specific to the pagination plugin, and also adjust the line height. Add them to `style.css`:

```css
/* Content styles */
@media print {
    body {
        margin: 0 !important;
    }
}
.ck-content * {
    line-height: 1.5;
}
.ck-content .table thead {
    display: table-row-group;
}
.ck-content .table tr {
    break-inside: avoid;
    break-after: auto;
}
```

There are several strategies how to pass style sheets in the configuration. We could add relative paths or links to them. Let’s use the simplest strategy in this tutorial, but keep in mind that your bundler or framework may offer a different solutions.

Create a `public` folder in the root of the project, and copy all the style sheets that we use there.

```sh
mkdir public
cp node_modules/ckeditor5/dist/index.css public/ckeditor5.css
cp node_modules/ckeditor5-premium-features/dist/index.css public/ckeditor5-premium-features.css
cp src/style.css public
```

Then add the following configuration to the exports:

```js
// More editor's configuration.
// ...
exportPdf: {
    stylesheets: [
        './ckeditor5.css',
        './ckeditor5-premium-features.css',
        './style.css'
    ],
    // More configuration of the Export to PDF.
    // ...
},
exportWord: {
    stylesheets: [
        './ckeditor5.css',
        './ckeditor5-premium-features.css',
        './style.css'
    ],
    // More configuration of the export to Word.
    // ...
}
// More editor's configuration.
// ...
```

You can read more about sending styles to the server in the [troubleshooting section](#ckeditor5/latest/features/pagination/pagination.html--troubleshooting) of Pagination overview.

This is it, we have a working pagination integration with Export to Word and Export to PDF!

#### Demo

The editor below has the [Pagination](#ckeditor5/latest/features/pagination/pagination.html), [Export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) and [Export to Word](#ckeditor5/latest/features/converters/export-word.html) features enabled. Keep in mind that this demo may slightly differ from the editor you have just built. This is because of fonts and styles specific to this documentation page.

> **Note**
>
> Please note, that, as of now, the Pagination feature demo does not work properly in the Firefox and Safari browsers. Refer to the [browser compatibility section](#ckeditor5/latest/features/pagination/pagination.html--browser-compatibility) for further details.

### Final solution

There is a repository available with the [final project](https://github.com/ckeditor/ckeditor5-tutorials-examples/tree/main/pagination-and-exports/final-project) that you can download and play with. Remember to fill in the required license and `tokenUrl` information.

#### Troubleshooting

Please keep in mind that each of the plugins used in this guide has some known issues – this could be partial or missing support for other CKEditor 5 plugins, partial browser support, some known bugs, etc. When combined, these sometimes might cause problems for certain more complicated use cases. We strongly advise you to go through all _Known issues_ sections in the features’ respective documentation pages and make sure that you understand all their limitations.

If you would like to report a bug or propose enhancements for these plugins, we encourage you to use the [CKEditor 5 issue tracker](https://github.com/ckeditor/ckeditor5/issues). If you would like to use CKEditor 5 as a part of a commercial solution or have a request for custom development, feel free to contact us through our [support channel](https://ckeditor.com/contact/) - our team will make sure to answer all your questions.

<a id="ckeditor5/latest/features/pagination/pagination.html">source file: "ckeditor5/latest/features/pagination/pagination.html"</a>

## Pagination overview

The pagination feature is a dedicated [decoupled editor](#ckeditor5/latest/examples/builds/document-editor.html) plugin that lets you see where page breaks will be after the document is [exported to PDF](#ckeditor5/latest/features/converters/export-pdf.html). The feature respects page breaks inserted by the user with the [page break feature](#ckeditor5/latest/features/page-break.html).

### Demo

The demo below lets you see page break lines. They show you the location of page breaks in an exported PDF or DOCX file. Use the pagination feature toolbar buttons to navigate back and forth between pages.

> **Note**
>
> As of now, the Pagination feature demo does not work properly in the Firefox and Safari browsers. Refer to the [browser compatibility section](#ckeditor5/latest/features/pagination/pagination.html--browser-compatibility) for further details.

### Additional feature information

In addition to page breaks, the pagination feature shows you page numbers and the total number of pages in the document. The feature also introduces a dedicated toolbar that lets you easily go to the next or previous page of the document or jump straight to a particular page.

The pagination feature is complementary to the [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) and [export to Word](#ckeditor5/latest/features/converters/export-word.html) features of CKEditor 5, ensuring the proper output every time. Combined with other CKEditor 5 features, these plugins allow for advanced editing and document creation implementations. This kind of practical application is shown in the [How to create ready-to-print documents with CKEditor 5 pagination feature](https://ckeditor.com/blog/How-to-create-ready-to-print-documents-with-page-structure-in-WYSIWYG-editor---CKEditor-5-pagination-feature/) blog post.

The pagination plugin cannot be used to reflect the original page division in content [imported from Word](#ckeditor5/latest/features/converters/import-word/import-word.html). This is an export-only feature.

> **Note**
>
> This feature is dedicated for use with the [decoupled editor](#ckeditor5/latest/examples/builds/document-editor.html) type only. If used with different types of editors, it may result in certain issues, for example, incorrect rendering of the toolbar. If you need support for the pagination feature in other editor types, feel free to [contact us](https://ckeditor.com/contact/) and inquire.

### Before you start

For the export plugins, you will need a special [token endpoint](https://ckeditor.com/docs/cs/latest/guides/security/token-endpoint.html). To get it, log into your CKEditor Ecosystem Dashboard account and [follow the guide on creating a token URL](https://ckeditor.com/docs/trial/latest/guides/export-to-pdf/quick-start.html#account-dashboard). When export features are used without this token, all generated documents will contain a watermark at the bottom of every page.

After obtaining all the credentials needed, create a custom editor and configure it.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { DecoupledEditor } from 'ckeditor5';
import { Pagination } from 'ckeditor5-premium-features';

DecoupledEditor
	.create( {
		root: {
			element: document.querySelector( '#editor' )
		},
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Pagination, /* ... */ ],
		toolbar: [
			'previousPage',
			'nextPage',
			'pageNavigation',
			'|',
			// More toolbar items.
		],
		pagination: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { DecoupledEditor } = CKEDITOR;
const { Pagination } = CKEDITOR_PREMIUM_FEATURES;

### Configuration

> **Note**
>
> For more technical details, check the [plugin configuration API](../../api/module_pagination_pagination-PaginationConfig.html).

The configuration is crucial for allowing the pagination feature to measure where the page breaks would be. These configuration values must match the [export to PDF](../../api/module_export-pdf_exportpdf-ExportPdfConfig.html) or the [export to Word](../../api/module_export-word_exportword-ExportWordConfig.html) configuration. The structure of both configurations is different.

#### Example configuration

```js
{
    pagination: {
        // A4
        pageWidth: '21cm',
        pageHeight: '29.7cm',

pageMargins: {
            top: '20mm',
            bottom: '20mm',
            left: '12mm',
            right: '12mm'
        }
    }
}
```

#### Plugin options

The plugin options tell the pagination feature what the format of the page and the page margins are. There is also an additional configuration option that allows you to enable pagination in all browsers, including the officially unsupported ones.

* **[`config.pagination.pageWidth`](../../api/module_pagination_pagination-PaginationConfig.html#member-pageWidth)**, **[`config.pagination.pageHeight`](../../api/module_pagination_pagination-PaginationConfig.html#member-pageHeight)**

The page dimensions.

* **[`config.pagination.pageMargins`](../../api/module_pagination_pagination-PaginationConfig.html#member-pageMargins)**

The page margins.

* **[`config.pagination.enableOnUnsupportedBrowsers`](../../api/module_pagination_pagination-PaginationConfig.html#member-enableOnUnsupportedBrowsers)**

The pagination feature is by default enabled only in browsers that are using the Blink engine (Chrome, Chromium, newer Edge, newer Opera). This behavior can be modified by setting this configuration option to `true`.

#### Pagination toolbar

CKEditor 5 pagination feature provides a few toolbar items that can be added to your editor toolbar configuration. They are all optional – the pagination feature does not need them to show you the document page division.

The pagination toolbar buttons make the document navigation easier, though:

* The `'nextPage'` button allows you to go to the next document page.
* The `'previousPage'` button allows you to go to the previous document page.
* The `'pageNavigation'` toolbar item shows you the total page count and allows you to go straight to a particular page number.

```js
DecoupledEditor
    .create( {
        root: {
            element: document.querySelector( '#editor' ),
        },
        // ... Other configuration options ...
        toolbar: [
            'previousPage',
            'nextPage',
            'pageNavigation',
            '|',
            // More toolbar items.
            // ...
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Troubleshooting

The pagination feature computes where the page breaks would be in the local browser, but the [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) or [export to Word](#ckeditor5/latest/features/converters/export-word.html) features are handled by dedicated HTML to PDF and DOCX converter services of CKEditor Cloud Services. Because of this, it is important to match the content styles with those sent to the backend service. Even a minor difference in the margin, padding, font size, etc. setting may lead to inconsistencies between the content in the editor and the generated PDF or Word file. Because of this, the local browser could calculate page breaks in incorrect places.

#### Editor content styling

For example, if you are using [decoupled editor (document editor)](../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html), you need to make sure that the editor styles match precisely the configuration options that you provided to the feature and to the [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) or [export to Word](#ckeditor5/latest/features/converters/export-word.html) features.

```css
.ck.ck-editor__editable_inline {
    /* A4 size */
    width: calc( 210mm + 2px ); /* Expand the width by 2px because of the border and "box-sizing: border-box". */
    height: auto;
    padding: 20mm 12mm;
    box-sizing: border-box;

border: 1px solid hsl( 0, 0%, 88% );
    background: hsl( 0, 0%, 100% );
    box-shadow: 0 2px 8px hsla( 0, 0%, 0%, .08 );
    margin: 40px auto;
    overflow: hidden;
}
```

Note the calculation of the width of the element.

#### The style sheets sent to the service

While preparing the style sheets to send to the export to PDF or export to Word service, you should:

* Make sure that the styling of all elements is exact.

* Reset the default page margins:

```css
  @media print {
      body {
          margin: 0 !important;
      }
  }
  ```

* Override the default browser behavior of breaking the tables:

```css
  .ck-content .table thead {
      display: table-row-group;
  }
  .ck-content .table tr {
      break-inside: avoid;
      break-after: auto;
  }
  ```

#### CKEditor 5 initialization

If you want to create the editor detached and attach it to the DOM tree later, remember to call `editor.ui.update();` after the editor is attached.

```js
DecoupledEditor
    .create( {
        ...config,
        root: {
            initialData
        }
    } )
    .then( editor => {
        const editorContainer = document.querySelector( '#editor-container' );
        const toolbarContainer = document.querySelector( '#toolbar-container' );

toolbarContainer.appendChild( editor.ui.view.toolbar.element );
        editorContainer.appendChild( editor.ui.view.editable.element );

editor.ui.update();
    } );
```

### Known issues

#### Table captions causing inconsistent pagination

Table captions may occasionally break pagination calculations when a page break falls inside a table that has a caption. This is a known bug in browsers and, until it is fixed, you must use the workaround — use a native `table`/`caption` element instead of `figure`/`figcaption`. Enable the workaround by setting:

```js
editor.config.set( 'table.tableCaption.useCaptionElement', true );
```

#### Automatic page breaks in Export to Word

Browser engines and Microsoft Word differ significantly. Because of that, the automatic prediction of page breaks in [Export to Word](#ckeditor5/latest/features/converters/export-word.html--how-it-works) is problematic and error-prone. Therefore, pagination in the Export to Word should be based solely on [page breaks](#ckeditor5/latest/features/page-break.html). We strongly recommend reviewing your document’s structure before exporting and manually applying the page breaks to maintain the preferred structure. You can also use [Export to PDF](#ckeditor5/latest/features/converters/export-pdf.html), where predicting page breaks is more straightforward and works more consistently.

#### Unsupported plugins

Not all CKEditor 5 plugins and features are compatible with pagination and export to PDF or Word at the moment. Refer to the documentation of the export features to learn more:

* [Export to PDF – known issues](#ckeditor5/latest/features/converters/export-pdf.html--known-issues)
* [Export to Word – known issues](#ckeditor5/latest/features/converters/export-word.html--known-issues)
* [Document title](#ckeditor5/latest/features/title.html) – cause conflicts

#### Browser compatibility

Currently, the pagination feature works best with the following web browsers:

* Chrome
* Chromium
* latest Edge
* latest Opera

The pagination plugin does not work in Firefox yet. There are also some glitches in Safari. To prevent users from seeing potentially invalid pagination, the plugin disables itself after detecting these unsupported browsers.

If you want to enable the pagination feature in an unsupported browser, you can set the [`config.pagination.enableOnUnsupportedBrowsers`](../../api/module_pagination_pagination-PaginationConfig.html#member-enableOnUnsupportedBrowsers) configuration option to `true` or enable it at runtime by calling `editor.plugins.get( 'Pagination' ).clearForceDisabled( 'browserCheck' )`.

### Related features

Here are some useful CKEditor 5 features that you can use together with the pagination plugin for an all-around paged editing experience:

* The [page break feature](#ckeditor5/latest/features/page-break.html) allows you to manually insert a page break into your document.
* The [export to Word](#ckeditor5/latest/features/converters/export-word.html) feature will allow you to generate editable `.docx` files out of your editor-created content.
* The [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) feature will allow you to generate portable PDF files out of your editor-created content.

### Common API

The [`Pagination`](../../api/module_pagination_pagination-Pagination.html) plugin registers:

* The `'pageNavigation'` toolbar item.

* The `'nextPage'` and `'previousPage'` buttons.

* The `'pagination'` option for the [`getData()`](../../api/module_core_editor_editor-Editor.html#function-getData) method:

```js
  const data = editor.getData( { pagination: true } );
  ```

This option enables downcast conversion of the calculated page breaks.

* At the beginning of the element:

```html
    <p style="page-break-before:always;" data-pagination-page="4"> ... </p>
    ```

* Inside the text:

```html
    <p> ... <span style="page-break-before:always;" data-pagination-page="8"></span> ... </p>
    ```

> **Note**
>
> If you have any further comments or suggestions about this feature, we will be happy if you [contact us](https://ckeditor.com/contact/) and share them!

<a id="ckeditor5/latest/features/pasting/paste-from-google-docs.html">source file: "ckeditor5/latest/features/pasting/paste-from-google-docs.html"</a>

## Pasting content from Google Docs

The paste from Google Docs feature lets you paste content from Google Docs and preserve its original structure and formatting.

> **Note**
>
> The Paste from Office plugin only preserves content formatting and structures that are included in your CKEditor 5 setup. This means that you may need to add missing features such as font color or text alignment. Read more in the [Automatic content filtering](#ckeditor5/latest/features/pasting/paste-from-google-docs.html--automatic-content-filtering) section below.

### Demo

To test pasting from Google Docs, open the [sample Google Docs document](https://docs.google.com/document/d/1pjLA5P0SKVtimJSiCgtMjHrmZWCB3TqqgpFdRoCS9gU/edit). Then copy its content and paste it into the editor below.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

Thanks to the paste from Google Docs feature, you can copy and paste a Google Docs document into CKEditor 5 and maintain basic text styling, heading levels, links, lists, tables, and images.

When the plugin is enabled, it automatically detects Google Docs content and transforms its structure and formatting to clean HTML which is then transformed into semantic content by the editor.

The [`PasteFromOffice`](../../api/module_paste-from-office_pastefromoffice-PasteFromOffice.html) plugin also allows you to paste content from Microsoft Word. See the [pasting content from Microsoft Office](#ckeditor5/latest/features/pasting/paste-from-office.html) guide to learn more.

### Automatic content filtering

With CKEditor 5 you do not need to worry about pasting messy content from Google Docs (or any other possible sources). Thanks to the CKEditor 5 [custom data model](#ckeditor5/latest/framework/index.html), only content that is specifically handled by the loaded rich-text editor features will be preserved.

This means that if you did not enable, for instance, [font family and font size](#ckeditor5/latest/features/font.html) features, this sort of formatting will be automatically stripped off when you paste content from Google Docs and other sources (like other websites).

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, PasteFromOffice } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ PasteFromOffice, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, PasteFromOffice } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ PasteFromOffice, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Support for other applications

At the current stage, the focus of the `@ckeditor/ckeditor5-paste-from-office` package is on supporting content that comes from [Microsoft Word](#ckeditor5/latest/features/pasting/paste-from-office.html) and Google Docs. However, it does not mean that pasting from other similar applications (such as Microsoft Excel) is not supported.

By default, CKEditor 5 will support pasting rich-text content from these applications, however, some styles and formatting may be lost, depending on the source application. Also, other minor bugs may appear.

You can find more information regarding compatibility with other applications in [this ticket](https://github.com/ckeditor/ckeditor5/issues/1184#issuecomment-409828069).

If you think that support for any of the applications needs improvements, add 👍 and comments in the following issues:

* [Support pasting from Excel](https://github.com/ckeditor/ckeditor5/issues/2513).
* [Support pasting from Libre Office](https://github.com/ckeditor/ckeditor5/issues/2520).
* [Support pasting from Pages](https://github.com/ckeditor/ckeditor5/issues/2527).

Feel free to open a [new feature request](https://github.com/ckeditor/ckeditor5/issues/new/choose) for other similar applications, too!

### Related features

CKEditor 5 supports a wider range of paste features, including:

* [Paste plain text](#ckeditor5/latest/features/pasting/paste-plain-text.html) – Paste text without formatting that will inherit the style of the content it was pasted into.
* [Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) – Paste content from Microsoft Word and keep the original structure and formatting.
* [Enhanced paste from Office](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html) – Enhanced paste from Office is a premium version of the plugin that offers far greater capabilities.
* [Import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) – Convert Word files directly into HTML content.
* [Paste Markdown](#ckeditor5/latest/features/pasting/paste-markdown.html) – Paste Markdown-formatted content straight into the editor.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-paste-from-office>.

<a id="ckeditor5/latest/features/pasting/paste-from-office-enhanced.html">source file: "ckeditor5/latest/features/pasting/paste-from-office-enhanced.html"</a>

## Enhanced paste from Office

The enhanced paste from Office feature lets you paste content from Microsoft Word and Excel while retaining more of the original formatting than the [standard paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) feature.

There is also the [basic, open-source Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) feature. You can read more about the differences between these two [further in this guide](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--content-formatting-support).

### Demo

Use these sample documents to test pasting from Microsoft Office:

* [Sample Word document](../../assets/PasteFromOfficeEnhancedWordSample.docx)
* [Sample Excel spreadsheet](../../assets/PasteFromOfficeEnhancedExcelSample.xlsx)

To test pasting from Office, download the sample documents and open them in Microsoft Office applications. Then, copy the content and paste it into the editor below.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Content formatting support

Enhanced paste from Office retains rich content pasted from Microsoft Office applications. See below the full table of supported styles and formatting.

#### Microsoft Word

The name of each group in the table corresponds to the category in Word’s “Modify style” user interface. If a specific formatting is supported natively (without using the [General HTML Support](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--installation) feature), a plugin name responsible for the formatting is provided in parentheses.

> **Warning**
>
> The basic **paste from Office** feature only supports inline formatting, introduced via the Microsoft Word user interface. It does not support Word styles.
>
> The **enhanced paste from Office** feature supports both.

| Group                       | Formatting                             | Paste from Office                                                                                      | Premium feature Enhanced paste from Office                                                                                    |                                                                                                                           |
| --------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
|                             |                                        |                                                                                                        | Native support                                                                                                                | With [General HTML Support](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--installation)             |
| Font                        | Font family                            | ✅ Yes                                                                                                  | ✅ Yes (`FontFamily`)                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Font style (weight, italic)            | ✅ Yes                                                                                                  | ✅ Yes (`Bold`, `Italic`)                                                                                                      | ✅ Yes                                                                                                                     |
|                             | Font size                              | ✅ Yes                                                                                                  | ✅ Yes (`FontSize`)                                                                                                            | ✅ Yes                                                                                                                     |
|                             | Text color                             | ✅ Yes                                                                                                  | ✅ Yes (`FontColor`)                                                                                                           | ✅ Yes                                                                                                                     |
|                             | Underline                              | ✅ Yes                                                                                                  | ✅ Yes (`Underline`) [\[1\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-underline-color)    | ✅ Yes [\[1\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-underline-color)              |
|                             | Advanced underline                     | ❌ No                                                                                                   | ✅ Yes (`Underline`) [\[2\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-underline-advanced) | ✅ Yes [\[2\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-underline-advanced)           |
|                             | Emphasis mark                          | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Strikethrough                          | ✅ Yes                                                                                                  | ✅ Yes (`Strikethrough`)                                                                                                       | ✅ Yes                                                                                                                     |
|                             | Double strikethrough                   | ❌ No                                                                                                   | ✅ Yes (`Strikethrough`) [\[3\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-strike)         | ✅ Yes (`Strikethrough`) [\[3\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-font-strike)     |
|                             | Superscript                            | ✅ Yes                                                                                                  | ✅ Yes (`Superscript`)                                                                                                         | ✅ Yes                                                                                                                     |
|                             | Subscript                              | ✅ Yes                                                                                                  | ✅ Yes (`Subscript`)                                                                                                           | ✅ Yes                                                                                                                     |
|                             | Small caps                             | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | All caps                               | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Hidden                                 | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Character scale                        | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
|                             | Character spacings                     | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Advanced typography                    | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
| Paragraph                   | Alignment                              | ✅ Yes                                                                                                  | ✅ Yes (`Alignment`)                                                                                                           | ✅ Yes                                                                                                                     |
|                             | Indentation left                       | ✅ Yes                                                                                                  | ✅ Yes (`IndentBlock`)                                                                                                         | ✅ Yes                                                                                                                     |
|                             | Indentation right                      | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Spacing before                         | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Spacing after                          | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Line spacing                           | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Line spacing at                        | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | No space between same–style paragraphs | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
| Tabs                        | Alignment                              | ❌ No                                                                                                   | ✅ Yes [\[4\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-tabs)                                  | ✅ Yes [\[4\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-tabs)                              |
|                             | Leader                                 | ❌ No                                                                                                   | ✅ Yes [\[4\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-tabs)                                  | ✅ Yes [\[4\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-tabs)                              |
| Borders and shading         | Style                                  | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes [\[5\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-border-style)                      |
|                             | Color                                  | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Width                                  | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Side                                   | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | From text                              | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Fill                                   | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
|                             | Pattern style                          | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes [\[6\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-borders-and-shading-pattern-style) |
|                             | Pattern color                          | ❌ No                                                                                                   | ❌ No                                                                                                                          | ✅ Yes                                                                                                                     |
| Language                    | Language                               | ❌ No                                                                                                   | ✅ Yes (`TextPartLanguage`)                                                                                                    | ✅ Yes                                                                                                                     |
|                             | Do not check spelling                  | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
| Frame                       | Text wrapping                          | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
|                             | Size                                   | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
|                             | Horizontal                             | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
|                             | Vertical                               | ❌ No                                                                                                   | ❌ No                                                                                                                          | ❌ No                                                                                                                      |
| Bullet points and Numbering | General                                | ✅ Yes (`List`) [\[7\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-lists) | ✅ Yes (`List`) [\[7\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-lists)                        | ✅ Yes [\[7\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--word-lists)                             |

> **Note**
>
> * \[1] Underline color is ignored.
> * \[2] Pasted as simple underline
> * \[3] Pasted as single strikethrough.
> * \[4] Tabs are non-interactive.
> * \[5] Not all Word border styles have CSS counterparts.
> * \[6] The overall density is preserved but the pattern details are lost.
> * \[7] Partial support.

#### Microsoft Excel

The name of each group in the table corresponds to the category in the Excel “Format cells” user interface. If a specific formatting is supported natively (without using the [General HTML Support](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--installation) feature), a plugin name responsible for the formatting is provided in parentheses.

| Group     | Formatting                       | Paste from Office | Premium feature Enhanced paste from Office                                                                                          |                                                                                                               |
| --------- | -------------------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
|           |                                  |                   | Native support                                                                                                                      | With [General HTML Support](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--installation) |
| Alignment | Horizontal alignment             | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Vertical alignment               | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Indent                           | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Orientation (angle)              | ❌ No              | ❌ No                                                                                                                                | ❌ No                                                                                                          |
| Font      | Family                           | ❌ No              | ✅ Yes (`FontFamily`)                                                                                                                | ✅ Yes                                                                                                         |
|           | Style                            | ❌ No              | ✅ Yes (`Bold`, `Italic`)                                                                                                            | ✅ Yes                                                                                                         |
|           | Size                             | ❌ No              | ✅ Yes (`FontSize`)                                                                                                                  | ✅ Yes                                                                                                         |
|           | Underline                        | ❌ No              | ✅ Yes (`Underline`)                                                                                                                 | ✅ Yes                                                                                                         |
|           | Advanced underline (like double) | ❌ No              | ❌ No                                                                                                                                | ❌ No                                                                                                          |
|           | Color                            | ❌ No              | ✅ Yes (`FontColor`)                                                                                                                 | ✅ Yes                                                                                                         |
|           | Strikethrough                    | ❌ No              | ✅ Yes (`Strikethrough`)                                                                                                             | ✅ Yes                                                                                                         |
|           | Superscript                      | ❌ No              | ✅ Yes (`Superscript`)                                                                                                               | ✅ Yes                                                                                                         |
|           | Subscript                        | ❌ No              | ✅ Yes (`Subscript`)                                                                                                                 | ✅ Yes                                                                                                         |
| Border    | Border color                     | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Border width                     | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Border style                     | ❌ No              | ✅ Yes [\[1\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--excel-border-style)                               | ✅ Yes [\[1\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--excel-border-style)         |
|           | Borders across cell (diagonal)   | ❌ No              | ❌ No                                                                                                                                | ❌ No                                                                                                          |
| Fill      | Background                       | ❌ No              | ✅ Yes (`TableCellProperties`)                                                                                                       | ✅ Yes                                                                                                         |
|           | Pattern color                    | ❌ No              | ✅ Yes (`TableCellProperties`) [\[2\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--excel-fill-pattern-color) | ✅ Yes [\[2\]](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--excel-fill-pattern-color)   |
|           | Pattern style                    | ❌ No              | ❌ No                                                                                                                                | ❌ No                                                                                                          |

> **Note**
>
> * \[1] Not all Excel border styles have CSS counterparts.
> * \[2] It overrides the cell background.

### Support for other office applications

At the current stage, the focus of `@ckeditor/ckeditor5-paste-from-office` and `@ckeditor/ckeditor5-paste-from-office-enhanced` packages is on supporting content that comes from Microsoft Word, Microsoft Excel, and [Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html). However, it does not mean that pasting from other similar applications (such as Microsoft PowerPoint) is not supported.

You can find more information about compatibility with other applications in [this ticket](https://github.com/ckeditor/ckeditor5/issues/1184#issuecomment-409828069).

If you think that support for any of the applications needs improvements, add 👍 and comments in the following issues:

* [Support pasting from Libre Office](https://github.com/ckeditor/ckeditor5/issues/2520).
* [Support pasting from Pages](https://github.com/ckeditor/ckeditor5/issues/2527).

Feel free to open a [new feature request](https://github.com/ckeditor/ckeditor5/issues/new/choose) for other similar applications, too!

### Installation

To add the enhanced paste from Office feature to your editor, you need to install [basic, open-source paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html), enhanced paste from Office and [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) plugins. The `GeneralHtmlSupport` plugin is optional but recommended for optimal retention and accuracy of pasted styles. [Learn more](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--configuration).

We highly recommend you also add other editor packages to get as much native support for pasted content as possible. You can learn more about editor features that work out–of–the–box with content pasted from Microsoft Office in a [dedicated section](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--content-formatting-support). To install the recommended packages, execute the following command:

Add the `PasteFromOffice`, `PasteFromOfficeEnhanced`, and `GeneralHtmlSupport` plugins to your plugin list as well as other editor features that support content pasted from Microsoft Office (`Bold`, `Italic`, `FontColor`, `Indent`, etc.):

**NPM**

```js
import {
	ClassicEditor,
	PasteFromOffice,
	GeneralHtmlSupport,
	Alignment,
	Bold,
	Italic,
	Underline,
	Strikethrough,
	Subscript,
	Superscript,
	FontColor,
	FontBackgroundColor,
	FontFamily,
	FontSize,
	Indent,
	Table,
	TableProperties,
	TableCellProperties,
	TextPartLanguage
} from 'ckeditor5';
import { PasteFromOfficeEnhanced } from 'ckeditor5-premium-features';

// Other imports...

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			// Load the open-source feature.
			PasteFromOffice,

// Load the enhanced feature.
			PasteFromOfficeEnhanced,

// Load the recommended General HTML Support feature.
			GeneralHtmlSupport,

// Load other recommended editor features.
			Alignment, Bold, Italic, Underline, Strikethrough, Subscript, Superscript,
			FontColor, FontBackgroundColor, FontFamily, FontSize, Indent,
			Table, TableProperties, TableCellProperties,
			TextPartLanguage,

/* ... */
		],

// See the "Configuration" section below to learn how to configure
		// the editor for the best performance.
		// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const {
	ClassicEditor,
	PasteFromOffice,
	GeneralHtmlSupport,
	Alignment,
	Bold,
	Italic,
	Underline,
	Strikethrough,
	Subscript,
	Superscript,
	FontColor,
	FontBackgroundColor,
	FontFamily,
	FontSize,
	Indent,
	Table,
	TableProperties,
	TableCellProperties,
	TextPartLanguage
} = CKEDITOR;
const { PasteFromOfficeEnhanced } = CKEDITOR_PREMIUM_FEATURES;

// Other imports...

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			// Load the open-source feature.
			PasteFromOffice,

// Load the enhanced feature.
			PasteFromOfficeEnhanced,

// Load the recommended General HTML Support feature.
			GeneralHtmlSupport,

/* ... */
		],

// See the "Configuration" section below to learn how to configure
		// the editor for the best performance.
		// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

Finally, [update the configuration](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--configuration).

### Activating the feature

### Configuration

Enhanced paste from Office does not come with its own configuration. Still, we highly recommend to load and configure other editor features in a certain way for optimal retention and performance of pasted styles:

* [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) – Enabling and [configuring](#ckeditor5/latest/features/html/general-html-support.html--enabling-all-html-features) this feature will allow you to make the most of the enhanced paste from Office by retaining advanced formatting that would otherwise be rejected by core editor features. See the [content compatibility table](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--content-formatting-support) to learn more.
* [Font size and family](#ckeditor5/latest/features/font.html) – Loading and configuring these features will ensure maximal compatibility of fonts in the pasted content.

The recommended configuration is as follows:

**NPM**

// Other imports...

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			// Load the open-source feature.
			PasteFromOffice,

// Load the enhanced feature.
			PasteFromOfficeEnhanced,

// Load the recommended General HTML Support feature.
			GeneralHtmlSupport,

/* ... */
		],

// Configuration of the GeneralHtmlSupport plugin to allow extra content into the editor.
		// This configuration will preserve styles and formatting normally unsupported by core editor features.
		htmlSupport: {
			allow: [
				{
					name: /^.*$/,
					styles: true,
					attributes: true,
					classes: true
				}
			]
		},

// Configuration of the FontFamily plugin.
		fontFamily: {
			// Allow all fonts from Microsoft Office documents
			// including those that are unknown to CKEditor.
			supportAllValues: true
		},

// Configuration of the FontSize plugin.
		fontSize: {
			options: [
				8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22
			],

// Allow all font sizes from Microsoft Office documents
			// including those that are unknown to CKEditor.
			supportAllValues: true
		},

// Add UI buttons and dropdowns for extra editor features if you used the feature set
		// from "Installation" section.
		toolbar: [
			// ...
			'bold', 'italic', 'underline', 'strikethrough', 'superscript', 'subscript',
			'|',
			'alignment', 'outdent', 'indent',
			'|',
			'fontSize', 'fontFamily', 'fontColor', 'fontBackgroundColor',
			'|',
			'insertTable',
			'|',
			'textPartLanguage',
			// ...
		],

// Add UI buttons and dropdowns for extra table features if you used the feature set
		// from "Installation" section.
		table: {
			contentToolbar: [
				'tableColumn', 'tableRow', 'mergeTableCells', '|', 'tableProperties', 'tableCellProperties'
			]
		},

// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

// Other imports...

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			// Load the open-source feature.
			PasteFromOffice,

// Load the enhanced feature.
			PasteFromOfficeEnhanced,

// Load the recommended General HTML Support feature.
			GeneralHtmlSupport,

/* ... */
		],

// Configuration of the FontFamily plugin.
		fontFamily: {
			// Allow all fonts from Microsoft Office documents
			// including those that are unknown to CKEditor.
			supportAllValues: true
		},

// Configuration of the FontSize plugin.
		fontSize: {
			options: [
				8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22
			],

// Allow all font sizes from Microsoft Office documents
			// including those that are unknown to CKEditor.
			supportAllValues: true
		},

// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Known issues

* There is a known issue with cell widths being incorrect upon pasting from Microsoft Excel. [Learn more](https://github.com/ckeditor/ckeditor5/issues/14521).
* Headings pasted from Microsoft Word with a normal font weight configured in styles will be rendered using a bold font due to the default style sheets provided by the editor.
* A bold text pasted from Microsoft Excel may be occasionally displayed as normal for specific font faces.
* There is a known issue with font family, font size, and text part language values being displayed incorrectly in the CKEditor UI.

### Related features

CKEditor 5 supports a wider range of paste features, including:

* [Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) – Basic, open-source version of the paste from Office plugin.
* [Paste from Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) – Paste content from Google Docs, maintaining the original formatting and structure.
* [Paste plain text](#ckeditor5/latest/features/pasting/paste-plain-text.html) – Paste text without formatting that will inherit the style of the content it was pasted into.
* [Import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) – Convert Word files directly into HTML content. You can read more about the differences between the paste from Office and import from Word features in the [dedicated comparison guide](#ckeditor5/latest/features/converters/import-word/features-comparison.html).

<a id="ckeditor5/latest/features/pasting/paste-from-office.html">source file: "ckeditor5/latest/features/pasting/paste-from-office.html"</a>

## Paste from Office

Paste from Office features let you paste content from Microsoft Word and Microsoft Excel and preserve its original structure and formatting. This is the basic, open-source Paste from Office feature. You can also try the more advanced, premium [enhanced Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html) feature.

### Demo

Use these sample documents to test pasting from Microsoft Office Word and Excel:

* [Sample Word document](../../assets/PasteFromOfficeEnhancedWordSample.docx)
* [Sample Excel spreadsheet](../../assets/PasteFromOfficeEnhancedExcelSample.xlsx)

To test pasting from Office, download the sample documents and open them in Microsoft Office applications. Then, copy the content and paste it into the editor below.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Enhanced paste from Office

Refer to the [enhanced Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html--content-formatting-support) guide for a full comparison of supported styles and formatting between the basic and premium versions.

### Additional feature information

> **Note**
>
> The Paste from Office plugin only preserves content formatting and structures that are included in your CKEditor 5 setup. This means that you may need to add missing features such as font color or text alignment. Read more in the [Automatic content filtering](#ckeditor5/latest/features/pasting/paste-from-office.html--automatic-content-filtering) section below.

Thanks to the paste from Office feature, you can copy and paste Microsoft Word documents into CKEditor 5 and maintain basic text styling, heading levels, links, lists, tables, and images.

Footnotes from the pasted document are also converted, as long as the [footnotes](#ckeditor5/latest/features/footnotes.html) feature is enabled in your editor.

When the plugin is enabled, it automatically detects Microsoft Word content and transforms its structure and formatting to clean HTML which is then transformed into semantic content by the editor.

The [`PasteFromOffice`](../../api/module_paste-from-office_pastefromoffice-PasteFromOffice.html) plugin also allows you to paste content from Google Docs. See the [pasting content from Google Docs guide](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) to learn more.

### Support for other office applications

You can find more information regarding compatibility with other applications in [this ticket](https://github.com/ckeditor/ckeditor5/issues/1184#issuecomment-409828069).

If you think that support for any of the applications needs improvements, please add 👍 and comments in the following issues:

* [Support pasting from Libre Office](https://github.com/ckeditor/ckeditor5/issues/2520).
* [Support pasting from Pages](https://github.com/ckeditor/ckeditor5/issues/2527).

Feel free to open a [new feature request](https://github.com/ckeditor/ckeditor5/issues/new/choose) for other similar applications, too!

### Automatic content filtering

With CKEditor 5 you do not need to worry about pasting messy content from Microsoft Word (or any other possible sources). Thanks to the CKEditor 5 [custom data model](#ckeditor5/latest/framework/index.html), only content that is specifically handled by the loaded rich-text editor features will be preserved.

This means that if you did not enable, for instance, [font family and font size](#ckeditor5/latest/features/font.html) features, this sort of formatting will be automatically stripped off when you paste content from Microsoft Word and other sources (like other websites).

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, PasteFromOffice } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ PasteFromOffice, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, PasteFromOffice } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ PasteFromOffice, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Known issues

If the pasted document contains both images and styled text (like headings), images are sometimes not pasted properly. Unfortunately, for some operating systems, browsers, and Word versions the image data is not available in the clipboard in this case.

It is advised to try and paste the image separately from the body of the text if this error occurs.

If the image is represented in the Word content by the VML syntax (like this one: `<v:shape><v:imagedata src="...."/></v:shape>`), it will not be pasted either as this notation is not supported by CKEditor 5. If you’d like to see this feature implemented, add a 👍 reaction to [this GitHub issue](https://github.com/ckeditor/ckeditor5/issues/9245).

### Related features

CKEditor 5 supports a wider range of paste features, including:

* [Enhanced paste from Office](#ckeditor5/latest/features/pasting/paste-from-office-enhanced.html) – Enhanced paste from Office is a premium version of the plugin that offers far greater capabilities.
* [Paste from Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) – Paste content from Google Docs, maintaining the original formatting and structure.
* [Paste plain text](#ckeditor5/latest/features/pasting/paste-plain-text.html) – Paste text without formatting that will inherit the style of the content it was pasted into.
* [Import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) – Convert Word files directly into HTML content. You can read more about the differences between the paste from Office and import from Word features in the [dedicated comparison guide](#ckeditor5/latest/features/converters/import-word/features-comparison.html).
* [Paste Markdown](#ckeditor5/latest/features/pasting/paste-markdown.html) – Paste Markdown-formatted content straight into the editor.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-paste-from-office>.

<a id="ckeditor5/latest/features/pasting/paste-markdown.html">source file: "ckeditor5/latest/features/pasting/paste-markdown.html"</a>

## Paste Markdown

The paste Markdown feature lets users paste Markdown-formatted content straight into the editor. It will be then converted into rich text on the fly.

> **Warning**
>
> This feature is still in the experimental phase. See the [known issues](#ckeditor5/latest/features/pasting/paste-markdown.html--known-issues) section to learn more.

### Demo

Paste some Markdown-formatted content into the demo editor below and see it turn into rich text on the fly. You can copy [this document](../../assets/markdown.txt) for convenience.

Output:

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Bold, Italic, Essentials, PasteFromMarkdownExperimental } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [
			PasteFromMarkdownExperimental,
			Essentials,
			Bold,
			Italic,
			// More plugins.
			// ...
		],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Bold, Italic, Essentials, PasteFromMarkdownExperimental } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [
			PasteFromMarkdownExperimental,
			Essentials,
			Bold,
			Italic,
			// More plugins.
			// ...
		],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Known issues

While the paste Markdown feature is already stable enough to use, it still needs some more testing. We are now focused on testing it in connection with other tools and plugins. If you have any observations, suggestions, or feedback you want to share, feel free to put them in [this GitHub issue](https://github.com/ckeditor/ckeditor5/issues/2321).

### Related features

CKEditor 5 supports a wider range of paste features, including:

* [Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) – Paste content from Microsoft Word and keep the original structure and formatting.
* [Paste from Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) – Paste content from Google Docs, maintaining the original formatting and structure.
* [Paste plain text](#ckeditor5/latest/features/pasting/paste-plain-text.html) – Paste text without formatting that will inherit the style of the content it was pasted into.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Format your content on the go with Markdown-like shortcodes.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-markdown-gfm>

<a id="ckeditor5/latest/features/pasting/paste-plain-text.html">source file: "ckeditor5/latest/features/pasting/paste-plain-text.html"</a>

## Pasting plain text

With the plain text pasting feature, text pasted using the `Ctrl`/`Cmd` + `Shift` + `V` keystroke will match the formatting of the content you paste it into.

### Demo

Copy some text from one of the styled paragraphs below and press `Ctrl`/`Cmd` + `Shift` + `V` to paste it into another paragraph. See how the pasted text matches the paragraph’s style. Next, compare what happens when you paste the text without pressing `Shift`.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The plain text pasting feature is implemented by the `PastePlainText` plugin which is a part of the `Clipboard` plugin.

It detects the `Ctrl`/`Cmd` + `Shift` + `V` keystroke during the paste and causes the pasted text to inherit the styles of the content it was pasted into. In this sense, the feature can also be described as “pasting without formatting” – the source formatting of the pasted text gets replaced with the target formatting of the text it was pasted into.

Pasting plain text with a double line break will turn the break into a paragraph. A single line break will instead be turned into a soft break upon pasting.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { Bold, ClassicEditor, Clipboard } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Clipboard, Bold, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { Bold, ClassicEditor, Clipboard } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Clipboard, Bold, /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

The [`PastePlainText`](../../api/module_clipboard_pasteplaintext-PastePlainText.html) plugin will activate along with the clipboard plugin.

### Support for other applications

You can find more information regarding compatibility with other applications in [this ticket](https://github.com/ckeditor/ckeditor5/issues/1184#issuecomment-409828069).

If you think that support for any of the applications needs improvements, please add 👍 and comments in the following issues:

Feel free to open a [new feature request](https://github.com/ckeditor/ckeditor5/issues/new/choose) for other similar applications, too!

### Related features

CKEditor 5 supports a wider range of paste features, including:

* [Paste Markdown](#ckeditor5/latest/features/pasting/paste-markdown.html) – Paste Markdown-formatted content straight into the editor.
* [Paste from Office](#ckeditor5/latest/features/pasting/paste-from-office.html) – Paste content from Microsoft Word and keep the original structure and formatting.
* [Paste from Google Docs](#ckeditor5/latest/features/pasting/paste-from-google-docs.html) – Paste content from Google Docs, maintaining the original formatting and structure.
* [Import from Word](#ckeditor5/latest/features/converters/import-word/import-word.html) – Convert Word files directly into HTML content.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-clipboard>.

<a id="ckeditor5/latest/features/read-only.html">source file: "ckeditor5/latest/features/read-only.html"</a>

## Read-only support

CKEditor 5 offers an out-of-the-box read-only mode. You can use it to prevent users under certain circumstances from editing your content.

### Demo

Use the button below to toggle the read-only mode. Some features, like exports or search, are still functional in the read-only mode. Others, like the replace function, are disabled.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

> **Note**
>
> You can see that after switching to read-only mode, some of the toolbar items are still active and functional. It happens thanks to the [`affectsData` property](../api/module_core_command-Command.html#member-affectsData). For most of the plugins, it is set to `true` by default, which makes them inactive when entering read-only mode. However, for those plugins that do not make any changes in the model – do not affect the content – it is set to `false`, thus allowing to still make use of them in modes with restricted user write permissions.

### Additional feature information

The feature does not require any additional plugin and the editor can be set into a read-only mode using the editor’s [`Editor#enableReadOnlyMode()`](../api/module_core_editor_editor-Editor.html#function-enableReadOnlyMode) method.

The read-only mode may have several applications. It may be used to impose user-based access restrictions, where a selected user or a group of users is only allowed to access the content for evaluation purposes but not change it.

The feature may also be used to view content that should not be edited, like financial reports, software logs, or reprinted stories. While not editable, this content will still be accessible for copying or for screen readers.

The editor can be switched to or out of the read-only mode by many features, under various circumstances. It supports a dedicated locking mechanism for the read-only mode. This solution enables easy control over the read-only mode even when many features try to turn it on or off at the same time, without conflicting with each other. It guarantees that the user will not make the editor content editable by accident (which could lead to errors).

> **Note**
>
> See also the [restricted editing feature](#ckeditor5/latest/features/restricted-editing.html) that lets you define which parts of a document can be editable for a group of users with limited editing rights, leaving the rest of the content non-editable to them. You can also read the [dedicated blog post](https://ckeditor.com/blog/feature-of-the-month-restricted-editing-modes/) about write-restricted editor modes.

### Hiding the toolbar in the read-only mode

Some use cases might require hiding the editor toolbar when entering the read-only mode. This can be achieved easily with the following code:

```js
ClassicEditor
    .create( {
        // The editor's configuration.
        // ...
    } )
    .then( editor => {
        const toolbarElement = editor.ui.view.toolbar.element;

editor.on( 'change:isReadOnly', ( evt, propertyName, isReadOnly ) => {
            if ( isReadOnly ) {
                toolbarElement.style.display = 'none';
            } else {
                toolbarElement.style.display = 'flex';
            }
        } );
    } )
    .catch( error => {
        console.log( error );
    } );
```

When the button is clicked, the `editor.enableReadOnlyMode()` creates a lock that sets the read-only mode on the editor. This triggers the code showed above, which in turn hides the toolbar using CSS styles. After clicking the button once more, the `editor.disableReadOnlyMode()` is called, which removes the read-only lock and the editor’s and the toolbar is visible again. This approach will work both for classic and decoupled editors.

Use the demo below to see this code in action. Toggle the read-only mode with the button. You will see that the toolbar disappears in the read-only mode.

### Common API

The editor provides the following API to manage the read-only mode:

* The [`isReadOnly`](../api/module_core_editor_editor-Editor.html#member-isReadOnly) property is a read-only, observable property that allows you to check the `isReadOnly` value and react to its changes,
* The [`Editor#enableReadOnlyMode( featureId )`](../api/module_core_editor_editor-Editor.html#function-enableReadOnlyMode) method turns on the read-only mode for the editor by creating a lock with given unique id.
* The [`Editor#disableReadOnlyMode( featureId )`](../api/module_core_editor_editor-Editor.html#function-disableReadOnlyMode) method removes the read-only lock from the editor. The editor becomes editable when no lock is present on the editor anymore.

### Related features

There are more features that help control user permissions in the WYSIWYG editor:

* [Restricted editing](#ckeditor5/latest/features/restricted-editing.html) – Define editable areas of the document for users with restricted editing rights.
* [Comments-only mode](#ckeditor5/latest/features/collaboration/comments/comments-only-mode.html) – Users can add comments to any part of the content instead of editing it directly.

### Common API

The editor provides the following API to manage the read-only mode:

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-core>.

<a id="ckeditor5/latest/features/remove-format.html">source file: "ckeditor5/latest/features/remove-format.html"</a>

## Remove formatting

The remove format feature lets you quickly remove any text formatting applied using inline HTML elements and CSS styles, like [basic text styles](#ckeditor5/latest/features/basic-styles.html) (bold, italic) or [font family, size, and color](#ckeditor5/latest/features/font.html). This feature does not remove block-level formatting ([headings](#ckeditor5/latest/features/headings.html), [images](#ckeditor5/latest/features/images/images-overview.html)) or semantic data ([links](#ckeditor5/latest/features/link.html)).

### Demo

Select the content you want to clean up and press the remove format button in the toolbar.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, RemoveFormat } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ RemoveFormat, /* ... */ ],
		toolbar: [ 'removeFormat', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, RemoveFormat } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ RemoveFormat, /* ... */ ],
		toolbar: [ 'removeFormat', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring the remove format feature

This feature has no integration–level configuration. Once enabled, it works out–of–the–box with all [core editor features](#ckeditor5/latest/features/index.html).

### A short note about content types in the editor

The remove format feature is intended to help users tidy up chunks of content from unnecessary formatting. Each editor feature brings its own content types to the WYSIWYG editor. If you do not want the unnecessary formatting to be enabled in the first place, you may want to consider reducing the number of features enabled in the editor.

Doing that will spare the users the pain of manually removing formatting every time they paste content from other programs and make the editing experience smoother. The narrower set of editor features also gives you more control over the content saved to the database and prevents the accidental use of the types of content you would rather not store in your application.

### Integrating with editor features

In order for the remove formatting feature to work with custom content, you need to update the [schema](#ckeditor5/latest/framework/architecture/editing-engine.html--schema) by setting the `isFormatting` property on the custom [text attribute](#ckeditor5/latest/framework/architecture/editing-engine.html--text-attributes).

This is already done for most inline elements supported by the [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) plugin and its derivatives such as the [Style](#ckeditor5/latest/features/style.html) plugin.

By default, formatting is not removed from the [link](#ckeditor5/latest/features/link.html) elements. To remove formatting from them as well, you need to create a [plugin](#ckeditor5/latest/getting-started/setup/configuration.html) that extends the schema and tells the editor that the `linkHref` text attribute produced by the link feature is a formatting attribute:

```js
// A simple plugin that extends the remove format feature to consider links.
function RemoveFormatLinks( editor ) {
    // Extend the editor schema and mark the "linkHref" model attribute as formatting.
    editor.model.schema.setAttributeProperties( 'linkHref', {
        isFormatting: true
    } );
}
```

Enable the `RemoveFormatLinks` plugin in the [configuration](#ckeditor5/latest/getting-started/setup/configuration.html--adding-features) and run the editor:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [
            RemoveFormat,
            RemoveFormatLinks,
            // More plugins.
            // ...
        ],
        toolbar: [
            'removeFormat',
            // More toolbar items.
            // ...
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

From now on, the remove format button should also remove links in the content. [Learn more about attribute properties.](../api/module_engine_model_schema-ModelSchema.html#function-setAttributeProperties)

### Related features

CKEditor 5 has more features that can help you format your content:

* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – The essentials, like **bold**, _italic_, and others.
* [Font styles](#ckeditor5/latest/features/font.html) – Easily and efficiently control the font [family](#ckeditor5/latest/features/font.html--configuring-the-font-family-feature), [size](#ckeditor5/latest/features/font.html--configuring-the-font-size-feature), [text or background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features).
* [Format painter](#ckeditor5/latest/features/format-painter.html) – Easily copy text formatting and apply it in a different place in the edited document.
* [Text alignment](#ckeditor5/latest/features/text-alignment.html) – Align your content left, align it right, center it, or justify.

### Common API

The [`RemoveFormat`](../api/module_remove-format_removeformat-RemoveFormat.html) plugin registers the `'removeFormat'` UI button component and a command of the same name implemented by [`RemoveFormatCommand`](../api/module_remove-format_removeformatcommand-RemoveFormatCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Removes all the formatting in the selection.
editor.execute( 'removeFormat' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-remove-format>.

<a id="ckeditor5/latest/features/restricted-editing.html">source file: "ckeditor5/latest/features/restricted-editing.html"</a>

## Restricted editing

The restricted editing feature introduces two modes: the standard editing mode and the restricted editing mode. Users working in the restricted editing mode cannot change the content, except for parts marked as editable.

### Demo

The demo below lets you emulate both the standard editing mode and the restricted editing mode.

Start by creating a template of the document in the standard editing mode. Select a section of the text and use the enable editing toolbar button to turn a selected area into an editable region or remove an existing one.

Then switch to the restricted editing mode to see how the editable and non-editable regions behave.

> **Tip**
>
> Use `Tab` to navigate from one editable region to another (and `Shift`+`Tab` to move back) in the restricted mode.

**Mode:**

Standard

Restricted

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

The restricted editing feature enables two editing modes:

* **Standard editing mode** – In this mode the user can edit the content and choose regions that should be editable in the restricted editing mode.
* **Restricted editing mode** – When you initialize the editor in this mode, the user can edit the content only within the regions chosen by the user in the standard editing mode. There changes allowed withing these fields can be configured.

There are two types of editable fields: inline and block.

* **Inline editable fields** only allow content editing with [features enabled in the restricted mode](#ckeditor5/latest/features/restricted-editing.html--enabling-commands-in-the-restricted-editing-mode). This kind of field can only hold inline content. They support only inline-type changes. Users can type, delete content, and format the text. However, no block-type editions are available. This means no splitting paragraphs (striking the `Enter` key) is allowed. Tables or block images cannot be added in this field, either.
* **Block editable fields** enable all content editing features loaded in the editor. Content inside the block can be anything, including lists, tables, images etc. (providing these features are loaded into the editor).

You can observe it in the [demo](#ckeditor5/latest/features/restricted-editing.html--demo) while switching between the inline and the block editable field – the number of active toolbar items will change.

Both block and inline fields can be inserted via the toolbar dropdown . The availability of one or both types of fields from the toolbar [can be configured](#ckeditor5/latest/features/restricted-editing.html--configuring-the-toolbar).

You can imagine a workflow where a certain group of users is responsible for creating templates of documents. At the same time, a second group of users can only fill the gaps (for example, fill in the missing data, like names, dates, product names, etc.).

By using this feature, the users of your application will be able to create template documents. In a certain way, you can use this feature to generate forms with rich-text capabilities. This kind of practical application is shown in the [How to create ready-to-print documents with CKEditor 5 pagination feature](https://ckeditor.com/blog/How-to-create-ready-to-print-documents-with-page-structure-in-WYSIWYG-editor---CKEditor-5-pagination-feature/) blog post.

> **Note**
>
> See also the [read-only feature](#ckeditor5/latest/features/read-only.html) that lets you turn the entire WYSIWYG editor into read-only mode. You can also read the [dedicated blog post](https://ckeditor.com/blog/feature-of-the-month-restricted-editing-modes/) about write-restricted editor modes.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration.

#### Running the standard editing mode

To initialize the editor in the standard editing mode, add the [`StandardEditingMode`](../api/module_restricted-editing_standardeditingmode-StandardEditingMode.html) plugin and add the `'restrictedEditingException:auto'` button to the toolbar:

**NPM**

```js
import { ClassicEditor, StandardEditingMode } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ StandardEditingMode, /* ... */ ],
		toolbar: [ 'restrictedEditingException:auto', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, StandardEditingMode } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ StandardEditingMode, /* ... */ ],
		toolbar: [ 'restrictedEditingException:auto', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Please note there are available toolbar items for inline, block, auto, and both types of editable fields. Read more in the [Configuring the tollbar](#ckeditor5/latest/features/restricted-editing.html--configuring-the-toolbar) section.

#### Running the restricted editing mode

To initialize the editor in the restricted editing mode, add the [`RestrictedEditingMode`](../api/module_restricted-editing_restrictededitingmode-RestrictedEditingMode.html) plugin and add the `'restrictedEditing'` button to the toolbar:

**NPM**

```js
import { ClassicEditor, RestrictedEditingMode } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ RestrictedEditingMode, /* ... */ ],
		toolbar: [ 'restrictedEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, RestrictedEditingMode } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ RestrictedEditingMode, /* ... */ ],
		toolbar: [ 'restrictedEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

You can configure which features should be available in the inline editing field. For instance, the following configuration allows the users to type, delete but also to bold text.

```js
ClassicEditor
    .create( {
        // ... Other confituration options ...
        restrictedEditing: {
            allowedCommands: [ 'bold' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Warning**
>
> This setting only applies to inline editing fields, where only inline content inserting or editing commands are allowed. Block content commands such as `insertTable` or `enter` cannot be allowed via this setting, as they are only available in block editing fields.

**Note**: Typing and deleting text is always possible in restricted editing regions. For more information, check out the [`config.restrictedEditing`](../api/module_restricted-editing_restrictededitingconfig-RestrictedEditingConfig.html) documentation.

#### Enabling commands in the restricted editing mode

The restricted editing mode allows modifying the editor content only in designated regions. Outside these regions, most of the editor commands are turned off by default. If you wish to enable some commands outside the restricted editing regions, you can use the [`RestrictedEditingModeEditing.enableCommand()`](../api/module_restricted-editing_restrictededitingmodeediting-RestrictedEditingModeEditing.html#function-enableCommand) method. You must execute this method in the [`afterInit()`](../api/module_core_plugin-PluginInterface.html#function-afterInit) callback of an editor plugin.

**NPM**

```js
import { ClassicEditor, Plugin } from 'ckeditor5';

class MyPlugin extends Plugin {
	afterInit() {
		this.editor.plugins.get( 'RestrictedEditingModeEditing' ).enableCommand( 'myCommand' );
	}
}
```

**CDN**

```js
const { ClassicEditor, Plugin } = CKEDITOR;

class MyPlugin extends Plugin {
	afterInit() {
		this.editor.plugins.get( 'RestrictedEditingModeEditing' ).enableCommand( 'myCommand' );
	}
}
```

#### Configuring the toolbar

When configuring the toolbar item for inserting restricted editing fields in standard mode, you can choose to provide your users with access to inline, block or both types of fields. To add these to the toolbar, you should use the following toolbar item calls, respectively: `restrictedEditingException:dropdown` (both types of fields available), `restrictedEditingException:inline`, and `restrictedEditingException:block`. There is also the `restrictedEditingException:auto` button that switches between an inline and block depending on the selection.

Example toolbar configuration may look like the one below:

```js
toolbar: [
    'restrictedEditingException:auto', '|',
    'heading', '|', 'bold', 'italic', 'link', '|',
    'bulletedList', 'numberedList', 'todolist', 'outdent', 'indent', '|',
    'blockQuote', 'insertImage', 'insertTable', '|',
    'undo', 'redo'
]
```

To configure the feature toolbar button for restricted mode, use the `restrictedEditing` call, instead. The Navigate editable regions button allows for moving between previous/next editable fields.

Example toolbar configuration may look like the one below. Please note that whatever toolbar items maybe enable, the two different types of editable fields [will not support all of them.](#ckeditor5/latest/features/restricted-editing.html--additional-feature-information). From the example below, inline editable fields will only support bold, italic, link, and undo, while images, tables, and list will only be available for block type fields.

```js
toolbar: {
    items: [
        'restrictedEditing', '|',
        'heading', '|', 'bold', 'italic', `link`, '|',
        'bulletedList', 'numberedList', 'todoList', 'outdent', 'indent', '|',
        'insertImage', 'insertTable', '|',
        'undo', 'redo'
    ]
}
```

##### Legacy toolbar button

The new toolbar items were introduced with version 47.2.0. To retain full backwards compatibility, we have provided an alias toolbar item: `restrictedEditingException`. It is the old toolbar button call and it defaults to inline restricted editing field button. There is no need to change your configuration if you only want to use inline fields type.

### Related features

CKEditor 5 has more features that help you control user permissions:

* [Read-only](#ckeditor5/latest/features/read-only.html) – Turn the entire content of the editor read-only.
* [Track changes](#ckeditor5/latest/features/collaboration/track-changes/track-changes.html) – Mark user changes in the content and show them as suggestions in the sidebar for acceptance or rejection.
* [Comments](#ckeditor5/latest/features/collaboration/comments/comments.html) – Users can add comments to any part of the content instead of editing it directly.

> **Note**
>
> Read this [CKEditor blog post](https://ckeditor.com/blog/How-to-create-ready-to-print-documents-with-page-structure-in-WYSIWYG-editor---CKEditor-5-pagination-feature/) on how to couple restricted editing with other features to create editable document templates.

### Common API

The [`StandardEditingMode`](../api/module_restricted-editing_standardeditingmode-StandardEditingMode.html) plugin registers:

* The `'restrictedEditingException:auto'` button that lets you mark regions as editable (either block or inline depending on the selection).
* The `'restrictedEditingException:dropdown'` button that lets you mark regions as editable.
* The `'restrictedEditingException:inline'` button that lets you mark inline regions as editable.
* The `'restrictedEditingException:block'` button that lets you mark block regions as editable.
* The `'restrictedEditingException'` button that lets you mark inline regions as editable (legacy alias).
* The [`'restrictedEditingException'`](../api/module_restricted-editing_restrictededitingexceptioncommand-RestrictedEditingExceptionCommand.html) command that allows marking inline regions as editable.
* The [`'restrictedEditingExceptionBlock'`](../api/module_restricted-editing_restrictededitingexceptionblockcommand-RestrictedEditingExceptionBlockCommand.html) command that allows marking block regions as editable.
* The [`'restrictedEditingExceptionAuto'`](../api/module_restricted-editing_restrictededitingexceptionautocommand-RestrictedEditingExceptionAutoCommand.html) command that calls either inline or block command depending on the selection.

The [`RestrictedEditingMode`](../api/module_restricted-editing_restrictededitingmode-RestrictedEditingMode.html) plugin registers:

* The `'restrictedEditing'` dropdown that lets you navigate between editable regions.
* The [`'goToPreviousRestrictedEditingException'`](../api/module_restricted-editing_restrictededitingmodenavigationcommand-RestrictedEditingModeNavigationCommand.html) and `'goToNextRestrictedEditingException'` commands that allow navigating between editable regions.

### Real-time collaboration

When using [real-time collaboration](https://ckeditor.com/collaboration/real-time-collaborative-editing/), all the connected users should always be in the same mode. You cannot have a different list of plugins enabled among users of a single collaborative session.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-restricted-editing>.

<a id="ckeditor5/latest/features/select-all.html">source file: "ckeditor5/latest/features/select-all.html"</a>

## Select all

The select all feature lets you select the entire content using the `Ctrl`/`Cmd`+`A` keystroke or a toolbar button. This way you can clear or copy all the content in one move.

### Demo

Press `Ctrl`/`Cmd`+`A` or use the toolbar button to select the entire content of the editor.

> **Note**
>
> When the selection is inside the [image caption](#ckeditor5/latest/features/images/images-captions.html), it will only expand to the boundaries of the caption. Use the keystroke or the toolbar button again to include more content until the entire content of the editor is selected. The same rule applies when the selection is inside a table cell or any self–contained (nested) editable part of the content.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, SelectAll } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ SelectAll, /* ... */ ],
		toolbar: [ 'selectAll', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, SelectAll } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SelectAll, /* ... */ ],
		toolbar: [ 'selectAll', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

### Related features

* [Keyboard shortcuts](#ckeditor5/latest/features/accessibility.html--keyboard-shortcuts) – Check other popular keyboard shortcuts supported by CKEditor 5.

### Common API

The [`SelectAll`](../api/module_select-all_selectall-SelectAll.html) plugin registers the `'selectAll'` UI button component and the `'selectAll'` command implemented by [`SelectAllCommand`](../api/module_select-all_selectallcommand-SelectAllCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Select the entire content of the editor.
editor.execute( 'selectAll' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-select-all>.

<a id="ckeditor5/latest/features/show-blocks.html">source file: "ckeditor5/latest/features/show-blocks.html"</a>

## Show blocks

The show blocks feature allows the content creators to visualize all block-level elements (except for widgets). It surrounds them with an outline and displays their element name in the top-left corner of the box.

### Demo

Toggle the block elements visibility with the show block toolbar button to see the feature in action. The content remains editable, so you can see how the blocks adjust to the content structure on the go. These outlines are not visible in the [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) and [export to Word](#ckeditor5/latest/features/converters/export-word.html) features, so there is no need to remove them before exporting.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, ShowBlocks } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ ShowBlocks, /* ... */ ],
		toolbar: [ 'showBlocks', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, ShowBlocks } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ ShowBlocks, /* ... */ ],
		toolbar: [ 'showBlocks', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

### Known issues

* The show blocks feature does not support widgets, yet. It means it will currently not show block outlines for example for images or tables. Feel free to upvote 👍 [this issue on GitHub](https://github.com/ckeditor/ckeditor5/issues/14869) if it is important for you.
* At present, the show blocks feature is not yet fully compatible with the [pagination](#ckeditor5/latest/features/pagination/pagination.html) feature. Using these two together may result in errors.

### Related features

Other CKEditor 5 features related to HTML editing that you may want to check:

* [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) – Allows you to enable HTML features (elements, attributes, classes, styles) that are not supported by other dedicated CKEditor 5 plugins.
* [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) – Allows for viewing and editing the source code of the document in a handy modal window (compatible with all editor types) with syntax highlighting, autocompletion and more.
* [Full page HTML](#ckeditor5/latest/features/html/full-page-html.html) – Allows using CKEditor 5 to edit entire HTML pages, from `<html>` to `</html>`, including the page metadata.

### Common API

The [`ShowBlocks`](../api/module_show-blocks_showblocks-ShowBlocks.html) plugin registers the `'showBlocks'` UI button component and the `'showBlocks'` command implemented by [`ShowBlocksCommand`](../api/module_show-blocks_showblockscommand-ShowBlocksCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Toggle the visibility of block-level elements outline.
editor.execute( 'showBlocks' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-show-blocks>.

<a id="ckeditor5/latest/features/slash-commands.html">source file: "ckeditor5/latest/features/slash-commands.html"</a>

## Slash commands

The slash commands feature lets you execute a predefined command by writing its name or alias directly in the editor. When you type a slash (`/`), the suggested commands are displayed in a panel next to it. You can also type a phrase after the `/` to filter the results in the panel and to easily find the desired command.

### Demo

Type the `/` character to invoke a panel with predefined commands. Then, filter the result list by typing more characters after the slash, for example: `/list`. Slash commands can also apply templates or styles defined in the editor.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

> **Note**
>
> The slash commands feature uses the [mentions feature](#ckeditor5/latest/features/mentions.html) under the hood, so ensure you [install it](#ckeditor5/latest/features/mentions.html--installation) too.

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Mention } from 'ckeditor5';
import { SlashCommand } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SlashCommand, Mention, /* ... */ ],
		slashCommand: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Mention } = CKEDITOR;
const { SlashCommand } = CKEDITOR_PREMIUM_FEATURES;

#### Activating the feature

### Unsupported contexts

Slash commands are automatically disabled inside [code blocks](#ckeditor5/latest/features/code-blocks.html). Typing `/` inside a code block will insert the character as plain text without triggering the command panel.

### Configuration

> **Note**
>
> For more technical details, check the [plugin configuration reference](../api/module_slash-command_slashcommandconfig-SlashCommandConfig.html).

Although the slash commands feature is based on the [mention](#ckeditor5/latest/features/mentions.html) feature, it does not require any additional configuration to work. In particular, the `/` marker is configured automatically as well as the list of [default slash commands](../api/module_slash-command_slashcommandconfig-SlashCommandConfig.html#function-getDefaultCommands) that will work right away (as long as they are enabled in the editor).

However, if you want to modify this list, it is possible to easily [add](#ckeditor5/latest/features/slash-commands.html--adding-slash-commands) or [remove](#ckeditor5/latest/features/slash-commands.html--removing-slash-commands) commands through configuration. It is also possible to [limit the number of commands](#ckeditor5/latest/features/slash-commands.html--limiting-displayed-command-list) displayed in the panel.

#### Adding slash commands

It is possible to add both commands registered in the editor and commands that execute custom logic. The parameter you should use for custom commands is [`slashCommand.extraCommands`](../api/module_slash-command_slashcommandeditorconfig-SlashCommandEditorConfig.html#member-extraCommands).

##### Editor commands

To add an editor command as a slash command, besides the [`id`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-id) and the [`title`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-title) you have to provide the [`commandName`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-commandName) parameter. The example below shows how to add a `bold` slash command:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        slashCommand: {
            extraCommands: [
                {
                    id: 'bold',
                    title: 'Bold',
                    commandName: 'bold',
                    // ...
                },
                // ...
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

##### Proxy commands

To add a proxy command (a command that executes custom logic), besides the [`id`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-id) and the [`title`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-title) you have to provide a callback function for the [`execute`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-execute) parameter. If you do not provide an `execute` parameter for a proxy command, the editor will throw an error when the user tries to execute it.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        slashCommand: {
            extraCommands: [
                {
                    id: 'alert',
                    title: 'Alert',
                    execute: editor => { console.log( 'Custom logic was executed.' ) }
                    // ...
                },
                // More extra commands.
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Removing slash commands

To remove a command from the default list of slash commands, add its name to the array of removed commands ([`slashCommand.removeCommands`](../api/module_slash-command_slashcommandeditorconfig-SlashCommandEditorConfig.html#member-removeCommands)). The command will only be removed from the list of [default slash commands](../api/module_slash-command_slashcommandconfig-SlashCommandConfig.html#function-getDefaultCommands), and not from the editor.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        slashCommand: {
            removeCommands: [ 'heading', 'paragraph', /* ... */ ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Limiting displayed command list

By default, all available slash commands are displayed in the panel. If you want to limit the number of commands displayed to the user, use the [`slashCommand.dropdownLimit`](../api/module_slash-command_slashcommandeditorconfig-SlashCommandEditorConfig.html#member-dropdownLimit) parameter. It will determine the number of displayed items.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        slashCommand: {
            dropdownLimit: 4
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Single slash command configuration

> **Note**
>
> For more technical details, check the [slash command configuration reference](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html).

There are some more optional parameters of a single slash command entry you might find useful when configuring your own commands:

* [`aliases`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-aliases) – To extend command filtering in the panel.
* [`description`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-description) – Helpful if a title is not descriptive enough.
* [`icon`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-icon) – To visually customize your own command.
* [`isEnabled`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-isEnabled) – To provide custom logic and decide when the command is displayed in the panel.

Here is an example of how you can use them:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        slashCommand: {
            extraCommands: [
                {
                    id: 'bold',
                    title: 'Bold',
                    execute: editor => { /* Custom logic. */ },
                    aliases: [ 'strong' ],
                    description: 'Style the text in bold.',
                    icon: customIcon,
                    isEnabled: editor => { /* Custom logic. */ }
                },
                // ...
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Sorting and filtering

By default, slash commands are sorted alphabetically by title. The order changes when the user starts filtering. Slash commands matched by [`id`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-id) are displayed first, then sorted by [`title`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-title), then by [`aliases`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-aliases), and finally by [`description`](../api/module_slash-command_slashcommandconfig-SlashCommandDefinition.html#member-description).

#### Integration with other features

Slash commands are integrated with the [template](#ckeditor5/latest/features/template.html) and [style](#ckeditor5/latest/features/style.html) features. It means that all templates and styles can be applied also using the corresponding slash command.

### Related features

You may want to check the following similar productivity features of CKEditor 5:

* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Lets you quickly apply formatting to the content you are writing.
* [Automatic text transformation](#ckeditor5/latest/features/text-transformation.html) – Enables automatic turning of snippets such as `(tm)` into `™` and `"foo"` into `“foo”`.

<a id="ckeditor5/latest/features/source-editing/source-editing-enhanced.html">source file: "ckeditor5/latest/features/source-editing/source-editing-enhanced.html"</a>

## Enhanced source code editing

The enhanced source code editing feature allows for viewing and editing the source code of the document in a handy modal window (compatible with [all editor types](#ckeditor5/latest/getting-started/setup/editor-types.html)) with syntax highlighting, autocompletion and more.

### Demo

Use any of the editors below to see the enhanced source code editing plugin in action. Please note that enhanced source code editing works with [editor types](#ckeditor5/latest/getting-started/setup/editor-types.html), taking advantage of the built–in modal system.

Toggle the source editing mode and make some changes in the HTML code (for example, add a new paragraph or an ordered list). Then leave the source editing mode and see that the changes are present in the document content.

You can also use one of the many CKEditor 5 features available in the toolbar and check how they render in the HTML source. Notice the collapsible table of contents, available thanks to the [general HTML support](#ckeditor5/latest/features/html/general-html-support.html) feature, which introduces HTML elements not yet covered by the official plugins.

**Classic editor**

**Inline editor**

**Balloon editor**

**Document editor**

**Multi-root editor**

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

#### Themes

The enhanced source code editing feature enables you to customize the look and feel of the editor containing source code, allowing for seamless visual integration with your application. You can use one of the [many already available themes](https://thememirror.net/) or create your own custom theme.

**Light theme**

**Dark theme**

##### Adding a theme

To load a custom theme, set the [`sourceEditingEnhanced.theme`](../../api/module_source-editing-enhanced_sourceeditingenhancedconfig-SourceEditingEnhancedConfig.html#member-theme) configuration option to the name of the provided theme.

> **Warning**
>
> **Note:** Custom themes are **not supported when using CKEditor 5 installed from CDN**, due to technical limitations related to bundling and dependency duplication. See [Limitations and incompatibilities](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html--custom-themes) for more information.
>
> Only the `'default'` and `'dark'` themes are fully supported in the CDN version.

```js
import { barf } from 'thememirror';

ClassicEditor
    .create( {
        // ... Other configuration options

sourceEditingEnhanced: {
            theme: barf
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

##### Creating a custom theme

To learn how to create your own custom themes, take a look at the [official CodeMirror documentation](https://codemirror.net/examples/styling/).

#### Code completion

The feature provides code completion support for HTML tags and attributes. The attribute completion list is context-aware and will only show ones that are allowed in the current context. It will also help you close open HTML tags. Start typing and the list will appear next to the caret.

Use `↑` and `↓` to browse the list. Press `Enter` to select the item.

#### Code folding

The feature allows you to fold and unfold parts of the document source code. This is especially useful when working with large documents.

Click the folding icon in the gutter to collapse or expand the code block. Use the `Ctrl`+`Shift`+`[` (`⌘⇧[` on macOS) and `Ctrl`+`Shift`+`]` (`⌘⇧]` on macOS) keyboard shortcuts to fold and unfold the code. Use `Ctrl`+`Alt`+`[` (`⌘⌥[` on macOS) and `Ctrl`+`Alt`+`]` (`⌘⌥]` on macOS) to fold and unfold all code blocks.

#### Bracket and tag matching

The feature highlights matching brackets in the source code. When you place the cursor next to a bracket, the matching bracket will be highlighted. If you move the caret inside a tag, the opening and closing tags will be highlighted. If a HTML tag is not closed properly, the editor will also highlight it to let you know.

#### Keyboard shortcuts

The source editor supports multiple keyboard shortcuts to make your work more efficient. Please refer to the full list of available keyboard shortcuts in a [dedicated guide](#ckeditor5/latest/features/accessibility.html--keyboard-shortcuts).

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { SourceEditingEnhanced } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SourceEditingEnhanced, /* ... */ ],
		toolbar: [ 'sourceEditingEnhanced', /* ... */ ],
		sourceEditingEnhanced: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { SourceEditingEnhanced } = CKEDITOR_PREMIUM_FEATURES;

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

#### Markdown source view

The source editing plugin also works well with the [Markdown output](#ckeditor5/latest/features/markdown.html) plugin. You do not need any special configuration: just add the plugin to the editor, and the source editing mode will display Markdown instead of HTML.

To utilize the Markdown source editing mode, just add the [Markdown output](#ckeditor5/latest/features/markdown.html) plugin to the editor.

**NPM**

```js
import { ClassicEditor, Markdown } from 'ckeditor5';
import { SourceEditingEnhanced } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SourceEditingEnhanced, Markdown, /* ... */ ],
		toolbar: [ 'sourceEditingEnhanced', /* ... */ ],
		sourceEditingEnhanced: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Markdown } = CKEDITOR;
const { SourceEditingEnhanced } = CKEDITOR_PREMIUM_FEATURES;

> **Note**
>
> Remember that Markdown syntax is simple and does not cover all the rich-text features. This means that some features provided by CKEditor 5 – either native or introduced by the GHS feature – can only be presented as native HTML as they have no Markdown equivalent. Such features will be stripped in the source view below.

### Limitations and incompatibilities

> **Danger**
>
> The source editing plugin is a low-level document editing method, which allows you to directly alter the document data source. This presents incompatibilities with some editor features which highly rely on the editor mechanisms and architecture.
>
> **Please read this section carefully, and check if these problems may apply to your editor configuration.**

#### Real-time collaboration

Source editing used during real-time collaboration brings a severe risk of data loss in a way that may be difficult for a user to notice and understand.

After you switch to source editing, incoming changes performed by remote users are not reflected in the source code. When you switch back (saving the source code), **all changes done in the meantime by other users will be overwritten**.

Due to this risk, these features are not allowed to be used together by default. When both are added to the editor, it will throw an error. **You have to explicitly enable source editing mode for real-time collaboration, acknowledging this risk.**

To enable the features, set the [`sourceEditingEnhanced.allowCollaborationFeatures`](../../api/module_source-editing-enhanced_sourceeditingenhancedconfig-SourceEditingEnhancedConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Comments and track changes

The comments and track changes features use markers to mark affected parts of the document.

In the source editing mode, it is possible for a user to modify these markers’ boundaries. The user can change the range of a comment or tracked change, or remove them. This presents a potential problem related to users permissions.

The editor will show a warning in the browser’s console when these plugins and source editing plugin are used together.

To turn off the warning, set the [`sourceEditingEnhanced.allowCollaborationFeatures`](../../api/module_source-editing-enhanced_sourceeditingenhancedconfig-SourceEditingEnhancedConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Support for various HTML elements

The editor will only save changes made to the document data source if it “understands” them. It means one of the loaded plugins must recognize the given syntax (HTML or Markdown). Any syntax unsupported by the editor will be filtered out upon save.

For example, if the editor does not have the [horizontal line](#ckeditor5/latest/features/horizontal-line.html) plugin loaded, the `<hr>` tag added in the document source will be removed upon exit from the source editing mode.

To avoid that, make sure that your editor configuration has all the necessary plugins that handle various HTML tags.

In many cases, to enable advanced modifications through the source editing, you might need to enable the [HTML embed](#ckeditor5/latest/features/html/html-embed.html) feature and the [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) feature, or write a plugin that will enable a given HTML tag or attribute support.

#### HTML normalization

When the editor reads the source data, it converts the data to a normalized, high-level, abstract data model structure, on which it operates. This structure differs from the HTML or Markdown code.

Note, that the same document “state” may be described using HTML in various ways.

For example, `<strong><em>Foo</em></strong>` and `<i><b>Foo</b></i>` both produce the “**_Foo_**” text with bold and italic styling. Both will be represented the same when loaded to the internal editor data model.

When the editor data model is later converted back to the document source data, it will be normalized regardless of the original input. In effect, `<i><b>Foo</b></i>` will eventually become `<strong><em>Foo</em></strong>`.

This limitation is a direct consequence of the core editor architecture and cannot be worked around. Although it is possible to change the editor’s final output, the input data will always be normalized to that output format.

#### Revision history

Saving the modified document source is internally executed through replacing the old data with the new one. As a consequence, it will be represented in revision history as a total replace change (insertion + deletion).

The editor will show a warning in the browser’s console when revision history and source editing are loaded together.

To turn the warning off, set the [`sourceEditingEnhanced.allowCollaborationFeatures`](../../api/module_source-editing-enhanced_sourceeditingenhancedconfig-SourceEditingEnhancedConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Restricted editing

Restricted editing is not enforced in the source editing mode. The user will be able to edit any part of the document, as well as remove the markers that mark the boundaries of restricted areas.

The editor will show a warning in the browser’s console when restricted editing and source editing are loaded together.

#### Custom themes

Using custom `CodeMirror` themes is **not supported** with [CKEditor 5 installed from CDN](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html--installing-ckeditor-5-from-cdn).

The CDN build already includes a bundled version of `CodeMirror` and its dependencies. If you attempt to use a custom theme and install CodeMirror-related packages manually, some dependencies will be loaded **twice** — once from the CDN bundle and once from your own packages. This results in version mismatches, duplicated internal modules, and runtime errors.

### Related features

There are other source-related CKEditor 5 features you may want to check:

* [Source editing support](#ckeditor5/latest/features/source-editing/source-editing.html) – The open-source source editing feature for CKEditor 5. Limited to the [classic editor](#ckeditor5/latest/getting-started/setup/editor-types.html--classic-editor). only, does not support syntax highlighting, keyboard shortcuts, autocompletion, or themes.
* [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) – Allows you to enable HTML features (elements, attributes, classes, styles) that are not supported by other dedicated CKEditor 5 plugins.
* [Full page HTML](#ckeditor5/latest/features/html/full-page-html.html) – Allows using CKEditor 5 to edit entire HTML pages, from `<html>` to `</html>`, including the page metadata.
* [HTML embed](#ckeditor5/latest/features/html/html-embed.html) – Allows embedding an arbitrary HTML snippet in the editor.
* [Markdown output](#ckeditor5/latest/features/markdown.html) – Allows for Markdown output instead of HTML output.

### Common API

The [`SourceEditingEnhanced`](../../api/module_source-editing-enhanced_sourceeditingenhanced-SourceEditingEnhanced.html) plugin registers:

* The `'sourceEditingEnhanced'` UI button component.
* The `'editSource'` command implemented by [`EditSourceCommand`](../../api/module_source-editing-enhanced_ui_editsourcecommand-EditSourceCommand.html).

You can execute the command using the [`editor.execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Open the "Edit source" modal window.
editor.execute( 'editSource' );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-source-editing>.

<a id="ckeditor5/latest/features/source-editing/source-editing.html">source file: "ckeditor5/latest/features/source-editing/source-editing.html"</a>

## Source code editing

The source editing feature lets you view and edit the source of your document. This is the basic, open-source source code editing feature, only available for the Classic Editor type. You can also try the more advanced, premium [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) plugin that provides the functionality in a handy modal window with syntax highlighting and more in all editor types.

### Demo

Use the editor below to see the source editing plugin in action. Toggle the source editing mode and make some changes in the HTML code (for example, add a new paragraph or an ordered list). Then leave the source editing mode and see that the changes are present in the document content.

You can also use one of the many CKEditor 5 features available in the toolbar and check how they render in the HTML source. Notice the collapsible table of contents, available thanks to the [general HTML support](#ckeditor5/latest/features/html/general-html-support.html) feature. The feature introduces HTML elements not yet covered by the official plugins.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, SourceEditing } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ SourceEditing, /* ... */ ],
		toolbar: [ 'sourceEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, SourceEditing } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SourceEditing, /* ... */ ],
		toolbar: [ 'sourceEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

To utilize the Markdown source editing mode just add the [Markdown output](#ckeditor5/latest/features/markdown.html) plugin to the editor.

**NPM**

```js
import { ClassicEditor, SourceEditing, Markdown } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ SourceEditing, Markdown, /* ... */ ],
		toolbar: [ 'sourceEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, SourceEditing, Markdown } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SourceEditing, Markdown, /* ... */ ],
		toolbar: [ 'sourceEditing', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Limitations and incompatibilities

#### Real-time collaboration

Source editing used during real-time collaboration brings a severe risk of data loss in a way that may be difficult for a user to notice and understand.

To enable the features, set the [`sourceEditing.allowCollaborationFeatures`](../../api/module_source-editing_sourceeditingconfig-SourceEditingConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Comments and track changes

The comments and track changes features use markers to mark affected parts of the document.

The editor will show a warning in the browser’s console when these plugins and source editing plugin are used together.

To turn off the warning, set the [`sourceEditing.allowCollaborationFeatures`](../../api/module_source-editing_sourceeditingconfig-SourceEditingConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Support for various HTML elements

The editor will save changes made to the document data source only if it “understands” them. It means only when one of the loaded plugins recognizes the given syntax (HTML or Markdown). All syntax unsupported by the editor will be filtered out.

To avoid that, make sure that your editor configuration has all the necessary plugins that handle various HTML tags.

#### HTML normalization

When the editor reads the source data, it converts the data to a normalized, high-level abstract data model structure, on which it operates. This structure differs from the HTML or Markdown code.

Note, that the same document “state” may be described using HTML in various ways.

For example, `<strong><em>Foo</em></strong>` and `<i><b>Foo</b></i>` both produce the “Foo” text with bold and italic styling. Both will be represented the same when loaded to the internal editor data model.

When the editor data model is later converted back to the document source data, it will be normalized regardless of what the original input was. In effect, `<i><b>Foo</b></i>` will eventually become `<strong><em>Foo</em></strong>`.

This limitation is a direct consequence of the core editor architecture and cannot be worked around. Although it is possible to change the editor final output, the input data will always be normalized to that output format.

#### Impact on the editor UI

Editor features rely on high-level editor API which cannot be used when the source editing is active. Due to that, when you switch to the source editing mode, all toolbar buttons become disabled and all dialog windows are closed.

The editable element is also hidden and replaced with a `<textarea>` in the DOM. If you set the height of the editor with CSS, you need an extra rule to keep the same height in the source editing mode. Refer to [this CKEditor 5 How-to question](#ckeditor5/latest/framework/how-tos.html--how-to-set-the-height-of-ckeditor-5) for details.

#### Revision history

The editor will show a warning in the browser’s console when revision history and source editing are loaded together.

To turn the warning off, set the [`sourceEditing.allowCollaborationFeatures`](../../api/module_source-editing_sourceeditingconfig-SourceEditingConfig.html#member-allowCollaborationFeatures) configuration flag to `true`.

#### Restricted editing

Restricted editing is not enforced in the source editing mode. The user will be able to edit any part of the document, as well as remove the markers that mark the boundaries of restricted areas.

The editor will show a warning in the browser’s console when restricted editing and source editing are loaded together.

### Markdown source view

### Related features

There are other source-related CKEditor 5 features you may want to check:

* [Enhanced source code editing](#ckeditor5/latest/features/source-editing/source-editing-enhanced.html) – Allows for viewing and editing the source code of the document in a handy modal window (compatible with all editor types) with syntax highlighting, autocompletion and more.
* [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) – Allows you to enable HTML features (elements, attributes, classes, styles) that are not supported by other dedicated CKEditor 5 plugins.
* [Full page HTML](#ckeditor5/latest/features/html/full-page-html.html) – Allows using CKEditor 5 to edit entire HTML pages, from `<html>` to `</html>`, including the page metadata.
* [HTML embed](#ckeditor5/latest/features/html/html-embed.html) – Allows embedding an arbitrary HTML snippet in the editor.
* [Markdown output](#ckeditor5/latest/features/markdown.html) – Allows for Markdown output instead of HTML output.

### Common API

The [`SourceEditing`](../../api/module_source-editing_sourceediting-SourceEditing.html) plugin registers:

* The `'sourceEditing'` UI button component.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-source-editing>.

<a id="ckeditor5/latest/features/special-characters.html">source file: "ckeditor5/latest/features/special-characters.html"</a>

## Special characters

The special characters feature lets you insert **mathematical operators**, **currency symbols**, **punctuation**, **graphic symbols** (such as arrows or bullets), or Unicode letters typically not accessible from the keyboard (such as **umlauts** or **other diacritics**).

### Demo

Use the special characters toolbar button in the editor below to open a [configurable](#ckeditor5/latest/features/special-characters.html--configuration) panel with a table of selectable special characters.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
// Core plugin provides the API for the management of special characters and their categories.
// The other provide a basic set of special characters.
import { ClassicEditor, SpecialCharacters, SpecialCharactersEssentials } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ SpecialCharacters, SpecialCharactersEssentials, /* ... */ ],
		toolbar: [ 'specialCharacters', /* ... */ ],
		specialCharacters: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
// Core plugin provides the API for the management of special characters and their categories.
// The other provide a basic set of special characters.
const { ClassicEditor, SpecialCharacters, SpecialCharactersEssentials } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ SpecialCharacters, SpecialCharactersEssentials, /* ... */ ],
		toolbar: [ 'specialCharacters', /* ... */ ],
		specialCharacters: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

By default, a few categories of special characters have been defined. You can easily customize the special characters available in your WYSIWYG editor installation by adding new categories, extending the existing ones, or removing them altogether.

#### Adding a new category

You can define a new special characters category using the [`SpecialCharacters#addItems()`](../api/module_special-characters_specialcharacters-SpecialCharacters.html#function-addItems) function.

For example, the following plugin adds the “Emoji” category to the special characters dropdown.

```js
function SpecialCharactersEmoji( editor ) {
    editor.plugins.get( 'SpecialCharacters' ).addItems( 'Emoji', [
        { title: 'smiley face', character: '😊' },
        { title: 'rocket', character: '🚀' },
        { title: 'wind blowing face', character: '🌬️' },
        { title: 'floppy disk', character: '💾' },
        { title: 'heart', character: '❤️' }
    ], { label: 'Emoticons' } );
}

ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [
            SpecialCharacters, SpecialCharactersEssentials, SpecialCharactersEmoji,
        ],
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

After adding the above plugin to the editor configuration, the new category will become available in the special characters dropdown.

> **Note**
>
> The title of a special character must be unique across the entire special characters set.

> **Note**
>
> The third argument of the [`SpecialCharacters#addItems()`](../api/module_special-characters_specialcharacters-SpecialCharacters.html#function-addItems) method is optional. You can use it to specify a label displayed as a category name. It is useful when your editor uses a language other than English. Check out the [UI language guide](#ckeditor5/latest/getting-started/setup/ui-language.html) to learn more.

Below you can see a demo based on the example shown above. Use the special characters toolbar button and then select “Emoticons” from the dropdown. This will let you insert an emoji into the content.

> **Note**
>
> You may also check out the ready-to-use [Emoji feature](#ckeditor5/latest/features/emoji.html) in order to quickly insert desired emoji into the document.

#### Adding characters to an existing category

By using the [`SpecialCharacters#addItems()`](../api/module_special-characters_specialcharacters-SpecialCharacters.html#function-addItems) function you can also add new special characters to an existing category.

```js
function SpecialCharactersExtended( editor ) {
    editor.plugins.get( 'SpecialCharacters' ).addItems( 'Mathematical', [
        { title: 'alpha', character: 'α' },
        { title: 'beta', character: 'β' },
        { title: 'gamma', character: 'γ' }
    ] );
}

ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [
            SpecialCharacters, SpecialCharactersEssentials, SpecialCharactersExtended,
        ],
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> The title of a special character must be unique across the entire special characters set.

Below you can see a demo based on the example shown above. Use the special characters toolbar button and then select “Mathematical” from the dropdown. You will see that the category now contains the additional Greek letters introduced by the configuration above.

#### Removing categories

The special characters feature exposes each category as a separate plugin. While the [`SpecialCharactersEssentials`](../api/module_special-characters_specialcharactersessentials-SpecialCharactersEssentials.html) plugin can be used to conveniently include all of them, you can customize the category list by adding individual plugins with particular categories.

By default, the `@ckeditor/ckeditor5-special-characters` package provides special characters grouped into the following categories:

* [`SpecialCharactersArrows`](../api/module_special-characters_specialcharactersarrows-SpecialCharactersArrows.html) – Arrows special characters.
* [`SpecialCharactersCurrency`](../api/module_special-characters_specialcharacterscurrency-SpecialCharactersCurrency.html) – Currency special characters.
* [`SpecialCharactersLatin`](../api/module_special-characters_specialcharacterslatin-SpecialCharactersLatin.html) – Latin special characters.
* [`SpecialCharactersMathematical`](../api/module_special-characters_specialcharactersmathematical-SpecialCharactersMathematical.html) – Mathematical special characters.
* [`SpecialCharactersText`](../api/module_special-characters_specialcharacterstext-SpecialCharactersText.html) – Text special characters.
* [`SpecialCharactersEssentials`](../api/module_special-characters_specialcharactersessentials-SpecialCharactersEssentials.html) – Combines the plugins listed above.

For example, you can limit the categories to “Mathematical” and “Currency” only by picking the [`SpecialCharactersMathematical`](../api/module_special-characters_specialcharactersmathematical-SpecialCharactersMathematical.html) and [`SpecialCharactersCurrency`](../api/module_special-characters_specialcharacterscurrency-SpecialCharactersCurrency.html) plugins, like so:

**NPM**

```js
import { ClassicEditor, SpecialCharacters, SpecialCharactersCurrency, SpecialCharactersMathematical } from 'ckeditor5';

ClassicEditor
	.create( {
		// ... Other configuration options ...
		plugins: [
			SpecialCharacters, SpecialCharactersCurrency, SpecialCharactersMathematical,
		],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, SpecialCharacters, SpecialCharactersCurrency, SpecialCharactersMathematical } = CKEDITOR;

Below you can see a demo based on the example shown above. After clicking the special characters toolbar button , you can see that it contains fewer categories compared to the other editors on this page.

#### Ordering categories

The order of categories in the UI is determined by the order in which they were registered. However, depending on the context in which you use the editor, you might want to change this order, to make it easier to access frequently used characters.

The categories order can be customized using the [`order`](../api/module_special-characters_specialcharactersconfig-SpecialCharactersConfig.html#member-order) array.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        plugins: [ SpecialCharacters, SpecialCharactersEssentials, ... ],
        specialCharacters: {
            order: [
                'Text',
                'Latin',
                'Mathematical',
                'Currency',
                'Arrows'
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Common API

The [`SpecialCharacters`](../api/module_special-characters_specialcharacters-SpecialCharacters.html) plugin registers the UI button component (`'specialCharacters'`).

### Contribute

The source code of the feature is available at GitHub in <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-special-characters>.

<a id="ckeditor5/latest/features/spelling-and-grammar-checking.html">source file: "ckeditor5/latest/features/spelling-and-grammar-checking.html"</a>

## Spelling, grammar, and punctuation checking

[WProofreader SDK](https://webspellchecker.com/wsc-proofreader) is an AI-driven, multi-language text correction tool. Spelling, grammar, and punctuation suggestions appear on hover as you type or in a separate dialog aggregating all mistakes and replacement suggestions in one place.

> **Note**
>
> This is a premium add-on that is a part of CKEditor Custom Plan, and delivered by our partner, [WebSpellChecker](https://webspellchecker.com/). [Choose the Custom Plan](https://ckeditor.com/pricing/) to enable it.

### Demo

Use the toolbar button to test the spell and grammar check feature in the editor below.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

The WProofreader badge in the bottom-right corner shows you the total number of mistakes detected. Hover an underlined word to display the WProofreader suggestions for any of the spelling and grammar mistakes found. The suggestion card allows the user to use the feature on the go. If you want to see an overview of all mistakes found, click the “Proofread in dialog” option in the toolbar dropdown. It will invoke a detached floating dialog, which is easy to navigate and perfect for dedicated proofreading sessions.

You can access the WProofreader settings from the toolbar, too. Set the primary language, create a spelling dictionary, and tweak some additional proofreading settings.

### Additional feature information

You can fine-tune WProofreader via the dedicated settings menu. Choose a primary language from a set of available ones. Create and manage additional custom dictionaries. You can add words to the user dictionary directly from the suggestion card, too. If needed, you can turn off the spell checker and enable it again with a single click.

### Multi-language support

The [text part language](#ckeditor5/latest/features/language.html) feature lets the user set different languages to different portions of the content. The spell and grammar check feature offers full support for multilingual content. If you set the WProofreader language to Auto Detect (or set the `auto` language in the configuration), the feature will automatically recognize the language for a given sentence. It will then suggest spelling and grammar corrections specifically for that language, as shown in the demo above.

### Check types

WProofreader checks texts for spelling, grammar, and punctuation mistakes. The autodetect feature facilitates the correction of multilingual texts. Users do not have to manually switch languages to proofread documents with mixed language. Handy spelling autocorrect validates user texts on the fly. Autocomplete suggestions for English make the proofreading process fast and smooth. You can accept the predictive text with a right `→` arrow key.

### Supported languages and dictionaries

#### Language support

The most popular languages used with WProofreader include: American English, Australian English, Arabic, Brazilian Portuguese, British English, Canadian English, Canadian French, Danish, Dutch, Finnish, French, German, Greek, Hebrew, Italian, Indonesian, Norwegian Bokmål, Norwegian Nynorsk, Portuguese, Spanish, Swedish, Turkish, and Ukrainian.

There are more languages available from the WebSpellChecker site. Grammar checking is available for over 20 languages.

The AI-driven tools approach for English, German, and Spanish is a recent addition to the software. It offers a far better checking quality and generates proofreading suggestions based on the context of a sentence. It provides more suitable suggestions that address mistakes with 3 times the accuracy compared to a traditional mechanism.

Here you can check the [full list of supported languages](https://webspellchecker.com/supported-languages/).

#### Specialized dictionaries

Apart from the language dictionaries, WebSpellChecker offers two specialized dictionaries: medical and legal.

#### Custom dictionaries

You can use custom dictionaries in two ways.

One is the **user-level dictionary** that you can expand during regular use by adding new words. This is a perfect solution for users working on specific content that may contain slang or professional jargon.

The other is the so-called **company-level dictionary**. These pre-made dictionaries can be uploaded by system administrators or CKEditor 5 integrators and made available across the company, accessible for all users. This way you can share all the benefits of a user-generated dictionary among the team, making the proofreading process more structured and controlled.

### Accessibility

The WProofreader UI is designed and oriented toward comfort and ease of use. The proofreading floating dialog can be moved around, addressing the needs of left-handed editors and right-to-left language users. The clear, simple design is more readable for users with vision impairments. You can also navigate and operate the dialog with a keyboard, eliminating the need to use a mouse or another pointing device.

The spell and grammar check is compliant with Web Content Accessibility Guidelines (WCAG) 2.1 and Section 508 accessibility standards.

### Installation

WProofreader is delivered as a CKEditor 5 plugin, so you can combine it into an editor preset just like other features. To add this feature to your rich-text editor, install the [`@webspellchecker/wproofreader-ckeditor5`](https://www.npmjs.com/package/@webspellchecker/wproofreader-ckeditor5) package:

```
npm install --save @webspellchecker/wproofreader-ckeditor5
```

Then, add it to your plugin list and the toolbar configuration. Please note, that unlike native CKEditor 5 plugins, this one is imported from its own package. Also, that this import is different than the standard CKEditor 5 plugins import:

```js
import { ClassicEditor } from 'ckeditor5';
import { WProofreader } from '@webspellchecker/wproofreader-ckeditor5';

import '@webspellchecker/wproofreader-ckeditor5/index.css';

ClassicEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
        plugins: [ WProofreader, /* ...], */ ],
        toolbar: [ 'wproofreader', /* ... */ ],
        wproofreader: {
            // Configuration.
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

At this step, you need to provide a proper configuration. You can use WProofreader either as a [cloud solution](#ckeditor5/latest/features/spelling-and-grammar-checking.html--wproofreader-cloud) or [hosted on your server](#ckeditor5/latest/features/spelling-and-grammar-checking.html--wproofreader-on-premises) (on-premises or in a private cloud).

#### WProofreader Cloud

After signing up for a [trial or paid version](https://ckeditor.com/contact/), you will receive your service ID on your email. You can use it to activate the service.

Add the following configuration to your editor:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        wproofreader: {
            serviceId: 'your-service-ID',
            srcUrl: 'https://svc.webspellchecker.net/spellcheck31/wscbundle/wscbundle.js'
        }
    } )
```

Refer to the [official documentation](https://github.com/WebSpellChecker/wproofreader-ckeditor5#install-instructions) for more details about the cloud setup and available configuration options.

#### WProofreader on-premises

After signing up for a [trial or paid version](https://ckeditor.com/contact/), you will receive access to the WebSpellChecker on-premises package to install it on your server.

You will need to add the following configuration to your editor:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        wproofreader: {
            serviceProtocol: 'https',
            serviceHost: 'localhost',
            servicePort: '443',
            servicePath: 'virtual_directory/api/',
            srcUrl: 'https://host_name/virtual_directory/wscbundle/wscbundle.js'
        }
    } )
```

Refer to the [official documentation](https://github.com/WebSpellChecker/wproofreader-ckeditor5#install-instructions) for more details about the server setup and available configuration options.

### Configuration

WProofreader configuration is set inside the CKEditor 5 configuration in the `wproofreader` object. Refer to the [WProofreader API](https://webspellchecker.com/docs/api/wscbundle/Options.html) for further information.

### Contribute

You can report issues and request features in the [official WProofreader for CKEditor 5 repository](https://github.com/WebSpellChecker/wproofreader-ckeditor5/issues).

<a id="ckeditor5/latest/features/style.html">source file: "ckeditor5/latest/features/style.html"</a>

## Styles

The style feature lets you apply pre-configured styles to elements in your content. It works by adding one or more CSS classes to an element to change its appearance or add semantic information.

### Demo

Use the demo below to test the styles feature. Select a passage or a header and try applying various styles.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

Configuration of the above demo

> **Note**
>
> See the [Configuration](#ckeditor5/latest/features/style.html--configuration) section to learn more about the configuration format.

The editor configuration:

```js
// ...
style: {
    definitions: [
        {
            name: 'Article category',
            element: 'h3',
            classes: [ 'category' ]
        },
        {
            name: 'Title',
            element: 'h2',
            classes: [ 'document-title' ]
        },
        {
            name: 'Subtitle',
            element: 'h3',
            classes: [ 'document-subtitle' ]
        },
        {
            name: 'Info box',
            element: 'p',
            classes: [ 'info-box' ]
        },
        {
            name: 'Side quote',
            element: 'blockquote',
            classes: [ 'side-quote' ]
        },
        {
            name: 'Marker',
            element: 'span',
            classes: [ 'marker' ]
        },
        {
            name: 'Spoiler',
            element: 'span',
            classes: [ 'spoiler' ]
        },
        {
            name: 'Code (dark)',
            element: 'pre',
            classes: [ 'fancy-code', 'fancy-code-dark' ]
        },
        {
            name: 'Code (bright)',
            element: 'pre',
            classes: [ 'fancy-code', 'fancy-code-bright' ]
        }
    ]
},
// ...
```

The style sheet:

```css
@import url('https://fonts.googleapis.com/css2?family=Bebas+Neue&family=PT+Serif:ital,wght@0,400;0,700;1,400&display=swap');

.ck.ck-content {
    font-family: 'PT Serif', serif;
    font-size: 16px;
    line-height: 1.6;
    padding: 2em;
}

.ck-content .ck-horizontal-line {
    margin-bottom: 1em;
}

.ck.ck-content hr {
    width: 100px;
    border-top: 1px solid #aaa;
    height: 1px;
    margin: 1em auto;
}

.ck.ck-content h3.category {
    font-family: 'Bebas Neue';
    font-size: 20px;
    font-weight: bold;
    color: #d1d1d1;
    letter-spacing: 10px;
    margin: 0;
    padding: 0;
}

.ck.ck-content h2.document-title {
    font-family: 'Bebas Neue';
    font-size: 50px;
    font-weight: bold;
    margin: 0;
    padding: 0;
    border: 0;
}

.ck.ck-content h3.document-subtitle {
    font-size: 20px;
    color: #e91e63;
    margin: 0 0 1em;
    font-weight: normal;
    padding: 0;
}

.ck.ck-content p.info-box {
    --background-size: 30px;
    --background-color: #e91e63;
    padding: 1.2em 2em;
    border: 1px solid var(--background-color);
    background: linear-gradient(135deg, var(--background-color) 0%, var(--background-color) var(--background-size), transparent var(--background-size)), linear-gradient(135deg, transparent calc(100% - var(--background-size)), var(--background-color) calc(100% - var(--background-size)), var(--background-color));
    border-radius: 10px;
    margin: 1.5em 2em;
    box-shadow: 5px 5px 0 #ffe6ef;
}

.ck.ck-content blockquote.side-quote {
    font-family: 'Bebas Neue';
    font-style: normal;
    float: right;
    width: 35%;
    position: relative;
    border: 0;
    overflow: visible;
    z-index: 1;
    margin-left: 1em;
}

.ck.ck-content blockquote.side-quote::before {
    content: "“";
    position: absolute;
    top: -37px;
    left: -10px;
    display: block;
    font-size: 200px;
    color: #e7e7e7;
    z-index: -1;
    line-height: 1;
}

.ck.ck-content blockquote.side-quote p {
    font-size: 2em;
    line-height: 1;
}

.ck.ck-content blockquote.side-quote p:last-child:not(:first-child) {
    font-size: 1.3em;
    text-align: right;
    color: #555;
}

.ck.ck-content span.marker {
    background: yellow;
}

.ck.ck-content span.spoiler {
    background: #000;
    color: #000;
}

.ck.ck-content span.spoiler:hover {
    background: #000;
    color: #fff;
}

.ck.ck-content pre.fancy-code {
    border: 0;
    margin-left: 2em;
    margin-right: 2em;
    border-radius: 10px;
}

.ck.ck-content pre.fancy-code::before {
    content: "";
    display: block;
    height: 13px;
    background: url(data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA1NCAxMyI+CiAgPGNpcmNsZSBjeD0iNi41IiBjeT0iNi41IiByPSI2LjUiIGZpbGw9IiNGMzZCNUMiLz4KICA8Y2lyY2xlIGN4PSIyNi41IiBjeT0iNi41IiByPSI2LjUiIGZpbGw9IiNGOUJFNEQiLz4KICA8Y2lyY2xlIGN4PSI0Ny41IiBjeT0iNi41IiByPSI2LjUiIGZpbGw9IiM1NkM0NTMiLz4KPC9zdmc+Cg==);
    margin-bottom: 8px;
    background-repeat: no-repeat;
}

.ck.ck-content pre.fancy-code-dark {
    background: #272822;
    color: #fff;
    box-shadow: 5px 5px 0 #0000001f;
}

.ck.ck-content pre.fancy-code-bright {
    background: #dddfe0;
    color: #000;
    box-shadow: 5px 5px 0 #b3b3b3;
}
```

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Style, GeneralHtmlSupport } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Style, GeneralHtmlSupport, /* ... */ ],
		toolbar: [ 'style', /* ... */ ],
		style: {
			// Configuration.
		},
		htmlSupport: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Style, GeneralHtmlSupport } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Style, GeneralHtmlSupport, /* ... */ ],
		toolbar: [ 'style', /* ... */ ],
		style: {
			// Configuration.
		},
		htmlSupport: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Important**
>
> The style feature requires the [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) feature to work properly.

### Configuration

Configuring the styles feature takes two steps. First, you need to define the styles in the configuration file, for example:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        style: {
            definitions: [
                {
                    name: 'Article category',
                    element: 'h3',
                    classes: [ 'category' ]
                },
                {
                    name: 'Info box',
                    element: 'p',
                    classes: [ 'info-box' ]
                },
            ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Then, define the corresponding CSS styles for the document:

```css
.ck.ck-content h3.category {
    font-family: 'Bebas Neue';
    font-size: 20px;
    font-weight: bold;
    color: #d1d1d1;
    letter-spacing: 10px;
    margin: 0;
    padding: 0;
}

.ck.ck-content p.info-box {
    padding: 1.2em 2em;
    border: 1px solid #e91e63;
    border-left: 10px solid #e91e63;
    border-radius: 5px;
    margin: 1.5em;
}
```

The editor will automatically distinguish text and block styles and group them in the dropdown.

### Known issues

At present, the style feature may clash with other features that bring in similar content (like headings). Problems with overlapping styles applied to the same element may also occur.

### Related features

Check out also these CKEditor 5 features to gain better control over your content style and format:

* [Basic text styles](#ckeditor5/latest/features/basic-styles.html) – Apply the most frequently used formatting such as bold, italic, underline, etc.
* [Font styles](#ckeditor5/latest/features/font.html) – Control the font [family](#ckeditor5/latest/features/font.html--configuring-the-font-family-feature), [size](#ckeditor5/latest/features/font.html--configuring-the-font-size-feature), [text or background color](#ckeditor5/latest/features/font.html--configuring-the-font-color-and-font-background-color-features).
* [Headings](#ckeditor5/latest/features/headings.html) – Divide your content into sections.
* [Format painter](#ckeditor5/latest/features/format-painter.html) – Easily copy text formatting and apply it in a different place in the edited document.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.
* [General HTML support](#ckeditor5/latest/features/html/general-html-support.html) – Enable additional HTML, such as `<style>` and `<classes>` attributes.

### Common API

The [Style](../api/module_style_style-Style.html) plugin registers:

* The `'style'` command implemented by [`StyleCommand`](../api/module_style_stylecommand-StyleCommand.html).
* The `'style'` UI dropdown.

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Applies the style to the selected content.
// Executing the command again will remove the style from the selected content.
editor.execute( 'style', { styleName: 'Article category' } );
```

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-style>.

<a id="ckeditor5/latest/features/table-of-contents.html">source file: "ckeditor5/latest/features/table-of-contents.html"</a>

## Table of contents

The table of contents feature lets you insert a widget with a list of headings (section titles) that reflects the structure of the document. The list stays up–to–date automatically as the user works on the document. Clicking a list item navigates the user to the corresponding document section.

### Demo

Create several headings in the editor and click the table of contents button in the toolbar. Change the heading text or level to see the table of contents getting updated live.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { TableOfContents } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ TableOfContents, /* ... */ ],
		toolbar: [ 'tableOfContents', /* ... */ ]
		// ...
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { TableOfContents } = CKEDITOR_PREMIUM_FEATURES;

By default, the table of contents feature takes care of managing the heading IDs and creating proper links with a dedicated `href` attribute. The output data produced by this feature ensures that clicking a link in a table of contents will scroll to the corresponding heading in the content.

#### Activating the feature

### Related features

Here are some more CKEditor 5 features that can help you navigate the content of the editor:

* [Document outline](#ckeditor5/latest/features/document-outline.html) – Display the list of sections (headings) of the document next to the editor.
* [Content minimap](#ckeditor5/latest/features/minimap.html) – Navigate the document using a miniature overview map placed next to the editor.
* [Pagination](#ckeditor5/latest/features/pagination/pagination.html) – See the live preview of the document’s page breaks and quickly navigate between pages.

### Common API

The [`TableOfContents`](../api/module_document-outline_tableofcontents-TableOfContents.html) plugin registers:

* The `'tableOfContents'` UI button component.
* The `'insertTableOfContents'` command implemented by [`TableOfContentsCommand`](../api/module_document-outline_tableofcontents_tableofcontentscommand-TableOfContentsCommand.html).

You can execute the command using the [`editor.execute()`](../api/module_core_editor_editor-Editor.html#function-execute) method:

```js
// Insert the table of contents.
editor.execute( 'insertTableOfContents' );
```

<a id="ckeditor5/latest/features/tables/layout-tables.html">source file: "ckeditor5/latest/features/tables/layout-tables.html"</a>

## Layout tables

Layout tables are used to structure web page content spatially rather than for presenting tabular data. They allow integrators to create multi-column designs and precise positioning of elements on a page. This kind of functionality may be handy, for example, when preparing newsletter content. You can switch between [content tables](#ckeditor5/latest/features/tables/tables.html) and layout tables by using the table toggling feature.

### Table types comparison

The CKEditor 5 table feature offers several approaches and plugins responsible for the execution of tables. These include:

* [Regular content tables](#ckeditor5/latest/features/tables/tables.html) – Content tables provide the basic table experience for presentation of tabular data.
* [Table layout](#ckeditor5/latest/features/tables/layout-tables.html) – Layout tables are used to structure the content spatially rather than present content. They allow for creating multi-column designs and precise positioning of elements on a page.
* [Plain table output](../../api/module_table_plaintableoutput-PlainTableOutput.html) – This plugin strips the `<figure>` tag from the table data. It is basically an email client compatibility feature.

|                  | Regular table                                 | Layout table                                       | Plain table output                                  |
| ---------------- | --------------------------------------------- | -------------------------------------------------- | --------------------------------------------------- |
| Usage            | Used for presenting tabular data              | Used for creating layouts and multi-column designs | Stripped of `<figure>` tags for email compatibility |
| Purpose          | Rich formatting and tabular data presentation | Focused on content positioning and structure       | Simplified output for maximum interoperability      |
| Setup            | Default table type in CKEditor 5              | Available through toggling or direct insertion     | Available as an optional plugin                     |
| Markup influence | Affects editing view and output data          | Affects editing view and output data               | Affects only output data                            |

### Demo

Check the editor below to see the layout tables plugin in action. Use the layout table toolbar button to insert a new layout table.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Table toggling

There are several table types available in CKEditor 5. To switch between these different table modes, you can use the table toggling feature. It allows users to change the type of an existing table by clicking it and selecting the desired table type. This enables seamless switching between presentation-focused content tables and layout-oriented tables without recreating the structure from scratch.

When a table is selected, you can toggle its type in one of two ways:

1. If the [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) plugin is enabled, the table properties button will include a “Table type” dropdown option that allows switching between regular content tables and layout tables.

2. If the [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) plugin is not available, you can use the dedicated `tableType` toolbar button to change the table type.

Switching between table types preserves the content while adjusting the table’s behavior and styling to match its new purpose. Layout tables focus on spatial arrangement and design, while content tables emphasize data presentation.

> **Warning**
>
> Changing a regular table to a layout table may result in data loss. Table captions will be removed when converting to a layout table, as layout tables do not support them.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Table, TableLayout } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

#### Configuring the preferred type for loading external tables.

By default, external tables are loaded using internal heuristics. This can be configured by setting the preferred table type for loading all external tables by setting the [`config.table.tableLayout.preferredExternalTableType`](../../api/module_table_tableconfig-TableLayoutConfig.html#member-preferredExternalTableType) option to `content` or `layout`.

**NPM**

```js
import { ClassicEditor, Table, TableLayout } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout /* ... */ ],
		table: {
			tableLayout :{
				preferredExternalTableType: 'content' // or 'layout'
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout /* ... */ ],
		table: {
			tableLayout :{
				preferredExternalTableType: 'content' // or 'layout'
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Stripping the `<figure>` wrapper from content tables

By default, the `<figure>` wrapper is preserved on content tables. To strip the `<figure>` element, set the [`config.table.tableLayout.stripFigureFromContentTable`](../../api/module_table_tableconfig-TableLayoutConfig.html#member-stripFigureFromContentTable) option to `true`.

**NPM**

```js
import { ClassicEditor, Table, TableLayout } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout /* ... */ ],
		table: {
			tableLayout :{
				stripFigureFromContentTable: true // or false
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout /* ... */ ],
		table: {
			tableLayout :{
				stripFigureFromContentTable: true // or false
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Configuring the table toggle feature

To configure the table toggling feature, you have several options:

1. Include the [`TableLayout`](../../api/module_table_tablelayout-TableLayout.html) plugin in your editor setup to enable toggling between table types.
2. Add the `tableType` button to your table content toolbar if you want a dedicated button for toggling.
3. For advanced UI integration scenarios, include both [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) and [`TableToolbar`](../../api/module_table_tabletoolbar-TableToolbar.html) plugins, which will add the table type option to the table properties dropdown.

The table type can also be set programmatically through the editor’s API, making it suitable for integration with external controls or automated workflows.

#### Configuring table toggle with `TableProperties`

When the [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) plugin is available, table type options will be integrated into the table properties dropdown:

**NPM**

```js
import { ClassicEditor, Table, TableLayout, TableProperties, TableToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout, TableProperties, TableToolbar, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
		table: {
			contentToolbar: [ 'tableColumn', 'tableRow', 'mergeTableCells', 'tableProperties' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout, TableProperties, TableToolbar } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout, TableProperties, TableToolbar, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
		table: {
			contentToolbar: [ 'tableColumn', 'tableRow', 'mergeTableCells', 'tableProperties' ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

This will add table toggling button to the table toolbar:

#### Configuring table toggle without `TableProperties`

If the `TableProperties` plugin is not available, you can use the dedicated `tableType` button in the content toolbar to change table types:

**NPM**

```js
import { ClassicEditor, Table, TableLayout, TableToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout, TableToolbar, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
		table: {
			contentToolbar: [ 'tableColumn', 'tableRow', 'mergeTableCells', 'tableType', /* ... */  ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout, TableToolbar } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout, TableToolbar, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', /* ... */ ],
		table: {
			contentToolbar: [ 'tableColumn', 'tableRow', 'mergeTableCells', 'tableType', /* ... */  ]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Configuring table toggle in the main editor toolbar

You can configure the main editor toolbar to use the content and layout tables selector dropdown. This is handy if for some reason you do not want to use the table toolbar in your implementation.

**NPM**

```js
import { ClassicEditor, Table, TableLayout } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableLayout, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', 'tableType', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableLayout } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableLayout, /* ... */ ],
		toolbar: [ 'insertTable', 'insertTableLayout', 'tableType', /* ... */ ]
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

This will add table toggling button to the main editor toolbar:

> **Note**
>
> Please note that the layout toggle button does not insert new tables, it just toggles the type. You still need to configure the table insertion buttons, as shown above.

### Related features

There are other CKEditor 5 features you may want to check:

* [Email editing](#ckeditor5/latest/features/email-editing/email.html) – The email editing solution is a set of tools aimed at making the email composition a better and more effective experience.
* [Email configuration helper](#ckeditor5/latest/features/email-editing/email-configuration-helper.html) – The email configuration helper plugin is the best way to start writing and editing emails.

### Common API

The [`TableLayout`](../../api/module_table_tablelayout-TableLayout.html) plugin registers the following command:

* [`TableLayoutEditing`](../../api/module_table_tablelayout_tablelayoutediting-TableLayoutEditing.html) – The layout table editing command.
* [`TableLayoutUI`](../../api/module_table_tablelayout_tablelayoutui-TableLayoutUI.html) – The layout table UI.
* [`InsertTableLayoutCommand`](../../api/module_table_commands_inserttablelayoutcommand-InsertTableLayoutCommand.html) – The `insertTableLayout` toolbar dropdown.

The [`TableLayout`](../../api/module_table_tablelayout-TableLayout.html) plugin registers the following UI components:

* The `'tableType'` button that allows changing the type of a selected table.
* The `'tableType'` command implemented by [`TableTypeCommand`](../../api/module_table_tablelayout_commands_tabletypecommand-TableTypeCommand.html).

You can execute the command using the [`editor.execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) method. The command accepts a table type value (‘content’ or ‘layout’) as an argument.

```js
// Change the selected table to a layout table.
editor.execute('tableType', 'layout' );

// Change the selected table to a content table.
editor.execute('tableType', 'content' );
```

Additionally, if the [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) plugin is loaded, the `'tableProperties'` button will be extended with a dropdown to select the table type, providing an alternative UI for changing the table type.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/tables/tables-caption.html">source file: "ckeditor5/latest/features/tables/tables-caption.html"</a>

## Table caption

The [`TableCaption`](../../api/module_table_tablecaption-TableCaption.html) plugin lets you add captions to your tables. Table captions also improve accessibility as they are recognized by screen readers.

### Demo

In the demo below, click the table caption to edit it. Once you click the caption, you can use the table toolbar button to toggle the caption on and off.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Table, TableCaption, TableToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableToolbar, TableCaption, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			contentToolbar: [
				'toggleTableCaption'
			]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableCaption, TableToolbar } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableToolbar, TableCaption, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			contentToolbar: [
				'toggleTableCaption'
			]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

By default, the table caption is placed above the table. You can change the placement by setting [`caption-side`](https://developer.mozilla.org/en-US/docs/Web/CSS/caption-side) in your [content styles](#ckeditor5/latest/getting-started/setup/css.html) for the `.ck-content .table > figcaption` style. Changing it to `caption-side: bottom` will display the caption below the table.

#### Alternative HTML configuration

By default, the plugin produces the `<figcaption>` HTML element to store the caption content. However, it is possible to use the `<caption>` element instead. To change it, use the [`useCaptionElement`](../../api/module_table_tableconfig-TableCaptionConfig.html#member-useCaptionElement) configuration option:

```js
table: {
    tableCaption: {
        useCaptionElement: true
        }
    }
```

### Common API

#### UI components

The [`TableCaption`](../../api/module_table_tablecaption-TableCaption.html) plugin registers the following UI component:

* The `toggleTableCaption` button

##### Toolbars

[`TableCaption`](../../api/module_table_tablecaption-TableCaption.html) plugin allows adding the `toggleTableCaption` item to the toolbar. It is possible to [configure](../../api/module_table_tableconfig-TableConfig.html#member-tableToolbar) its content.

#### Editor commands

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/tables/tables-installation.html">source file: "ckeditor5/latest/features/tables/tables-installation.html"</a>

## Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the `Table` plugin to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Table, TableToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableToolbar, Bold, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableToolbar } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableToolbar, Bold, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

#### Table contextual toolbar

Easily control your tables employing a dedicated toolbar.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        table: {
            contentToolbar: [ 'tableColumn', 'tableRow', 'mergeTableCells' ]
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Default table headers

To make every inserted table have `n` number of rows and columns as table headers by default, set an optional table configuration property `defaultHeadings` as follows:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        table: {
            defaultHeadings: { rows: 1, columns: 1 }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

Check the table with default headers applied to both the first row and the first column in the demo below. Click on the table and use the column properties or the row properties UI button to toggle the respective headers.

#### Enable table footers

To enable table footers, set the optional table configuration property `enableFooters` as follows:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        table: {
            enableFooters: true
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

The option also enables UI for table footers. You can set a footer row similarly to the header row by using the switch button in the table toolbar.

#### Disallow nesting tables

By default, the editor allows nesting a table inside another table’s cell.

To disallow nesting tables, you need to register an additional schema rule. It needs to be added before the data is loaded into the editor. Due to that, it is best to implement it as a plugin:

```js
function DisallowNestingTables( editor ) {
    editor.model.schema.addChildCheck( ( context, childDefinition ) => {
        if ( childDefinition.name == 'table' && Array.from( context.getNames() ).includes( 'table' ) ) {
            return false;
        }
    } );
}

// Pass it via config.extraPlugins or config.plugins:

ClassicEditor
    .create( {
        // ... Other configuration options ...
        extraPlugins: [ DisallowNestingTables ],
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

> **Note**
>
> Check the [step-by-step tutorial](#ckeditor5/latest/framework/tutorials/crash-course/editor.html) if you need more information about the technical side of this solution.

> **Note**
>
> We recommend using the official [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) for development and debugging. It will give you tons of useful information about the state of the editor, such as internal data structures, selection, commands, and much more.

### Common API

#### UI components

The [`Table`](../../api/module_table_table-Table.html) plugins register the following UI components:

| [Component](#ckeditor5/latest/getting-started/setup/toolbar.html) name | Registered by                                      |
| ---------------------------------------------------------------------- | -------------------------------------------------- |
| The `'insertTable'` dropdown                                           | [`Table`](../../api/module_table_table-Table.html) |
| The `'tableColumn'` dropdown                                           |                                                    |
| The `'tableRow'` dropdown                                              |                                                    |
| The `'mergeTableCells'` split button                                   |                                                    |

##### Toolbars

The [`TableToolbar`](../../api/module_table_tabletoolbar-TableToolbar.html) plugin introduces two balloon toolbars for tables.

* The content toolbar shows up when a table cell is selected and it is anchored to the table. It is possible to [configure](../../api/module_table_tableconfig-TableConfig.html#member-contentToolbar) its content. Normally, the toolbar contains the table-related tools such as `'tableColumn'` and `'tableRow'` dropdowns and `'mergeTableCells'` split button.
* The table toolbar shows up when the whole table is selected, for instance using the widget handler. It is possible to [configure](../../api/module_table_tableconfig-TableConfig.html#member-tableToolbar) its content.

#### Editor commands

| [Command](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--commands) name | Command class                                                                                                  | Belongs to (top–level plugin)                      |
| ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| `'insertTable'`                                                                                  | [`InsertTableCommand`](../../api/module_table_commands_inserttablecommand-InsertTableCommand.html)             | [`Table`](../../api/module_table_table-Table.html) |
| `'insertTableColumnLeft'`                                                                        | [`InsertColumnCommand`](../../api/module_table_commands_insertcolumncommand-InsertColumnCommand.html)          |                                                    |
| `'insertTableColumnRight'`                                                                       | [`InsertColumnCommand`](../../api/module_table_commands_insertcolumncommand-InsertColumnCommand.html)          |                                                    |
| `'insertTableRowAbove'`                                                                          | [`InsertRowCommand`](../../api/module_table_commands_insertrowcommand-InsertRowCommand.html)                   |                                                    |
| `'insertTableRowBelow'`                                                                          | [`InsertRowCommand`](../../api/module_table_commands_insertrowcommand-InsertRowCommand.html)                   |                                                    |
| `'removeTableColumn'`                                                                            | [`RemoveColumnCommand`](../../api/module_table_commands_removecolumncommand-RemoveColumnCommand.html)          |                                                    |
| `'removeTableRow'`                                                                               | [`RemoveRowCommand`](../../api/module_table_commands_removerowcommand-RemoveRowCommand.html)                   |                                                    |
| `'selectTableColumn'`                                                                            | [`SelectColumnCommand`](../../api/module_table_commands_selectcolumncommand-SelectColumnCommand.html)          |                                                    |
| `'selectTableRow'`                                                                               | [`SelectRowCommand`](../../api/module_table_commands_selectrowcommand-SelectRowCommand.html)                   |                                                    |
| `'setTableColumnHeader'`                                                                         | [`SetHeaderColumnCommand`](../../api/module_table_commands_setheadercolumncommand-SetHeaderColumnCommand.html) |                                                    |
| `'setTableRowHeader'`                                                                            | [`SetHeaderRowCommand`](../../api/module_table_commands_setheaderrowcommand-SetHeaderRowCommand.html)          |                                                    |
| `'mergeTableCellRight'`                                                                          | [`MergeCellCommand`](../../api/module_table_commands_mergecellcommand-MergeCellCommand.html)                   |                                                    |
| `'mergeTableCellLeft'`                                                                           | [`MergeCellCommand`](../../api/module_table_commands_mergecellcommand-MergeCellCommand.html)                   |                                                    |
| `'mergeTableCellUp'`                                                                             | [`MergeCellCommand`](../../api/module_table_commands_mergecellcommand-MergeCellCommand.html)                   |                                                    |
| `'mergeTableCellDown'`                                                                           | [`MergeCellCommand`](../../api/module_table_commands_mergecellcommand-MergeCellCommand.html)                   |                                                    |
| `'splitTableCellVertically'`                                                                     | [`SplitCellCommand`](../../api/module_table_commands_splitcellcommand-SplitCellCommand.html)                   |                                                    |
| `'splitTableCellHorizontally'`                                                                   | [`SplitCellCommand`](../../api/module_table_commands_splitcellcommand-SplitCellCommand.html)                   |                                                    |

#### Table alignment in output

Table alignment in the editor’s output uses CSS classes by default. But, you can control it with the `table.tableProperties.alignment.useInlineStyles` property.

* When the property is `false` (default), output contains CSS classes.
* When the property is `true`, output contains inline styles.

The option applies to all five alignment options. Learn more about them in the [Table alignment](#ckeditor5/latest/features/tables/tables.html--table-alignment) section.

> **Note**
>
> We recommend using the official [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) for development and debugging. It will give you tons of useful information about the state of the editor, such as internal data structures, selection, commands, and much more.

<a id="ckeditor5/latest/features/tables/tables-resize.html">source file: "ckeditor5/latest/features/tables/tables-resize.html"</a>

## Table column resize

The [`TableColumnResize`](../../api/module_table_tablecolumnresize-TableColumnResize.html) plugin lets you resize tables and individual table columns. It gives you complete control over column width, whether you drag the column edge or enter an exact value, in percentages or pixels.

### Demo

To resize a column, simply hover your pointer over the column edge until it gets highlighted. Drag the column edge until you achieve the desired size.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

The column resize feature is compatible with the [Export to Word](#ckeditor5/latest/features/converters/export-word.html) feature. The converter will respect the column width set in the editor and retain it in the created .DOCX file.

### Column width units

By default, CKEditor 5 keeps table column widths as percentages, so the table and its columns scale with the available space. The feature also supports fixed widths expressed in pixels.

The table width is the single source of truth for the unit. When you set the table width in pixels through the [table and cell styling](#ckeditor5/latest/features/tables/tables-styling.html) tools, the column widths switch to pixels too. Switching the table width back to a percentage converts the columns accordingly. This keeps the whole table consistent, whether it should stretch with the surrounding layout or stay at a fixed size.

### Setting an exact column width

Besides dragging the column edge, you can set a precise column width through the cell properties. Put the caret in a cell, open the cell properties, and enter the value in the **Width** field.

In a resized table, this width applies to the entire column the cell belongs to, rather than to the single cell. This lets you enter an exact value instead of approximating it by dragging.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Table, TableColumnResize } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableColumnResize, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableColumnResize } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableColumnResize, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Common API

The [`TableColumnResize`](../../api/module_table_tablecolumnresize-TableColumnResize.html) plugin registers the `'tableColumnWidth'` command.

You can set the width of the columns covered by the current selection with the command below. A numeric value without a unit is treated as pixels:

```js
// Set the width of the selected column to 200 pixels.
editor.execute( 'tableColumnWidth', { value: '200' } );
```

In a resized table, the **Width** field of the [cell properties](#ckeditor5/latest/features/tables/tables-styling.html) uses this command to set the width of the whole column instead of a single cell.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/tables/tables-scroll.html">source file: "ckeditor5/latest/features/tables/tables-scroll.html"</a>

## Table scrolling

The [`TableScroll`](../../api/module_table_tablescroll-TableScroll.html) plugin keeps wide tables usable. Whenever a table would be wider than the space available to it, the table scrolls horizontally inside its own frame instead of squeezing its columns down to an unreadable width or breaking out of the page layout.

### Demo

Try shrinking your browser window, or dragging the table below wider with the [column resize](#ckeditor5/latest/features/tables/tables-resize.html) handle – once the table no longer fits, it starts scrolling horizontally on its own. While dragging, the table’s edge snaps to exactly 100% of the available width and resists being dragged past it, making it easy to land on a table that fits its container exactly – a longer drag still lets it overflow on purpose.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list:

**NPM**

```js
import { ClassicEditor, Table, TableScroll } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableScroll, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableScroll } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableScroll, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> By default, this feature requires no configuration or additional UI – a **content** table starts and stops scrolling automatically, based on its own width and the space available to it. It works together with the [table and column resize](#ckeditor5/latest/features/tables/tables-resize.html) and [table caption](#ckeditor5/latest/features/tables/tables-caption.html) features. See [below](#ckeditor5/latest/features/tables/tables-scroll.html--configuring-which-tables-can-scroll) for how to also enable it for layout tables.

### Configuring which tables can scroll

By default, only **content** tables become scrollable when they overflow their container. **Layout** tables are excluded by default, since letting a layout table grow past its container can easily break the intended page layout – dragging its column resize handle stops at the container’s edge instead of overflowing it.

To also allow layout tables to scroll (and to be resized past the container width), add `'layout'` to [`config.table.tableScroll.tableTypes`](../../api/module_table_tableconfig-TableScrollConfig.html#member-tableTypes):

**NPM**

```js
ClassicEditor
	.create( document.querySelector( '#editor' ), {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableScroll, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			tableScroll: {
				tableTypes: [ 'content', 'layout' ]
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
ClassicEditor
	.create( document.querySelector( '#editor' ), {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableScroll, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			tableScroll: {
				tableTypes: [ 'content', 'layout' ]
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> A table nested inside another table never becomes scrollable, regardless of this configuration – scrolling only ever applies to a table sitting directly in the editing root.

### Common API

The [`TableScroll`](../../api/module_table_tablescroll-TableScroll.html) plugin does not register any commands or UI components.

### Known issues

This feature only affects the editing view – a table only ever scrolls while you are editing it, it never scrolls in the actual document data. Because of that, it does not carry over to the [Export to Word](#ckeditor5/latest/features/converters/export-word.html) and [Export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) features: an overflowing table is exported at its full, intended width, and appears exactly as it would with the scrolling feature disabled.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/tables/tables-styling.html">source file: "ckeditor5/latest/features/tables/tables-styling.html"</a>

## Table and cell styling tools

CKEditor 5 comes with some additional tools that help you change the look of tables and table cells. You can control border color and style, background color, padding, or text alignment.

### Demo

Put the caret anywhere inside the table to open the table toolbar. Click the table properties button in the toolbar. A pop–up will open with options to shape the look of the entire table. The cell properties button gives you access to styling options for individual table cells.

[Learn more](#ckeditor5/latest/features/tables/tables-styling.html--configuring-styling-tools) about configuring color palettes in the table styling pop–up interfaces.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Table, TableCellProperties, TableProperties, TableToolbar } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Table, TableToolbar, TableProperties, TableCellProperties, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			contentToolbar: [
				'tableColumn', 'tableRow', 'mergeTableCells',
				'tableProperties', 'tableCellProperties'
			],

tableProperties: {
				// The configuration of the TableProperties plugin.
			},

tableCellProperties: {
				// The configuration of the TableCellProperties plugin.
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Table, TableCellProperties, TableProperties, TableToolbar } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Table, TableToolbar, TableProperties, TableCellProperties, /* ... */ ],
		toolbar: [ 'insertTable', /* ... */ ],
		table: {
			contentToolbar: [
				'tableColumn', 'tableRow', 'mergeTableCells',
				'tableProperties', 'tableCellProperties'
			],

tableProperties: {
				// The configuration of the TableProperties plugin.
			},

tableCellProperties: {
				// The configuration of the TableCellProperties plugin.
			}
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring styling tools

Table and cell styling tools let you create tables with colorful backgrounds and borders. These colors can be picked using color palettes in the table properties and cell properties pop-ups. To help users choose the right colors for the content, you can pre-configure such color palettes, like in the editor below:

With the selection inside any table cell, use the table properties and cell properties buttons in the toolbar to check available styling and color options.

#### Customizing color palettes

You can use these specific configuration options to define customized color palettes for background and border colors to match your document:

* [`tableProperties.borderColors`](../../api/module_table_tableconfig-TableConfig.html#member-tableProperties) – Defines the color palette for table borders.
* [`tableProperties.backgroundColors`](../../api/module_table_tableconfig-TableConfig.html#member-tableProperties) – Defines the color palette for table background.
* [`tableCellProperties.borderColors`](../../api/module_table_tableconfig-TableConfig.html#member-tableCellProperties) – Defines the color palette for cell borders.
* [`tableCellProperties.backgroundColors`](../../api/module_table_tableconfig-TableConfig.html#member-tableCellProperties) – Defines the color palette for cell background.

> **Note**
>
> These configuration options **do not** impact the [data loaded into the editor](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html--replacing-the-editor-data-with-setdata). This means that they do not limit or filter the colors in the data. They are used only in the user interface allowing users to pick colors in a more convenient way.

For instance, to define the same color palette for all border and background configurations, use the following code snippet:

```js
const customColorPalette = [
    {
        color: 'hsl(4, 90%, 58%)',
        label: 'Red'
    },
    {
        color: 'hsl(340, 82%, 52%)',
        label: 'Pink'
    },
    {
        color: 'hsl(291, 64%, 42%)',
        label: 'Purple'
    },
    {
        color: 'hsl(262, 52%, 47%)',
        label: 'Deep Purple'
    },
    {
        color: 'hsl(231, 48%, 48%)',
        label: 'Indigo'
    },
    {
        color: 'hsl(207, 90%, 54%)',
        label: 'Blue'
    },

// More colors.
    // ...
];

ClassicEditor
    .create( {
        // ... Other configuration options ...
        table: {
            contentToolbar: [
                'tableColumn', 'tableRow', 'mergeTableCells',
                'tableProperties', 'tableCellProperties'
            ],

// Set the palettes for tables.
            tableProperties: {
                borderColors: customColorPalette,
                backgroundColors: customColorPalette
            },

// Set the palettes for table cells.
            tableCellProperties: {
                borderColors: customColorPalette,
                backgroundColors: customColorPalette
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Default table and table cell styles

The table styles feature allows for configuring the default look of the tables in the editor. The configuration object should be synchronized with the [editor content styles](#ckeditor5/latest/getting-started/setup/css.html).

The **“Table properties”** and **“Table cell properties”** buttons in the toolbar will show the table and table cell properties applied to the table or table cells.

The style sheet for the editor displayed below looks as follows:

```css
.ck-content figure.table:not(.layout-table) {
    float: left;
    width: 550px;
    height: 450px;
}

.ck-content figure.table:not(.layout-table) > table {
    border-style: dashed;
    border-color: hsl(90, 75%, 60%);
    border-width: 3px;
}

.ck-content figure.table:not(.layout-table) > table  > tbody > tr > td,
.ck-content figure.table:not(.layout-table) > table  > tbody > tr > th,
.ck-content figure.table:not(.layout-table) > table  > thead > tr > td,
.ck-content figure.table:not(.layout-table) > table  > thead > tr > th {
    text-align: center;
    vertical-align: bottom;
    padding: 10px
}
```

You must pass the same values to the editor configuration as:

* The [`table.tableProperties.defaultProperties`](../../api/module_table_tableconfig-TablePropertiesOptions.html) object for the table properties.
* The [`table.tableCellProperties.defaultProperties`](../../api/module_table_tableconfig-TableCellPropertiesOptions.html) object for the table cell properties.

```js
const tableConfig = {
    table: {
        tableProperties: {
            // The default styles for tables in the editor.
            // They should be synchronized with the content styles.
            defaultProperties: {
                borderStyle: 'dashed',
                borderColor: 'hsl(90, 75%, 60%)',
                borderWidth: '3px',
                alignment: 'left',
                width: '550px',
                height: '450px'
            },
        },
        // The default styles for table cells in the editor.
        // They should be synchronized with the content styles.
        tableCellProperties: {
            defaultProperties: {
                horizontalAlignment: 'center',
                verticalAlignment: 'bottom',
                padding: '10px'
            }
        }
    }
};
```

You should align the table element to the `left` side by default. Its size should be `550x450px`. The border style should be `dashed`, `3px` of its width, and the color specified as `Light green`.

The content should be away about `10px` from the cell’s edges (`padding`), vertically aligned to `bottom` and horizontally to `center`.

The same will be applied to new tables and cells if they are inserted into the editor.

Read more about all supported properties for the [table](../../api/module_table_tableconfig-TablePropertiesOptions.html) and [table cell](../../api/module_table_tableconfig-TableCellPropertiesOptions.html) features in their API documentation.

> **Note**
>
> The default table and table cell styles **do** impact the [data loaded into the editor](#ckeditor5/latest/getting-started/setup/getting-and-setting-data.html--replacing-the-editor-data-with-setdata). Default properties will not be kept in the editor model.

#### Helper lines when border style is set to none

By default, when a table or table cell has an inline style such as `border: none` or `border-style: none`, the editor displays a dashed helper line to visually indicate the hidden border. This visualization is applied only in the editing view and does not affect the output HTML or the data stored by CKEditor 5.

The effect looks as follows:

If you prefer a true WYSIWYG experience or already implement your own border visualization logic, this behavior can be disabled using the [`table.showHiddenBorders`](../../api/module_table_tableconfig-TableConfig.html#member-showHiddenBorders) configuration option.

```js
const tableConfig = {
    table: {
        showHiddenBorders: false
    }
};
```

When disabled, tables and cells with `border: none` will remain completely borderless in the editing view, matching their rendered output.

### Common API

#### UI components

| [Component](#ckeditor5/latest/getting-started/setup/toolbar.html) name | Registered by                                                                                |
| ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| The `'tableProperties'` button                                         | [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html)             |
| The `'tableCellProperties'` button                                     | [`TableCellProperties`](../../api/module_table_tablecellproperties-TableCellProperties.html) |

##### Toolbars

The [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html) and [`TableCellProperties`](../../api/module_table_tablecellproperties-TableCellProperties.html) plugins allow adding the `tableProperties` and `tableCellProperties` items to the toolbar. You can [configure](../../api/module_table_tableconfig-TableConfig.html#member-tableToolbar) its content.

#### Editor commands

| [Command](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--commands) name | Command class                                                                                                                                                             | Belongs to (top-level plugin)                                                                |
| ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| `'tableBorderColor'`                                                                             | [`TableBorderColorCommand`](../../api/module_table_tableproperties_commands_tablebordercolorcommand-TableBorderColorCommand.html)                                         | [`TableProperties`](../../api/module_table_tableproperties-TableProperties.html)             |
| `'tableBorderStyle'`                                                                             | [`TableBorderStyleCommand`](../../api/module_table_tableproperties_commands_tableborderstylecommand-TableBorderStyleCommand.html)                                         |                                                                                              |
| `'tableBorderWidth'`                                                                             | [`TableBorderWidthCommand`](../../api/module_table_tableproperties_commands_tableborderwidthcommand-TableBorderWidthCommand.html)                                         |                                                                                              |
| `'tableAlignment'`                                                                               | [`TableAlignmentCommand`](../../api/module_table_tableproperties_commands_tablealignmentcommand-TableAlignmentCommand.html)                                               |                                                                                              |
| `'tableWidth'`                                                                                   | [`TableWidthCommand`](../../api/module_table_tableproperties_commands_tablewidthcommand-TableWidthCommand.html)                                                           |                                                                                              |
| `'tableHeight'`                                                                                  | [`TableHeightCommand`](../../api/module_table_tableproperties_commands_tableheightcommand-TableHeightCommand.html)                                                        |                                                                                              |
| `'tableBackgroundColor'`                                                                         | [`TableBackgroundColorCommand`](../../api/module_table_tableproperties_commands_tablebackgroundcolorcommand-TableBackgroundColorCommand.html)                             |                                                                                              |
| `'tableCellBorderStyle'`                                                                         | [`TableCellBorderStyleCommand`](../../api/module_table_tablecellproperties_commands_tablecellborderstylecommand-TableCellBorderStyleCommand.html)                         | [`TableCellProperties`](../../api/module_table_tablecellproperties-TableCellProperties.html) |
| `'tableCellBorderColor'`                                                                         | [`TableCellBorderColorCommand`](../../api/module_table_tablecellproperties_commands_tablecellbordercolorcommand-TableCellBorderColorCommand.html)                         |                                                                                              |
| `'tableCellBorderWidth'`                                                                         | [`TableCellBorderWidthCommand`](../../api/module_table_tablecellproperties_commands_tablecellborderwidthcommand-TableCellBorderWidthCommand.html)                         |                                                                                              |
| `'tableCellHorizontalAlignment'`                                                                 | [`TableCellHorizontalAlignmentCommand`](../../api/module_table_tablecellproperties_commands_tablecellhorizontalalignmentcommand-TableCellHorizontalAlignmentCommand.html) |                                                                                              |
| `'tableCellWidth'`                                                                               | [`TableCellWidthCommand`](../../api/module_table_tablecellwidth_commands_tablecellwidthcommand-TableCellWidthCommand.html)                                                |                                                                                              |
| `'tableCellHeight'`                                                                              | [`TableCellHeightCommand`](../../api/module_table_tablecellproperties_commands_tablecellheightcommand-TableCellHeightCommand.html)                                        |                                                                                              |
| `'tableCellPadding'`                                                                             | [`TableCellPaddingCommand`](../../api/module_table_tablecellproperties_commands_tablecellpaddingcommand-TableCellPaddingCommand.html)                                     |                                                                                              |
| `'tableCellBackgroundColor'`                                                                     | [`TableCellBackgroundColorCommand`](../../api/module_table_tablecellproperties_commands_tablecellbackgroundcolorcommand-TableCellBackgroundColorCommand.html)             |                                                                                              |
| `'tableCellVerticalAlignment'`                                                                   | [`TableCellVerticalAlignmentCommand`](../../api/module_table_tablecellproperties_commands_tablecellverticalalignmentcommand-TableCellVerticalAlignmentCommand.html)       |                                                                                              |

> **Important**
>
> When the [table column resize](#ckeditor5/latest/features/tables/tables-resize.html) feature is enabled and the table has been resized, the cell **Width** field sets the width of the whole column through the `'tableColumnWidth'` command, rather than the width of a single cell.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/tables/tables.html">source file: "ckeditor5/latest/features/tables/tables.html"</a>

## Tables in CKEditor 5 (overview)

The table feature provides tools for creating and editing tables. Tables are great for organizing data in a clear, visually appealing way or creating structured content. They are also great for making document layouts for applications such as newsletters or email editors. There are two basic types of tables available: content tables, described in this feature guide, and [layout tables](#ckeditor5/latest/features/tables/layout-tables.html) used to organize the content rather than present tabular data. You can easily [switch between these two types](#ckeditor5/latest/features/tables/layout-tables.html--table-toggling).

### Demo

Use the insert table button to insert a new table into the content. Click inside the table to open a contextual toolbar. The toolbar lets you add or remove columns and rows . You can also merge or split cells .

Try toggling the caption on and off . You can also change the properties of the entire table or individual cells . To control the width of a column, click and drag its edge.

You may look for more interesting details in the [Tables in CKEditor 5](https://ckeditor.com/blog/feature-of-the-month-tables-in-ckeditor-5/) blog post after reading this guide.

### Basic table features

The basic table features allow users to insert tables into content, add or remove columns and rows and merge or split cells.

The [`@ckeditor/ckeditor5-table`](https://www.npmjs.com/package/@ckeditor/ckeditor5-table) package contains multiple plugins that implement various table-related features. The [`Table`](../../api/module_table_table-Table.html) plugin is at the core of the ecosystem and it provides the table functionality. There are many other features that extend the editor capabilities:

### Table selection

The [`TableSelection`](../../api/module_table_tableselection-TableSelection.html) plugin introduces support for the custom selection system for tables that lets you:

* Select an arbitrary rectangular table fragment – a few cells from different rows, a column (or a few of them) or a row (or multiple rows).
* Apply formatting or add a link to all selected cells at once.

The table selection plugin is loaded automatically by the `Table` plugin and can be tested in the [demo above](#ckeditor5/latest/features/tables/tables.html--demo).

### Table alignment

You can move tables horizontally to create a desired document layout. There are five alignment options in tables:

* Left (block) : A table aligns to the left. The table does not influence the flow of other content.
* Center : A table is horizontally centered, with equal amounts of space on both sides.
* Right (block) : A table is aligned to the right. The table does not influence the flow of other content.
* Left (wrap) : A table aligns to the left, and other content wraps around it.
* Right (wrap) : A table aligns to the right, and other content wraps around it.

You can find all of those options in the [table properties balloon](#ckeditor5/latest/features/tables/tables.html--table-contextual-toolbar). The balloon displays after you click on a table. Use the [demo above](#ckeditor5/latest/features/tables/tables.html--demo) to test all those options.

You can also control how the alignment appears in the editor’s output. Learn more about it in the [Table alignment in output](#ckeditor5/latest/features/tables/tables-installation.html--table-alignment-in-output) section.

### Table cell type

Two types of table cells can contain content: data cells (the default type) and header cells. Header cells provide semantic labelling for rows or columns, helping the browser or a screen reader understand the data arrangement and relations.

To change cell type, click the cell and use the cell properties icon from the table toolbar. Once there, choose the desired cell type.

To create a header row or column in your table, select all cells in the row or column and change their type to header. You will see the type change automatically in the row/column property dialog.

> **Tip**
>
> It is easier to use the row/column property dialog to change these into headers, rather than use the cell property method.

### Table cell scope

Header cells can use the `scope` attribute to explicitly associate themselves with the related row or column, which helps screen readers understand the table structure.

This attribute is available only for header cells and is enabled by default. The editor assigns the `scope` attribute automatically based on a header cell’s position. If you prefer, you can change it manually in the cell properties balloon. The dropdown offers two explicit options:

* **Column header** – forces a header cell to describe the column and sets `scope="col"`.
* **Row header** – forces a header cell to describe the row and sets `scope="row"`.

To disable this behavior, set the [`config.table.tableCellProperties.scopedHeaders`](../../api/module_table_tableconfig-TableCellPropertiesConfig.html#member-scopedHeaders) configuration option to `false`.

### Typing around tables

To type before or after a table easily, select the table, then press the Arrow key (`←` or `→`) once, depending on where you want to add content – before or after. The table is no longer selected and whatever text you type will appear in the desired position.

### Nesting tables

CKEditor 5 allows nesting tables inside other table’s cells. This may be used for creating advanced charts or layouts based on tables. The nested table can be formatted just like a regular one.

#### Demo

You can test this feature in the demo below by adding a new table in the blank “abandoned” section at the bottom of the existing table. Click inside a cell and use the insert table button . A nested table will appear inside the cell.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

#### Known issues

While table nesting is fully functional, the Markdown code generated with the [Markdown output](#ckeditor5/latest/features/autoformat.html) feature will not properly render nested tables ([#9475](https://github.com/ckeditor/ckeditor5/issues/9475)). Feel free to upvote 👍 this issue on GitHub if it is important for you.

### Table contextual toolbar

The [`TableToolbar`](../../api/module_table_tabletoolbar-TableToolbar.html) plugin introduces a contextual toolbar for table. The toolbar appears when a table or a cell is selected and contains various table-related buttons. These would typically include add or remove columns and rows and merge or split cells . If these features are configured, the toolbar will also contain buttons for captions and table and cell properties.

The table selection plugin is loaded automatically by the `Table` plugin and can be tested in the [demo above](#ckeditor5/latest/features/tables/tables.html--demo). Learn more about configuring a contextual toolbar in the [Common API section](#ckeditor5/latest/features/tables/tables-installation.html--toolbars).

### Block vs inline content in table cells

The table feature allows for creating block content (like paragraphs, lists, headings, etc.) inside table cells. However, if a table cell contains just one paragraph and this paragraph has no special attributes (like text alignment), the cell content is considered “inline” and the paragraph is not rendered.

This means that a table cell can have two states: with inline content or with block content. The reason for this differentiation is that most tables contain only inline content (like the [demo](#ckeditor5/latest/features/tables/tables.html--demo) above) and it is common for “data tables” to not contain any block content. In such a scenario, printing out `<p>` elements would be semantically wrong and also unnecessary. There are, however, scenarios where the user wants to create, for example, a list inside a table cell and then the support for block content is necessary.

> **Note**
>
> “Rendering” here refers to the view layer. In the model, a cell is always filled with at least a `<paragraph>`. This is because of consistency, as – since a cell always has some block content – the text is never directly inside the `<tableCell>`. This also allows features like `Enter` support to work out of the box (since a `<paragraph>` exists in the model, it can be split despite the fact that it is not present in the view).

#### Inline content

The following is the model representation of table cells with inline content only (a single `<paragraph>` inside):

```html
<table>
    <tableRow>
        <tableCell>
            <paragraph>Foo</paragraph>
        </tableCell>
        <tableCell>
            <paragraph>Bar</paragraph>
        </tableCell>
    </tableRow>
</table>
```

The above model structure will be rendered to the [data](../../api/module_editor-classic_classiceditor-ClassicEditor.html#function-getData) as:

```html
<figure class="table">
    <table>
        <tbody>
            <tr>
                <td>Foo</td>
                <td>Bar</td>
            </tr>
        </tbody>
    </table>
</figure>
```

In the editing view (the editable container in which the user edits the content), additional `<span>` elements are created to compensate for the hidden `<paragraph>` elements:

```html
<figure class="table">
    <table>
        <tbody>
            <tr>
                <td><span>Foo</span></td>
                <td><span>Bar</span></td>
            </tr>
        </tbody>
    </table>
</figure>
```

#### Block content

If a table cell contains any other block content than a single `<paragraph>` with no attributes, these block elements will be rendered.

The following is a sample table with some block content (model representation):

```html
<table>
    <tableRow>
        <tableCell>
            <paragraph>Foo</paragraph>
            <paragraph>Bar</paragraph>
        </tableCell>
        <tableCell>
            <heading1>Some title</heading1>
        </tableCell>
        <tableCell>
            <paragraph textAlign="right">Baz</paragraph>
        </tableCell>
    </tableRow>
</table>
```

The above model structure will be rendered to the data and to the editing view as:

```html
<figure class="table">
    <table>
        <tbody>
            <tr>
                <td>
                    <p>Foo</p>
                    <p>Bar</p>
                </td>
                <td>
                    <h2>Some title</h2>
                </td>
                <td>
                    <p style="text-align: right;">Baz</p>
                </td>
            </tr>
        </tbody>
    </table>
</figure>
```

> **Note**
>
> At the moment, it is not possible to completely disallow block content in tables. See the [discussion on GitHub](https://github.com/ckeditor/ckeditor5-table/issues/101) about adding a configuration option that would enable that. Feel free to upvote 👍 if this feature is important to you.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-table>.

<a id="ckeditor5/latest/features/template.html">source file: "ckeditor5/latest/features/template.html"</a>

## Templates

The template feature allows you to insert predefined content structures into the document. Templates can provide both smaller portions of content (like a formatted table) and base structures for entire documents (for example, a formal letter template). Templates are a useful tool to speed up the writing process and maintain compliance with the company’s document and content policy.

### Demo

Click the template button to open the dropdown and select the template you want to apply. You can search the templates by their titles.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor } from 'ckeditor5';
import { Template } from 'ckeditor5-premium-features';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Template, /* ... */ ],
		toolbar: [ 'insertTemplate', /* ... */ ],

// Configure the feature.
		template: {
			definitions: [
				{
					title: 'The title of the template',
					description: 'A longer description of the template',
					data: '<p>Data inserted into the content</p>'
				},
				{
					// ...
				},
				// More template definitions.
				// ...
			]
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor } = CKEDITOR;
const { Template } = CKEDITOR_PREMIUM_FEATURES;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Template, /* ... */ ],
		toolbar: [ 'insertTemplate', /* ... */ ],

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

#### Activating the feature

### Configuration

> **Note**
>
> For more technical details, check the [plugin configuration reference](../api/module_template_template-TemplateConfig.html).

The configuration of the feature is simply a list of [template definitions](../api/module_template_template-TemplateConfig.html#member-definitions).

An example configuration can be as follows:

```js
{
    template: {
        definitions: [
            {
                title: 'Issue acknowledgement (plain text)',
                data: 'Dear customer, thank you for your report! The issue is currently being worked on by our development team.'
            },
            {
                title: 'Signature (multi-line)',
                data: '<p><b>Jane Doe</b></p><p>Marketing Specialist at <a href="https://example.com">Example.com</a></p>',
                description: 'Author signature with the link to the website.'
            },
            {
                title: 'Pricing table',
                data: '<figure class="table"><table><thead><tr><th style="text-align:center;">Feature</th><th style="background-color:hsl(90, 75%, 60%);text-align:center;">Free</th><th style="background-color:hsl(180, 75%, 60%);text-align:center;">Basic</th><th style="background-color:hsl(0, 75%, 60%);text-align:center;"><span style="color:hsl(0, 0%, 100%);">Professional</span></th><th style="background-color:hsl(270, 75%, 60%);text-align:center;"><span style="color:hsl(0, 0%, 100%);">Custom</span></th></tr></thead><tbody><tr><td style="text-align:center;">Feature #1</td><td style="background-color:hsl(90, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(180, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(0, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(270, 75%, 60%);text-align:center;">✅</td></tr><tr><td style="text-align:center;">Feature #2</td><td style="background-color:hsl(90, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(180, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(0, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(270, 75%, 60%);text-align:center;">✅</td></tr><tr><td style="text-align:center;">Feature #3</td><td style="background-color:hsl(90, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(180, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(0, 75%, 60%);text-align:center;">✅</td><td style="background-color:hsl(270, 75%, 60%);text-align:center;">✅</td></tr><tr><td style="text-align:center;">Feature #4</td><td style="background-color:hsl(90, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(180, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(0, 75%, 60%);text-align:center;">❌</td><td style="background-color:hsl(270, 75%, 60%);text-align:center;">✅</td></tr></tbody></table><figcaption>Pricing table</figcaption></figure>',
                icon: '<svg viewBox="0 0 45 45" fill="none" xmlns="http://www.w3.org/2000/svg"><mask id="a" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="2" y="2" width="41" height="41"><rect x="2" y="2" width="41" height="41" rx="5" fill="#59A5FF"/></mask><g mask="url(#a)"><rect x="2" y="2" width="41" height="41" rx="5" fill="#444"/><path fill="#ECECEC" d="M4 17h11v11H4z"/><path fill="#A9E6FA" d="M17 17h11v11H17z"/><path fill="#ECECEC" d="M30 17h11v11H30z"/><path d="M4 7a3 3 0 0 1 3-3h31a3 3 0 0 1 3 3v8H4V7Z" fill="#FF1A88"/><path d="M4 30h11v11H7a3 3 0 0 1-3-3v-8ZM17 30h11v11H17z" fill="#A9E6FA"/><path d="M30 30h11v8a3 3 0 0 1-3 3h-8V30Z" fill="#ECECEC"/></g></svg>',
                description: 'Product pricing table that compares individual plans.'
            },
            // More template definitions.
            // ...
        ]
    }
}
```

> **Note**
>
> Even though the template feature can insert any HTML into the document, some content may be filtered out by the editor if no feature that supports this kind of content is enabled. For instance, if a template inserts `<b>Bold text</b>`, your editor needs the [`Bold`](../api/module_basic-styles_bold-Bold.html) plugin to be loaded to preserve it.
>
> See the overview of the [plugins’ HTML output](#ckeditor5/latest/framework/architecture/plugins.html--plugins-and-html-output) to learn which features you need. You can also use the [General HTML Support feature](#ckeditor5/latest/features/html/general-html-support.html) to insert custom HTML into the content.

### Related features

Here are some more CKEditor 5 features that can help you work with predefined content blocks and documents:

* [Restricted editing](#ckeditor5/latest/features/restricted-editing.html) – Define editable areas of the document for users with restricted editing rights.
* [HTML embed](#ckeditor5/latest/features/html/html-embed.html) – Embed an arbitrary HTML snippet in the editor.
* The [export to Word](#ckeditor5/latest/features/converters/export-word.html) feature allows you to generate editable `.docx` files out of your editor-created content.
* The [export to PDF](#ckeditor5/latest/features/converters/export-pdf.html) feature allows you to generate portable PDF files out of your editor-created content.

### Common API

The [`Template`](../api/module_template_template-Template.html) plugin registers:

* The `'insertTemplate'` UI dropdown component.
* The `'insertTemplate'` command implemented by [`TemplateCommand`](../api/module_template_templatecommand-TemplateCommand.html).

You can execute the command to insert arbitrary content into the editor at the user selection:

```js
editor.execute( 'insertTemplate', '<p>Content of the template</p>' );
```

<a id="ckeditor5/latest/features/text-alignment.html">source file: "ckeditor5/latest/features/text-alignment.html"</a>

## Text alignment

The alignment feature lets you align your content to the left or right as well as center or justify it.

### Demo

Click inside a paragraph or a header and use the toolbar dropdown to change the alignment of the element.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Alignment } from 'ckeditor5';

ClassicEditor.
	create( {
		licenseKey: '<YOUR_LICENSE_KEY>' // Or 'GPL'.
		plugins: [ Alignment, /* ... */ ],
		toolbar: [ 'alignment', /* ... */ ]
		alignment: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Alignment } = CKEDITOR;

ClassicEditor.
	create( {
		licenseKey: '<YOUR_LICENSE_KEY>'
		plugins: [ Alignment, /* ... */ ],
		toolbar: [ 'alignment', /* ... */ ]
		alignment: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring alignment options

#### Defining available options

It is possible to configure which alignment options are available in the editor by setting the [`alignment.options`](../api/module_alignment_alignmentconfig-AlignmentConfig.html#member-options) configuration option. You can choose from `'left'`, `'right'`, `'center'`, and `'justify'`.

> **Note**
>
> You should always include the `'left'` option for the LTR content. Similarly, you should always include the `'right'` option for the RTL content. Learn more about [configuring language of the editor content](#ckeditor5/latest/getting-started/setup/ui-language.html--setting-the-language-of-the-content).

For example, the following editor will support two alignment options: to the left and to the right:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        alignment: {
            options: [ 'left', 'right' ]
        },
        toolbar: [
            'heading', '|', 'bulletedList', 'numberedList', 'alignment', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Using classes instead of inline style

By default, alignment is set inline using the `text-align` CSS property. If you wish the feature to output more semantic content that uses classes instead of inline styles, you can specify class names by using the `className` property in `config.alignment.options` and style them by using a style sheet.

> **Note**
>
> Once you decide to use classes for the alignment, you must define `className` for **all** alignment entries in [`config.alignment.options`](../api/module_alignment_alignmentconfig-AlignmentConfig.html#member-options).

The following configuration will set `.my-align-left` and `.my-align-right` to left and right alignment, respectively.

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        alignment: {
            options: [
                { name: 'left', className: 'my-align-left' },
                { name: 'right', className: 'my-align-right' }
            ]
        },
        toolbar: [
            'heading', '|', 'bulletedList', 'numberedList', 'alignment', 'undo', 'redo'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Configuring the toolbar

You can choose to use the alignment dropdown (`'alignment'`) or configure the toolbar to use separate buttons for each of the options:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        toolbar: [
            'heading', '|', 'alignment:left', 'alignment:right', 'alignment:center', 'alignment:justify'
        ]
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### Related features

CKEditor 5 has more features that can help you organize your content:

* [Document title](#ckeditor5/latest/features/title.html) – Clearly divide your content into a title and body.
* [Headings](#ckeditor5/latest/features/headings.html) – Split your content into logical sections.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Organize your content into visually separated blocks, indent crucial paragraphs, etc.
* [Block quote](#ckeditor5/latest/features/block-quote.html) – Include block quotations or pull quotes in the rich-text content.
* [Remove format](#ckeditor5/latest/features/remove-format.html) – Easily clean basic text formatting.

### Common API

The [`Alignment`](../api/module_alignment_alignment-Alignment.html) plugin registers:

* Dropdown: `'alignment'`.

* Buttons: `'alignment:left'`, `'alignment:right'`, `'alignment:center'`, `'alignment:justify'`.

The number of options and their names are based on the [`alignment.options`](../api/module_alignment_alignmentconfig-AlignmentConfig.html#member-options) configuration option.

* Command: `'alignment'`:

You can align the currently selected block(s) by executing one of these commands:

```js
  editor.execute( 'alignment', { value: 'center' } );
  ```

### Content compatibility

The [`Alignment`](../api/module_alignment_alignment-Alignment.html) plugin provides support for the deprecated `align` attribute.

Block elements such as `<p>` with the `align` attribute are accepted by the plugin, but the editor always returns the markup in a modern format, so the transformation is one way only.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-alignment>.

<a id="ckeditor5/latest/features/text-transformation.html">source file: "ckeditor5/latest/features/text-transformation.html"</a>

## Automatic text transformation (autocorrect)

The text transformation feature enables autocorrection. It automatically changes predefined text fragments into their improved forms.

### Demo

Type snippets such as `(c)`, `3/4`, `!=`, `---`, `"foo"` into the editor below and see how they get transformed into their typographically nicer forms. You can see the complete list of predefined transformations in the [`TextTransformationConfig`](../api/module_typing_typingconfig-TextTransformationConfig.html) documentation.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

Here are some examples of snippets changed by the text transformation feature:

| From  | To    |
| ----- | ----- |
| (tm)  | ™     |
| 1/2   | ½     |
| ->    | →     |
| --    | –     |
| "foo" | “foo” |

This feature comes pre-configured with a set of the most popular transformations. You can, however, remove existing ones or add your own autocorrect entries.

While most often this feature is used to insert special characters that are not present on your keyboard, you can also use it to achieve other goals. For instance, you can improve the users’ productivity by configuring it to expand some abbreviations (like team or company names) into their full forms.

You may find interesting details and usage examples in the [Automatic text transformation in CKEditor 5](https://ckeditor.com/blog/feature-of-the-month-automatic-text-transformation-in-ckeditor-5/) blog post after reading this guide.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, TextTransformation } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ TextTransformation, /* ... */ ],
		typing: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, TextTransformation } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ TextTransformation, /* ... */ ],
		typing: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuring transformations

This feature comes pre-configured with a set of transformations. You can find the list of them in the [`TextTransformationConfig`](../api/module_typing_typingconfig-TextTransformationConfig.html) documentation.

By using the options defined below you can extend, limit, or override this list:

* [`typing.transformations.include`](../api/module_typing_typingconfig-TextTransformationConfig.html#member-include) – Overrides the default configuration. When overriding the default configuration you can reuse the predefined transformations (by using their names that you can find in the [`TextTransformationConfig`](../api/module_typing_typingconfig-TextTransformationConfig.html) documentation) and write custom transformations.
* [`typing.transformations.remove`](../api/module_typing_typingconfig-TextTransformationConfig.html#member-remove) – Removes predefined transformations.
* [`typing.transformations.extra`](../api/module_typing_typingconfig-TextTransformationConfig.html#member-extra) – Adds your custom transformations to the predefined ones.

#### Example: Using `transformations.include`

For instance, to use the transformations from the “quotes” and “typography” groups and to turn `CKE` into `CKEditor`, you can use the `transformations.include` property like this:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        typing: {
            transformations: {
                include: [
                    // Use only the 'quotes' and 'typography' groups.
                    'quotes',
                    'typography',

// Plus some custom transformation.
                    { from: 'CKE', to: 'CKEditor' }
                ],
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

#### Example: Using `transformations.remove` and `extra`

Another example, removing some transformations and adding some extra ones:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        typing: {
            transformations: {
                remove: [
                    // Do not use the transformations from the
                    // 'symbols' and 'quotes' groups.
                    'symbols',
                    'quotes',

// As well as the following transformations.
                    'arrowLeft',
                    'arrowRight'
                ],

extra: [
                    // Add some custom transformations, for example, for emojis.
                    { from: ':)', to: '🙂' },
                    { from: ':+1:', to: '👍' },
                    { from: ':tada:', to: '🎉' },

// You can also define patterns using regular expressions.
                    // Note: The pattern must end with `$` and all its fragments must be wrapped
                    // with capturing groups.
                    // The following rule replaces ` "foo"` with ` «foo»`.
                    {
                        from: /(^|\s)(")([^"]*)(")$/,
                        to: [ null, '«', null, '»' ]
                    },

// Finally, you can define `to` as a callback.
                    // This (naive) rule will auto-capitalize the first word after a period, question mark, or an exclamation mark.
                    {
                        from: /([.?!] )([a-z])$/,
                        to: matches => [ null, matches[ 1 ].toUpperCase() ]
                    }
                ],
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

You can read more about the format of transformation rules in [`TextTypingTransformationDescription`](../api/module_typing_typingconfig-TextTypingTransformationDescription.html).

You can test these custom rules in the demo. Try typing `:)` or `:+1:` and see how the text gets transformed into emojis. You can also write some sentences to test how the editor capitalizes words after a period, a quotation mark, or an exclamation mark.

### Related features

In addition to enabling automatic text transformations, you may want to check the following productivity features:

* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Quickly apply formatting to the content you are writing.
* [Autolink](#ckeditor5/latest/features/link.html--autolink-feature) – Turns the links and email addresses typed or pasted into the editor into active URLs.
* [Slash commands](#ckeditor5/latest/features/slash-commands.html) – Execute a predefined command by writing its name or alias directly in the editor.
* [Mentions](#ckeditor5/latest/features/mentions.html) – Brings support for smart autocompletion.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-typing>.

<a id="ckeditor5/latest/features/title.html">source file: "ckeditor5/latest/features/title.html"</a>

## Document title

The title feature lets you add a single title field at the beginning of your document. This way you can clearly divide your content into the title and body sections.

### Demo

Use the editor below to create a document with distinct title and body sections. You can check the content of the title and body elements in the console below.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Keyboard navigation

The title plugin lets you move from the title to the body element using the `Tab` key, providing form-like experience. When the selection is at the beginning of the first body element, you can go back to the title element using `Shift`+`Tab`. You can also use `Enter` and `Backspace` keys to move the caret between the title and the body.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Title } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Title, /* ... */ ]
		title: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Title } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Title, /* ... */ ]
		title: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Placeholder integration

The title plugin is integrated with the [placeholder](#ckeditor5/latest/features/editor-placeholder.html) configuration. If you define it, the placeholder text will be used for the body element.

To change the title placeholder, use the [`title.placeholder`](../api/module_heading_title-HeadingTitleConfig.html#member-placeholder) configuration option. For instance:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        title: {
            placeholder: 'My custom placeholder for the title'
        },
        root: {
            placeholder: 'My custom placeholder for the body'
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

### HTML structure

When you call [`editor.getData()`](../api/module_core_editor_editor-Editor.html#function-getData), the document title will be represented as the following HTML:

```html
<h1>Feasibility Study</h1>
```

#### Model representation

In the CKEditor 5 data model the document title is represented as follows:

```html
<title>
    <title-content>
        Feasibility Study
    </title-content>
</title>
```

### Known issues

The feature is not compatible with the [pagination](#ckeditor5/latest/features/pagination/pagination.html) feature.

### Related features

CKEditor 5 has more features that can help you structure your document better:

* [Headings](#ckeditor5/latest/features/headings.html) – Divide your content into sections.
* [Block indentation](#ckeditor5/latest/features/indent.html) – Organize your content into visually separated blocks, indent crucial paragraphs, etc.
* [Editor placeholder](#ckeditor5/latest/features/editor-placeholder.html) – Set placeholder text to display when the content is empty. It helps users locate the editor in the application and prompts to input the content.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-heading>.

<a id="ckeditor5/latest/features/undo-redo.html">source file: "ckeditor5/latest/features/undo-redo.html"</a>

## Undo/Redo

The undo feature lets you withdraw recent changes to your content as well as bring them back. You can also selectively revert past changes, not just the latest ones.

### Demo

Use the demo below to try out the undo and redo mechanism. Play around with the content. Try introducing some changes and then use the toolbar buttons to undo or redo them.

Alternatively, use the well-known keyboard shortcut `Ctrl` + `Z` (this would be `Cmd` + `Z` on Mac) for undo. For redo, you can use either `Ctrl` + `Y` or `Ctrl` + `Shift` + `Z` (respectively with `Cmd` on Mac).

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

### Additional feature information

All operations of the undo feature are remembered and organized into batches that can later be easily undone or redone. Thanks to this approach, the feature can selectively revert past changes, not just the latest ones. This allows handling asynchronous actions such as image uploads without blocking the user from editing the document in the meantime.

The selective undo is heavily used in [real-time collaboration](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration.html) environments. In such a scenario, a specific user should only be able to revert their changes, while keeping the changes made by other users intact (unless there is an editing conflict). By omitting some changes and going down the stack, it is possible to only revert selected changes.

The feature supports both toolbar buttons and [keyboard shortcuts](#ckeditor5/latest/features/accessibility.html--keyboard-shortcuts) for convenient and easy operation.

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, Undo } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Undo, /* ... */ ],
		toolbar: [ 'undo', 'redo', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, Undo } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Undo, /* ... */ ],
		toolbar: [ 'undo', 'redo', /* ... */ ],
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

> **Note**
>
> Read more about [installing plugins](#ckeditor5/latest/getting-started/setup/configuration.html) and [toolbar configuration](#ckeditor5/latest/getting-started/setup/toolbar.html).

### Common API

The [Undo](../api/module_undo_undo-Undo.html) plugin is a “glue” plugin that loads the [`UndoEditing`](../api/module_undo_undoediting-UndoEditing.html) engine and the [`UndoUI`](../api/module_undo_undoui-UndoUI.html) features.

The `UndoEditing` feature registers the following commands:

* The [`UndoCommand`](../api/module_undo_undocommand-UndoCommand.html) which can be programmatically called as `undo` and is used to retrieve editor history from a batch.

```js
  editor.execute( 'undo');
  ```

You can use it to retrieve changes from the latest batch, or from some previous batch (for example, changes made by a selected user in a collaborative environment):

```js
  editor.execute( 'undo', batchToUndo );
  ```

* The [`RedoCommand`](../api/module_undo_redocommand-RedoCommand.html) is used to restore undo state from batch and is called as `redo`.

```js
  editor.execute( 'redo');
  ```

The [`UndoUI`](../api/module_undo_undoui-UndoUI.html) feature introduces the `undo` and `redo` buttons to the editor toolbar.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-undo>.

<a id="ckeditor5/latest/features/watchdog.html">source file: "ckeditor5/latest/features/watchdog.html"</a>

## Watchdog

The watchdog utility protects you from data loss in case the editor crashes. It saves your content just before the crash and creates a new instance of the editor with your content intact.

### Additional feature information

Every non-trivial piece of software has bugs. Despite our high-quality standards like 100% code coverage, regression testing, and manual tests before every release, CKEditor 5 is not free of bugs. Neither is the browser used by the user, your application in which CKEditor 5 is integrated, or any third-party add-ons that you used.

To limit the effect of an editor crash on the user experience, you can automatically restart the WYSIWYG editor with the content saved just before the crash.

The watchdog utility allows you to do exactly that. It ensures that an editor instance is running, despite a potential crash. It works by detecting that an editor crashed, destroying it, and automatically creating a new instance of that editor with the content of the previous editor.

Note that the most “dangerous” places in the CKEditor 5 API, like `editor.model.change()`, `editor.editing.view.change()` or emitters, are covered with checks and `try-catch` blocks that can detect unknown errors and restart the editor when they occur.

There are two available types of watchdogs:

* [Editor watchdog](#ckeditor5/latest/features/watchdog.html--editor-watchdog) – To be used with a single editor instance.
* [Context watchdog](#ckeditor5/latest/features/watchdog.html--context-watchdog) – To be used when your application uses the context.

### Usage

> **Important**
>
> Watchdog requires access to the editor creation process.
>
> You can use watchdog only in setups where the editor instance is created programmatically (for example, via `Editor.create()` or a custom creator callback).
>
> Prebuilt editors and framework integrations are supported as long as a creator function is provided or the integration exposes watchdog configuration.
>
> Watchdog cannot be used with editors initialized declaratively or via global scripts where the creation process is not under application control.

#### Editor watchdog

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), change your `ClassicEditor.create()` call to `watchdog.create()` as follows:

**NPM**

```js
import { ClassicEditor, Bold, EditorWatchdog, Essentials, Italic, Paragraph } from 'ckeditor5';

// Create a watchdog for the given editor type.
const watchdog = new EditorWatchdog( ClassicEditor );

// Create a new editor instance.
watchdog.create( {
	attachTo: document.querySelector( '#editor' ),
	licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
	plugins: [ Essentials, Paragraph, Bold, Italic ],
	toolbar: [ 'bold', 'italic', 'alignment' ]
} );
```

**CDN**

```js
const { ClassicEditor, Bold, EditorWatchdog, Essentials, Italic, Paragraph } = CKEDITOR;

// Create a watchdog for the given editor type.
const watchdog = new EditorWatchdog( ClassicEditor );

// Create a new editor instance.
watchdog.create( {
	attachTo: document.querySelector( '#editor' ),
	licenseKey: '<YOUR_LICENSE_KEY>',
	plugins: [ Essentials, Paragraph, Bold, Italic ],
	toolbar: [ 'bold', 'italic', 'alignment' ]
} );
```

In other words, your goal is to create a watchdog instance and make the watchdog create an instance of the editor you want to use. The watchdog will then create a new editor and if it ever crashes, restart it by creating a new editor.

> **Note**
>
> A new editor instance is created every time the watchdog detects a crash. Thus, the editor instance should not be kept in your application’s state. Use the [`EditorWatchdog#editor`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#member-editor) property instead.
>
> It also means that any code that should be executed for any new editor instance should be either loaded as an editor plugin or executed in the callbacks defined using [`EditorWatchdog#setCreator()`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#function-setCreator) and [`EditorWatchdog#setDestructor()`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#function-setDestructor). Read more about controlling the editor creation and destruction in the next section.

##### Controlling editor creation and destruction

For more control over the creation and destruction of editor instances, you can use [`EditorWatchdog#setCreator()`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#function-setCreator) and, if needed, the [`EditorWatchdog#setDestructor()`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#function-setDestructor) methods:

```js
// Create an editor watchdog.
const watchdog = new EditorWatchdog();

// Define a callback that will create an editor instance and return it.
watchdog.setCreator( ( editorConfig ) => {
    return ClassicEditor
        .create( editorConfig )
        .then( editor => {
            // Do something with the new editor instance.
            // ...
        } );
} );

// Do something before the editor is destroyed. Return a promise.
watchdog.setDestructor( editor => {
    // Do something before the editor is destroyed.
    // ...
    return editor
        .destroy()
        .then( () => {
            // Do something after the editor is destroyed.
            // ...
        } );
} );

// Create an editor instance and start watching it.
watchdog.create( editorConfig );
```

> **Note**
>
> The default (not overridden by `setDestructor()`) editor destructor simply executes `Editor#destroy()`.

##### Editor watchdog API

Other useful [methods, properties and events](../api/module_watchdog_editorwatchdog-EditorWatchdog.html):

```js
watchdog.on( 'error', () => { console.log( 'Editor crashed.' ) } );
watchdog.on( 'restart', () => { console.log( 'Editor was restarted.' ) } );

// Destroy the watchdog and the current editor instance.
watchdog.destroy();

// The current editor instance.
watchdog.editor;

// The current state of the editor.
// The editor might be in one of the following states:
//
// * `initializing` - Before the first initialization, and after crashes, before the editor is ready.
// * `ready` - A state when the user can interact with the editor.
// * `crashed` - A state when an error occurs. It quickly changes to `initializing` or `crashedPermanently` depending on how many and how frequent errors have been caught recently.
// * `crashedPermanently` - A state when the watchdog stops reacting to errors and keeps the editor crashed.
// * `destroyed` - A state when the editor is manually destroyed by the user after calling `watchdog.destroy()`.
watchdog.state;

// Listen to state changes.

let prevState = watchdog.state;

watchdog.on( 'stateChange', () => {
    const currentState = watchdog.state;

console.log( `State changed from ${ currentState } to ${ prevState }` );

if ( currentState === 'crashedPermanently' ) {
        watchdog.editor.enableReadOnlyMode( 'crashed-editor' );
    }

prevState = currentState;
} );

// An array of editor crash information.
watchdog.crashes.forEach( crashInfo => console.log( crashInfo ) );
```

#### Context watchdog

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, ContextWatchdog, Bold, Italic, Context, Essentials, Paragraph } from 'ckeditor5';

// Create a context watchdog and pass the context class with optional watchdog configuration:
const watchdog = new ContextWatchdog( Context, {
	crashNumberLimit: 10
} );

// Initialize the watchdog with the context configuration:
await watchdog.create( {
	plugins: [
		// A list of plugins for the context.
		// ...
	],
	// More configuration options for the plugin.
	// ...
} );

// Add editor instances.
// You may also use multiple `ContextWatchdog#add()` calls, each adding a single editor.
await watchdog.add( [ {
	id: 'editor1',
	type: 'editor',
	config: {
		attachTo: document.querySelector( '#editor' ),
		plugins: [ Essentials, Paragraph, Bold, Italic ],
		toolbar: [ 'bold', 'italic', 'alignment' ]
	},
	creator: ( config ) => ClassicEditor.create( config )
}, {
	id: 'editor2',
	type: 'editor',
	config: {
		attachTo: document.querySelector( '#editor-2' ),
		plugins: [ Essentials, Paragraph, Bold, Italic ],
		toolbar: [ 'bold', 'italic', 'alignment' ]
	},
	creator: ( config ) => ClassicEditor.create( config )
} ] );

// Or:
await watchdog.add( {
	id: 'editor1',
	type: 'editor',
	config: {
		attachTo: document.querySelector( '#editor' ),
		plugins: [ Essentials, Paragraph, Bold, Italic ],
		toolbar: [ 'bold', 'italic', 'alignment' ]
	},
	creator: ( config ) => ClassicEditor.create( config )
} );

await watchdog.add( {
	id: 'editor2',
	type: 'editor',
	config: {
		attachTo: document.querySelector( '#editor-2' ),
		plugins: [ Essentials, Paragraph, Bold, Italic ],
		toolbar: [ 'bold', 'italic', 'alignment' ]
	},
	creator: ( config ) => ClassicEditor.create( config )
} );
```

**CDN**

```js
const { ClassicEditor, ContextWatchdog, Bold, Italic, Context, Essentials, Paragraph } = CKEDITOR;

// Create a context watchdog and pass the context class with optional watchdog configuration:
const watchdog = new ContextWatchdog( Context, {
	crashNumberLimit: 10
} );

To destroy one of the item instances, use [`ContextWatchdog#remove`](../api/module_watchdog_contextwatchdog-ContextWatchdog.html#function-remove):

```js
await watchdog.remove( [ 'editor1', 'editor2' ] );

// Or:
await watchdog.remove( 'editor1' );
await watchdog.remove( 'editor2' );
```

##### Context watchdog API

The context watchdog feature provides the following API:

```js
// Creating a watchdog that will use the context class and the watchdog configuration.
const watchdog = new ContextWatchdog( Context, watchdogConfig );

// Setting a custom creator for the context.
watchdog.setCreator( async config => {
    const context = await Context.create( config );

// Do something when the context is initialized.
    // ...

return context;
} );

// Setting a custom destructor for the context.
watchdog.setDestructor( async context => {

// Do something before destroy.
    // ...

await context.destroy();
} );

// Initializing the context watchdog with the context configuration.
await watchdog.create( contextConfig );

// Adding item configuration (or an array of item configurations).
await watchdog.add( {
    id: 'editor1',
    type: 'editor',
    config: editorConfig,
    creator: createEditor,
    destructor: destroyEditor,
} );

await watchdog.add( [
    {
        id: 'editor1',
        type: 'editor',
        config: editorConfig,
        creator: createEditor,
        destructor: destroyEditor,
    },
    // More configuration items.
    // ...
] );

// Remove and destroy a given item (or items).
await watchdog.remove( 'editor1' );

await watchdog.remove( [ 'editor1', 'editor2', ... ] );

// Getting the given item instance.
const editor1 = watchdog.getItem( 'editor1' );

// Getting the state of the given item.
const editor1State = watchdog.getItemState( 'editor1' );

// Getting the context state.
const contextState = watchdog.state;

// The `error` event is fired when the context watchdog catches a context-related error.
// Note that errors fired by items are not delegated to `ContextWatchdog#event:error`.
// See also `ContextWatchdog#event:itemError`.
watchdog.on( 'error', ( _, { error } ) => {

// The `restart` event is fired when the context is set back to the `ready` state (after it was in the `crashed` state).
// Similarly, this event is not thrown for internal item restarts.
watchdog.on( 'restart', () => {
    console.log( 'The context has been restarted.' );
} );

// The `itemError` event is fired when an error occurred in one of the added items.
watchdog.on( 'itemError', ( _, { error, itemId } ) => {
    console.log( `An error occurred in an item with the '${ itemId }' ID.` );
} );

// The `itemRestart` event is fired when an item is set back to the `ready` state (after it was in the `crashed` state).
watchdog.on( 'itemRestart', ( _, { itemId } ) => {
    console.log( 'An item with with the '${ itemId }' ID has been restarted.' );
} );
```

### Configuration

Both [`EditorWatchdog`](../api/module_watchdog_editorwatchdog-EditorWatchdog.html#function-constructor) and [`ContextWatchdog`](../api/module_watchdog_contextwatchdog-ContextWatchdog.html#function-constructor) constructors accept a [configuration object](../api/module_watchdog_watchdog-WatchdogConfig.html) as the second argument with the following optional properties:

* `crashNumberLimit` – A threshold specifying the number of errors (defaults to `3`). After this limit is reached and the time between last errors is shorter than `minimumNonErrorTimePeriod`, the watchdog changes its state to `crashedPermanently` and it stops restarting the editor. This prevents an infinite restart loop.
* `minimumNonErrorTimePeriod` – An average number of milliseconds between the last editor errors (defaults to 5000). When the period of time between errors is lower than that and the `crashNumberLimit` is also reached, the watchdog changes its state to `crashedPermanently` and it stops restarting the editor. This prevents an infinite restart loop.
* `saveInterval` – A minimum number of milliseconds between saving the editor data internally (defaults to 5000). Note that for large documents this might impact the editor’s performance.

```js
const editorWatchdog = new EditorWatchdog( ClassicEditor, {
    minimumNonErrorTimePeriod: 2000,
    crashNumberLimit: 4,
    saveInterval: 1000
} );
```

> **Note**
>
> Note that the context watchdog passes its configuration to editor watchdogs that it creates for added editors.

### Limitations

The watchdog does not handle errors thrown during the editor or context initialization (for example, in `Editor.create()`) and editor destruction (for example, in `Editor#destroy()`). Errors thrown at these stages mean that there is a problem in the code integrating the editor with your application and such a problem cannot be fixed by restarting the editor.

<a id="ckeditor5/latest/features/word-count.html">source file: "ckeditor5/latest/features/word-count.html"</a>

## Word count and character count

The word count feature lets you track the number of words and characters in the editor. This helps you control the volume of your content and check the progress of your work.

### Demo

Add or remove some content and see how the counter below the editor changes in real time.

This demo presents a limited set of features. Visit the [feature-rich editor example](#ckeditor5/latest/examples/builds-custom/full-featured-editor.html) to see more in action.

The example above was created by using the following HTML page structure:

```html
<div id="editor">
    <p>Hello world.</p>
</div>
<div id="word-count"></div>
```

You can use the code below to set up the WYSIWYG editor with the word and character count features as in the example above.

```js
ClassicEditor
    .create( {
        // Configuration details.
    } )
    .then( editor => {
        const wordCountPlugin = editor.plugins.get( 'WordCount' );
        const wordCountWrapper = document.getElementById( 'word-count' );

wordCountWrapper.appendChild( wordCountPlugin.wordCountContainer );
    } );
```

### Installation

After [installing the editor](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html), add the feature to your plugin list and toolbar configuration:

**NPM**

```js
import { ClassicEditor, WordCount } from 'ckeditor5';

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ WordCount, /* ... */ ],
		wordCount: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

**CDN**

```js
const { ClassicEditor, WordCount } = CKEDITOR;

ClassicEditor
	.create( {
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ WordCount, /* ... */ ],
		wordCount: {
			// Configuration.
		}
	} )
	.then( /* ... */ )
	.catch( /* ... */ );
```

### Configuration

The word count and character count feature is quite flexible and there are a few configuration options available.

#### Configuring the container

There are two ways how you can inject the word count statistics into your page:

* By using the [`WordCount#wordCountContainer`](../api/module_word-count_wordcount-WordCount.html#member-wordCountContainer) property as shown in the example above.
* By specifying where the word count feature should insert its container which can be done by using [`config.wordCount.container`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-container).

The word count plugin renders its output as:

```html
<div class="ck ck-word-count">
    <div class="ck-word-count__words">Words: %%</div>
    <div class="ck-word-count__characters">Characters: %%</div>
</div>
```

If you wish to render the statistics differently, see the [`update` event](#ckeditor5/latest/features/word-count.html--reacting-to-updates).

#### Changing the output

There are two configuration options available that change the output of the word count and character count features:

* If the [`config.wordCount.displayWords`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-displayWords) option is set to `false`, the word counter will be hidden.
* If the [`config.wordCount.displayCharacters`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-displayCharacters) option is set to `false`, the character counter will be hidden.

#### Reacting to updates

You can execute your custom callback every time content statistics change by defining [`config.wordCount.onUpdate`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-onUpdate) in the editor configuration:

```js
ClassicEditor
    .create( {
        // ... Other configuration options ...
        wordCount: {
            onUpdate: stats => {
                // Prints the current content statistics.
                console.log( `Characters: ${ stats.characters }\nWords: ${ stats.words }` );
            }
        }
    } )
    .then( /* ... */ )
    .catch( /* ... */ );
```

**Note**: For performance reasons, your callback will be throttled and may not be up–to–date. Use the [`characters`](../api/module_word-count_wordcount-WordCount.html#member-characters) and [`words`](../api/module_word-count_wordcount-WordCount.html#member-words) plugin properties to retrieve the precise numbers on demand.

Below you can play with a demo post editor with a soft 120-character limit. The progress chart underneath it indicates the number of characters in the content. The chart changes its color as the number nears or exceeds the limit. Type in the editor to see the feature in action. See the code used to create the demo listed below in this section.

```js
const maxCharacters = 120;
const container = document.querySelector( '.demo-update' );
const progressCircle = document.querySelector( '.demo-update__chart__circle' );
const charactersBox = document.querySelector( '.demo-update__chart__characters' );
const wordsBox = document.querySelector( '.demo-update__words' );
const circleCircumference = Math.floor( 2 * Math.PI * progressCircle.getAttribute( 'r' ) );
const sendButton = document.querySelector( '.demo-update__send' );

BalloonEditor
    .create( {
        root: {
            element: document.querySelector( '#demo-update__editor' )
        },
        // Editor configuration.
        wordCount: {
            onUpdate: stats => {
                const charactersProgress = stats.characters / maxCharacters * circleCircumference;
                const isLimitExceeded = stats.characters > maxCharacters;
                const isCloseToLimit = !isLimitExceeded && stats.characters > maxCharacters * .8;
                const circleDashArray = Math.min( charactersProgress, circleCircumference );

// Set the stroke of the circle to show how many characters were typed.
                progressCircle.setAttribute( 'stroke-dasharray', `${ circleDashArray },${ circleCircumference }` );

// Display the number of characters in the progress chart. When the limit is exceeded,
                // display how many characters should be removed.
                if ( isLimitExceeded ) {
                    charactersBox.textContent = `-${ stats.characters - maxCharacters }`;
                } else {
                    charactersBox.textContent = stats.characters;
                }

wordsBox.textContent = `Words in the post: ${ stats.words }`;

// If the content length is close to the character limit, add a CSS class to warn the user.
                container.classList.toggle( 'demo-update__limit-close', isCloseToLimit );

// If the character limit is exceeded, add a CSS class that makes the content's background red.
                container.classList.toggle( 'demo-update__limit-exceeded', isLimitExceeded );

// If the character limit is exceeded, disable the send button.
                sendButton.toggleAttribute( 'disabled', isLimitExceeded );
            }
        }
    } );
```

Here is the HTML structure used to create the customized word and character count implementation above:

```html
<style>
    .demo-update {
        border: 1px solid var(--ck-color-base-border);
        border-radius: var(--ck-border-radius);
        box-shadow: 2px 2px 0px hsla( 0, 0%, 0%, 0.1 );
        margin: 1.5em 0;
        padding: 1em;
    }

.demo-update h3 {
        font-size: 18px;
        font-weight: bold;
        margin: 0 0 .5em;
        padding: 0;
    }

.demo-update .ck.ck-editor__editable_inline {
        border: 1px solid hsla( 0, 0%, 0%, 0.15 );
        transition: background .5s ease-out;
        min-height: 6em;
        margin-bottom: 1em;
    }

.demo-update__controls {
        display: flex;
        flex-direction: row;
        align-items: center;
    }

.demo-update__chart {
        margin-right: 1em;
    }

.demo-update__chart__circle {
        transform: rotate(-90deg);
        transform-origin: center;
    }

.demo-update__chart__characters {
        font-size: 13px;
        font-weight: bold;
    }

.demo-update__words {
        flex-grow: 1;
        opacity: .5;
    }

.demo-update__limit-close .demo-update__chart__circle {
        stroke: hsl( 30, 100%, 52% );
    }

.demo-update__limit-exceeded .ck.ck-editor__editable_inline {
        background: hsl( 0, 100%, 97% );
    }

.demo-update__limit-exceeded .demo-update__chart__circle {
        stroke: hsl( 0, 100%, 52% );
    }

.demo-update__limit-exceeded .demo-update__chart__characters {
        fill: hsl( 0, 100%, 52% );
    }
</style>

<div class="demo-update">
    <h3>Post editor with word count</h3>
    <div id="demo-update__editor">
        <p>Tourists frequently admit that <a href="https://en.wikipedia.org/wiki/Taj_Mahal">Taj Mahal</a> “simply cannot be described with words”.</p>
    </div>
    <div class="demo-update__controls">
        <span class="demo-update__words"></span>
        <svg class="demo-update__chart" viewbox="0 0 40 40" width="40" height="40" xmlns="http://www.w3.org/2000/svg">
            <circle stroke="hsl(0, 0%, 93%)" stroke-width="3" fill="none" cx="20" cy="20" r="17" />
            <circle class="demo-update__chart__circle" stroke="hsl(202, 92%, 59%)" stroke-width="3" stroke-dasharray="134,534" stroke-linecap="round" fill="none" cx="20" cy="20" r="17" />
            <text class="demo-update__chart__characters" x="50%" y="50%" dominant-baseline="central" text-anchor="middle"></text>
        </svg>
        <button type="button" class="demo-update__send">Send post</button>
    </div>
</div>
```

### Related features

CKEditor 5 provides other productivity-boosting features that you may find helpful:

* [Proofreading, spelling and grammar checking](#ckeditor5/latest/features/spelling-and-grammar-checking.html) – Track and correct any possible errors as you type.
* [Autosave](#ckeditor5/latest/features/autosave.html) – Never lose your content by accident, stay safe and automatically save.
* [Autoformatting](#ckeditor5/latest/features/autoformat.html) – Employ Markdown syntax for a faster and more efficient editing process.
* [Automatic text transformation](#ckeditor5/latest/features/text-transformation.html) – Automatically turn predefined snippets into their improved forms using the autocorrect feature.

### Common API

The [`WordCount`](../api/module_word-count_wordcount-WordCount.html) plugin provides:

* The [`wordCountContainer`](../api/module_word-count_wordcount-WordCount.html#member-wordCountContainer) property. It returns a self-updating HTML element which is updated with the current number of words and characters in the editor. You can remove the “Words” or “Characters” counters with a proper configuration of the [`config.wordCount.displayWords`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-displayWords) and [`config.wordCount.displayCharacters`](../api/module_word-count_wordcountconfig-WordCountConfig.html#member-displayCharacters) options.

* The [`update` event](../api/module_word-count_wordcount-WordCount.html#event-update), fired whenever the plugins update the number of counted words and characters. You can use it to run a custom callback function with updated values:

```js
  editor.plugins.get( 'WordCount' ).on( 'update', ( evt, stats ) => {
      // Prints the current content statistics.
      console.log( `Characters: ${ stats.characters }\nWords:      ${ stats.words }` );
  } );
  ```

Alternatively, you can use [`config.wordCount.onUpdate`](#ckeditor5/latest/features/word-count.html--reacting-to-updates) to register a similar callback via the editor configuration.

**Note**: For performance reasons, the `update` event is throttled so the statistics may not be up–to–date. Use the [`characters`](../api/module_word-count_wordcount-WordCount.html#member-characters) and [`words`](../api/module_word-count_wordcount-WordCount.html#member-words) plugin properties to retrieve the precise numbers on demand.

* The [`characters`](../api/module_word-count_wordcount-WordCount.html#member-characters) and [`words`](../api/module_word-count_wordcount-WordCount.html#member-words) properties from which you can retrieve the stats at any moment.

### Contribute

The source code of the feature is available on GitHub at <https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-word-count>.

<a id="ckeditor5/latest/framework/architecture/core-editor-architecture.html">source file: "ckeditor5/latest/framework/architecture/core-editor-architecture.html"</a>

## Core editor architecture

The [`@ckeditor/ckeditor5-core`](https://www.npmjs.com/package/@ckeditor/ckeditor5-core) package provides the core classes that tie every editor together: the editor classes, plugins, commands, and the event system with observables.

### Editor classes

The [`Editor`](../../api/module_core_editor_editor-Editor.html) class represents the base of the editor. It is the entry point of the application, gluing all other components. It provides a few properties that you need to know:

* [`config`](../../api/module_core_editor_editor-Editor.html#member-config) – The configuration object.
* [`plugins`](../../api/module_core_editor_editor-Editor.html#member-plugins) and [`commands`](../../api/module_core_editor_editor-Editor.html#member-commands) – The collection of loaded plugins and commands.
* [`model`](../../api/module_core_editor_editor-Editor.html#member-model) – The entry point to the [editor’s data model](#ckeditor5/latest/framework/architecture/editing-engine.html--model).
* [`data`](../../api/module_core_editor_editor-Editor.html#member-data) – The data controller. It controls how data is retrieved from the document and set inside it.
* [`editing`](../../api/module_core_editor_editor-Editor.html#member-editing) – The editing controller. It controls how the model is rendered to the user for editing.
* [`keystrokes`](../../api/module_core_editor_editor-Editor.html#member-keystrokes) – The keystroke handler. It allows to bind keystrokes to actions.

Besides that, the editor exposes a few of methods:

* [`create()`](../../api/module_core_editor_editor-Editor.html#static-function-create) – The static `create()` method. Editor constructors are protected and you should create editors using this static method. It allows the initialization process to be asynchronous.
* [`destroy()`](../../api/module_core_editor_editor-Editor.html#function-destroy) – Destroys the editor.
* [`execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) – Executes the given command.
* [`setData()`](../../api/module_core_editor_editor-Editor.html#function-setData) and [`getData()`](../../api/module_core_editor_editor-Editor.html#function-getData) – A way to retrieve the data from the editor and set the data in the editor. The data format is controlled by the [data controller’s data processor](../../api/module_engine_controller_datacontroller-DataController.html#member-processor). It does not need to be a string (it can be, for example, a JSON if you implement such a [data processor](../../api/module_engine_dataprocessor_dataprocessor-DataProcessor.html)). See, for example, how to [produce Markdown output](#ckeditor5/latest/features/markdown.html).

For the full list of methods check the [API docs](../../api/index.html) of the editor class you use. Specific editor implementations may provide additional methods.

The [`Editor`](../../api/module_core_editor_editor-Editor.html) class is a base to implement your own editors. CKEditor 5 Framework comes with a few editor types (for example, [classic](../../api/module_editor-classic_classiceditor-ClassicEditor.html), [inline](../../api/module_editor-inline_inlineeditor-InlineEditor.html), [balloon](../../api/module_editor-balloon_ballooneditor-BalloonEditor.html) and [decoupled](../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html)) but you can freely implement editors which work and look completely different. The only requirement is that you implement the [`Editor`](../../api/module_core_editor_editor-Editor.html) interface.

### Plugins

Plugins are a way to introduce editor features. In CKEditor 5 even [typing](../../api/module_typing_typing-Typing.html) is a plugin. What is more, the [`Typing`](../../api/module_typing_typing-Typing.html) plugin depends on the [`Input`](../../api/module_typing_input-Input.html) and [`Delete`](../../api/module_typing_delete-Delete.html) plugins which are responsible for handling the methods of inserting text and deleting content, respectively. At the same time, some plugins need to customize `Backspace` behavior in certain cases and handle it by themselves. This leaves the base plugins free of any non-generic knowledge.

Another important aspect of how existing CKEditor 5 plugins are implemented is the split into engine and UI parts. For example, the [`BoldEditing`](../../api/module_basic-styles_bold_boldediting-BoldEditing.html) plugin introduces the schema definition, mechanisms rendering `<strong>` tags, commands to apply and remove bold from text, while the [`BoldUI`](../../api/module_basic-styles_bold_boldui-BoldUI.html) plugin adds the UI of the feature (that is, the button). This feature split is meant to allow for greater reuse (one can take the engine part and implement their own UI for a feature) as well as for running CKEditor 5 on the server side. Finally, there is the [`Bold`](../../api/module_basic-styles_bold-Bold.html) plugin that brings both plugins for a full experience.

The summary of this is that:

* Every feature is implemented or at least enabled by a plugin.
* Plugins are highly granular.
* Plugins know everything about the editor.
* Plugins should know as little about other plugins as possible.

These are the rules based on which the official plugins were implemented. When implementing your own plugins, if you do not plan to publish them, you can reduce this list to the first point.

After this lengthy introduction (which is aimed at making it easier for you to digest the existing plugins), the plugin API can be explained.

All plugins need to implement the [`PluginInterface`](../../api/module_core_plugin-PluginInterface.html). The easiest way to do so is by inheriting from the [`Plugin`](../../api/module_core_plugin-Plugin.html) class. The plugin initialization code should be located in the [`init()`](../../api/module_core_plugin-PluginInterface.html#function-init) method (which can return a promise). If some piece of code needs to be executed after other plugins are initialized, you can put it in the [`afterInit()`](../../api/module_core_plugin-PluginInterface.html#function-afterInit) method. The dependencies between plugins are implemented using the static [`requires`](../../api/module_core_plugin-PluginStaticMembers.html#member-requires) property.

```js
import MyDependency from 'some/other/plugin';

class MyPlugin extends Plugin {
    static get requires() {
        return [ MyDependency ];
    }

init() {
        // Initialize your plugin here.

this.editor; // The editor instance which loaded this plugin.
    }
}
```

You can see how to implement a simple plugin in the [step-by-step tutorial](#ckeditor5/latest/framework/tutorials/crash-course/editor.html).

### Commands

A command is a combination of an action (a callback) and a state (a set of properties). For instance, the `bold` command applies or removes the bold attribute from the selected text. If the text in which the selection is placed has bold applied already, the value of the command is `true`, `false` otherwise. If the `bold` command can be executed on the current selection, it is enabled. If not (because, for example, bold is not allowed in this place), it is disabled.

All commands need to inherit from the [`Command`](../../api/module_core_command-Command.html) class. Commands need to be added to the editor’s [command collection](../../api/module_core_editor_editor-Editor.html#member-commands) so they can be executed by using the [`Editor#execute()`](../../api/module_core_editor_editor-Editor.html#function-execute) method.

Take this example:

```js
class MyCommand extends Command {
    execute( message ) {
        console.log( message );
    }
}

class MyPlugin extends Plugin {
    init() {
        const editor = this.editor;

editor.commands.add( 'myCommand', new MyCommand( editor ) );
    }
}
```

Calling `editor.execute( 'myCommand', 'Foo!' )` will log `Foo!` to the console.

To see how state management of a typical command like `bold` is implemented, have a look at some pieces of the [`AttributeCommand`](../../api/module_basic-styles_attributecommand-AttributeCommand.html) class on which `bold` is based.

The first thing to notice is the [`refresh()`](../../api/module_core_command-Command.html#function-refresh) method:

```js
refresh() {
    const doc = this.editor.document;

this.value = doc.selection.hasAttribute( this.attributeKey );
    this.isEnabled = doc.schema.checkAttributeInSelection(
        doc.selection, this.attributeKey
    );
}
```

This method is called automatically (by the command itself) when [any changes are applied to the model](../../api/module_engine_model_document-ModelDocument.html#event-change). This means that the command automatically refreshes its own state when anything changes in the editor.

The important thing about commands is that every change in their state as well as calling the `execute()` method fire events. Some examples of these are [`#set:value`](../../api/module_core_command-Command.html#event-set:%7Bproperty%7D) and [`#change:value`](../../api/module_core_command-Command.html#event-change:%7Bproperty%7D) when you change the `#value` property and [`#execute`](../../api/module_core_command-Command.html#event-execute) when you execute the command.

> **Note**
>
> Read more about this mechanism in the [Observables](#ckeditor5/latest/framework/deep-dive/observables.html) deep dive guide.

These events make it possible to control the command from the outside. For instance, if you want to block specific commands when some condition is true (for example, according to your application logic, they should be temporarily unavailable) and there is no other, cleaner way to do that, you can disable the command using the built-in helper [`forceDisabled()`](../../api/module_core_command-Command.html#function-forceDisabled) (and re-enable it with [`clearForceDisabled()`](../../api/module_core_command-Command.html#function-clearForceDisabled)):

```js
// Disabling the command.
const boldCommand = editor.commands.get( 'bold' );
boldCommand.forceDisabled( 'MyFeature' );

// Enabling the command again.
boldCommand.clearForceDisabled( 'MyFeature' );
```

The command will remain disabled until `clearForceDisabled( 'MyFeature' )` is called and no other feature keeps it disabled, regardless of how many times `someCommand.refresh()` is called.

By default, editor commands are blocked when the editor is in the [read-only](../../api/module_core_editor_editor-Editor.html#member-isReadOnly) mode. However, if your command does not change the editor data and you want it to stay enabled in the read-only mode, you can set the [`affectsData`](../../api/module_core_command-Command.html#member-affectsData) flag to `false`:

```js
class MyAlwaysEnabledCommand extends Command {
    constructor( editor ) {
        super( editor );

// This command will remain enabled even when the editor is read-only.
        this.affectsData = false;
    }
}
```

The [`affectsData`](../../api/module_core_command-Command.html#member-affectsData) flag will also affect the command in [other editor modes](#ckeditor5/latest/features/read-only.html--related-features) that restrict user write permissions.

> **Note**
>
> The `affectsData` flag is set to `true` by default for all editor commands and, unless your command should be enabled when the editor is read-only, you do not need to change it. The flag is immutable during the lifetime of the editor.

### Event system and observables

CKEditor 5 has an event-based architecture so you can find [`Emitter`](../../api/module_utils_emittermixin-Emitter.html) and [`Observable`](../../api/module_utils_observablemixin-Observable.html) mixed all over the place. Both mechanisms allow for decoupling the code and make it extensible.

Most of the classes that have already been mentioned are either emitters or observables (observable is an emitter, too). An emitter can emit (fire) events as well as listen to them.

```js
class MyPlugin extends Plugin {
    init() {
        // Make MyPlugin listen to someCommand#execute.
        this.listenTo( someCommand, 'execute', () => {
            console.log( 'someCommand was executed' );
        } );

// Make MyPlugin listen to someOtherCommand#execute and block it.
        // You listen with a high priority to block the event before
        // someOtherCommand's execute() method is called.
        this.listenTo( someOtherCommand, 'execute', evt => {
            evt.stop();
        }, { priority: 'high' } );
    }

// Inherited from Plugin:
    destroy() {
        // Removes all listeners added with this.listenTo();
        this.stopListening();
    }
}
```

The second listener to `'execute'` shows one of the common practices in CKEditor 5 code. Basically, the default action of `'execute'` (which is calling the `execute()` method) is registered as a listener to that event with a default priority. Thanks to that, by listening to the event using `'low'` or `'high'` priorities you can execute some code before or after `execute()` is really called. If you stop the event, then the `execute()` method will not be called at all. In this particular case, the [`Command#execute()`](../../api/module_core_command-Command.html#function-execute) method was decorated with the event using the [`ObservableMixin#decorate()`](../../api/module_utils_observablemixin-Observable.html#function-decorate) function:

```js
import { ObservableMixin, mix } from 'ckeditor5';

class Command {
    constructor() {
        this.decorate( 'execute' );
    }

// Will now fire the #execute event automatically.
    execute() {}
}

// Mix ObservableMixin into Command.
mix( Command, ObservableMixin );
```

> **Note**
>
> Check out the [event system deep dive guide](#ckeditor5/latest/framework/deep-dive/event-system.html) and the [observables deep dive guide](#ckeditor5/latest/framework/deep-dive/observables.html) to learn more about the advanced usage of events and observables with some additional examples.

Besides decorating methods with events, observables allow to observe their chosen properties. For instance, the `Command` class makes its `#value` and `#isEnabled` observable by calling [`set()`](../../api/module_utils_observablemixin-Observable.html#function-set:KEY_VALUE):

```js
class Command {
    constructor() {
        this.set( 'value', undefined );
        this.set( 'isEnabled', undefined );
    }
}

mix( Command, ObservableMixin );

const command = new Command();

command.on( 'change:value', ( evt, propertyName, newValue, oldValue ) => {
    console.log(
        `${ propertyName } has changed from ${ oldValue } to ${ newValue }`
    );
} )

command.value = true; // -> 'value has changed from undefined to true'
```

Observables have one more feature which is widely used by the editor (especially in the UI library) – the ability to bind the value of one object’s property to the value of some other property or properties (of one or more objects). This, of course, can also be processed by callbacks.

Assuming that `target` and `source` are observables and that used properties are observable:

```js
target.bind( 'foo' ).to( source );

source.foo = 1;
target.foo; // -> 1

// Or:
target.bind( 'foo' ).to( source, 'bar' );

source.bar = 1;
target.foo; // -> 1
```

You can also find more about data bindings in the user interface in the [UI library architecture](#ckeditor5/latest/framework/architecture/ui-library.html) guide.

### Read next

Once you have learned how to create plugins and commands you can read how to implement real editing features in the [Editing engine](#ckeditor5/latest/framework/architecture/editing-engine.html) guide.

<a id="ckeditor5/latest/framework/architecture/editing-engine.html">source file: "ckeditor5/latest/framework/architecture/editing-engine.html"</a>

## Editing engine

The [`@ckeditor/ckeditor5-engine`](https://www.npmjs.com/package/@ckeditor/ckeditor5-engine) package is the largest and most complex part of CKEditor 5. It is built around three layers: the model (the editor’s data), the view (its rendering layer), and the conversion that maps between them.

> **Tip**
>
> We recommend using the official [CKEditor 5 inspector](#ckeditor5/latest/framework/development-tools/inspector.html) for development and debugging. It will give you tons of useful information about the state of the editor such as internal data structures, selection, commands, and many more.

### Overview

The editing engine uses a Model-View-Controller (MVC) architecture. While the engine does not enforce a specific structure, most implementations follow this pattern:

The architecture has three layers: **model**, **controller**, and **view**. There is one **model document** that gets **converted** into two separate views: the **editing view** and the **data view**. These views represent different things:

* The editing view shows the content users see in the browser and interact with.
* The data view handles the editor’s input and output data in a format the data processor understands.

Both views use virtual DOM structures (custom, DOM-like structures) that converters and features work with. These structures are then **rendered** to the actual DOM.

The deep blue blocks in the diagram represent code from editor features (plugins). Features control what changes happen to the model, how those changes convert to the view, and how the model updates based on events.

Let’s explore each layer separately.

### Model

The model is a DOM-like tree structure consisting of [elements](../../api/module_engine_model_element-ModelElement.html) and [text nodes](../../api/module_engine_model_text-ModelText.html). Unlike the actual DOM, both elements and text nodes in the model can have attributes.

Like the DOM, the model structure lives inside a [document](../../api/module_engine_model_document-ModelDocument.html) that contains [root elements](../../api/module_engine_model_document-ModelDocument.html#member-roots). The model and view can both have multiple roots. The document also holds the [selection](../../api/module_engine_model_documentselection-ModelDocumentSelection.html) and the [history of its changes](../../api/module_engine_model_history-History.html).

The document, its [schema](../../api/module_engine_model_schema-ModelSchema.html), and [document markers](../../api/module_engine_model_markercollection-MarkerCollection.html) are properties of the [`Model`](../../api/module_engine_model_model-Model.html) class. You can access an instance of the `Model` class through [`editor.model`](../../api/module_core_editor_editor-Editor.html#member-model). Besides holding these properties, the model provides the API for changing the document and its markers.

```js
editor.model;                       // -> The data model
editor.model.document;              // -> The document
editor.model.document.getRoot();    // -> The document's root
editor.model.document.selection;    // -> The document's selection
editor.model.schema;                // -> The model's schema
```

#### Changing the model

You can only change the document structure, selection, and create elements using the [model writer](../../api/module_engine_model_writer-ModelWriter.html). Access the writer instance in the [`change()`](../../api/module_engine_model_model-Model.html#function-change) and the [`enqueueChange()`](../../api/module_engine_model_model-Model.html#function-enqueueChange:DEFAULT_BATCH) blocks.

```js
// Inserts text "foo" at the selection position
editor.model.change( writer => {
    writer.insertText( 'foo', editor.model.document.selection.getFirstPosition() );
} );

// Apply bold to the entire selection
editor.model.change( writer => {
    for ( const range of editor.model.document.selection.getRanges() ) {
        writer.setAttribute( 'bold', true, range );
    }
} );
```

All changes within a single `change()` block combine into one undo step (added to a single [batch](../../api/module_engine_model_batch-Batch.html)). When you nest `change()` blocks, all changes go to the outermost block’s batch. For example, this code creates a single undo step:

```js
editor.model.change( writer => {
    writer.insertText( 'foo', paragraph, 'end' ); // foo

editor.model.change( writer => {
        writer.insertText( 'bar', paragraph, 'end' ); // foobar
    } );

writer.insertText( 'bom', paragraph, 'end' ); // foobarbom
} );
```

> **Important**
>
> All document structure changes happen through [operations](../../api/module_engine_model_operation_operation-Operation.html). This concept comes from Operational Transformation (OT), a technology that enables collaboration. This approach requires the system to transform every operation by every other operation to determine the result of concurrently applied operations.
>
> However, OT requires a small set of operations and CKEditor 5 uses a non-linear tree model—rather than the flat, array-like models typical in OT. As a result, the set of potential semantic changes is more complex. In CKEditor 5, you organize operations into [batches](../../api/module_engine_model_batch-Batch.html), which act as single undo steps.

#### Text attributes

Text styles like “bold” and “italic” are stored in the model as text attributes, not as elements (think of them like element attributes). This DOM structure:

```html
<p>
    "Foo "
    <strong>
        "bar"
    </strong>
</p>
```

translates to this model structure:

```html
<paragraph>
    "Foo "  // text node
    "bar"   // text node with bold=true attribute
</paragraph>
```

This representation of inline text styling significantly reduces the complexity of algorithms working with the model. For instance, with this DOM structure:

```html
<p>
    "Foo "
    <strong>
        "bar"
    </strong>
</p>
```

If you have a selection before the letter “b” (`"Foo ^bar"`), is this position inside or outside `<strong>`? With [native DOM Selection](https://developer.mozilla.org/en-US/docs/Web/API/Selection), you could get both positions – one anchored in `<p>` and another in `<strong>`. In CKEditor 5, this position translates exactly to `"Foo ^bar"`.

#### Selection attributes

How does CKEditor 5 know that the selection should “be bold” in the case described above? It matters because it determines whether typed text will be bold.

The selection also [has attributes](../../api/module_engine_model_selection-ModelSelection.html#function-setAttribute). If the selection is at `"Foo ^bar"` with the attribute `bold=true`, you know the user will type bold text.

#### Indexes and offsets

In the previous example, inside `<paragraph>` there are two text nodes: `"Foo "` and `"bar"`. If you know how [native DOM Ranges](https://developer.mozilla.org/en-US/docs/Web/API/Range) work, you might ask: “If the selection is at the boundary of two text nodes, is it anchored in the left one, the right one, or in the containing element?”

It is another problem with DOM APIs. Positions outside and inside some element can be visually identical, and they can be anchored inside or outside a text node (if the position is at a text node boundary). It creates complications when implementing editing algorithms.

To avoid these problems and enable real collaborative editing, CKEditor 5 uses **indexes** and **offsets**. Indexes relate to nodes (elements and text nodes) while offsets relate to positions. For example, in this structure:

```html
<paragraph>
    "Foo "
    <imageInline></imageInline>
    "bar"
</paragraph>
```

* The `"Foo "` text node is at index `0` in its parent
* `<imageInline>` is at index `1`
* `"bar"` is at index `2`

Meanwhile, offset `x` in `<paragraph>` translates to:

| Offset | Position                                                     | Node            |
| ------ | ------------------------------------------------------------ | --------------- |
| `0`    | `<paragraph>^Foo <imageInline></imageInline>bar</paragraph>` | `"Foo "`        |
| `1`    | `<paragraph>F^oo <imageInline></imageInline>bar</paragraph>` | `"Foo "`        |
| `4`    | `<paragraph>Foo ^<imageInline></imageInline>bar</paragraph>` | `<imageInline>` |
| `6`    | `<paragraph>Foo <imageInline></imageInline>b^ar</paragraph>` | `"bar"`         |

#### Positions, ranges and selections

The engine defines three levels of classes that work with offsets:

* A [`ModelPosition`](../../api/module_engine_model_position-ModelPosition.html) instance contains an [array of offsets](../../api/module_engine_model_position-ModelPosition.html#member-path) (which is called a “path”). See the [`Position#path` API documentation](../../api/module_engine_model_position-ModelPosition.html#member-path) for examples of how paths work.
* A [`ModelRange`](../../api/module_engine_model_range-ModelRange.html) contains two positions: [start](../../api/module_engine_model_range-ModelRange.html#member-start) and [end](../../api/module_engine_model_range-ModelRange.html#member-end).
* Finally, there is the [`ModelSelection`](../../api/module_engine_model_selection-ModelSelection.html) class, which represents a selection in the model. A `ModelSelection` can contain one or more ranges, selection attributes, and information about its direction (whether it was made from left to right or right to left). You can create and modify as many `ModelSelection` instances as you need. In addition, a single [`ModelDocumentSelection`](../../api/module_engine_model_documentselection-ModelDocumentSelection.html) instance always represents the user’s actual selection in the document. This `ModelDocumentSelection` can only be changed using the [model writer](../../api/module_engine_model_writer-ModelWriter.html) and is automatically kept in sync when the document structure changes.

#### Markers

Markers are a special type of range with these characteristics:

* Managed by [`MarkerCollection`](../../api/module_engine_model_markercollection-MarkerCollection.html).
* Can only be created and changed through the [model writer](../../api/module_engine_model_writer-ModelWriter.html).
* Can be synchronized over the network with collaborating clients.
* Automatically update when the document structure changes.
* Can be converted to the editing view to display in the editor (as [highlights](../../api/module_engine_conversion_downcasthelpers-DowncastHelpers.html#function-markerToHighlight) or [elements](../../api/module_engine_conversion_downcasthelpers-DowncastHelpers.html#function-markerToElement)).
* Can be converted [converted to the data view](../../api/module_engine_conversion_downcasthelpers-DowncastHelpers.html#function-markerToData) to store with the document data.
* Can be [loaded with the document data](../../api/module_engine_conversion_upcasthelpers-UpcastHelpers.html#function-dataToMarker).

Markers are perfect for storing and maintaining additional data related to document portions, such as comments or other users’ selections.

When multiple markers share a position in the model, the downcast dispatcher sorts them into a deterministic order — see [Downcasting overlapping markers](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html--downcasting-overlapping-markers) for the exact rules.

#### Schema

The [model’s schema](../../api/module_engine_model_schema-ModelSchema.html) defines several aspects of the model structure:

* **Where nodes are allowed or disallowed,** for example, a `paragraph` is allowed in `$root`, but not in `heading1`.
* **What attributes are allowed for a node,** for example, an `image` can have `src` and `alt` attributes.
* **Additional semantics of model nodes,** for example, an `image` is of the “object” type and a `paragraph` is of the “block” type.

The schema can also define specifically disallowed children and attributes. It is useful when nodes inherit properties from other nodes but need to exclude certain things:

* **Disallowed nodes in certain places,** for example, a custom `specialParagraph` element inherits all properties from `paragraph` but disallows `imageInline`.
* **Disallowed attributes on a node,** for example, a custom `specialPurposeHeading` element inherits attributes from `heading2` but does not allow the `alignment` attribute.

Features and the engine use this information to make processing decisions. The schema affects:

* What happens with pasted content and what gets filtered out (note: for pasting, conversion is also important. HTML elements and attributes not converted by registered converters are filtered out before becoming model nodes, so the schema does not apply to them).
* Which elements the heading feature can be applied to (which blocks can become headings and which elements are blocks).
* Which elements can be wrapped with a block quote.
* Whether the bold button is enabled when the selection is in a heading (and whether text in the heading can be made bold).
* Where the selection can be placed (only in text nodes and on object elements).
* And more.

By default, editor plugins configure the schema. We recommend that every editor feature come with rules that enable and pre-configure it. It ensures plugin users can enable features without worrying about reconfiguring their schema.

> **Important**
>
> There is no straightforward way to override the schema pre-configured by features. If you want to override default settings when initializing the editor, the best solution is to replace `editor.model.schema` with a new instance. However, this requires rebuilding the editor.

Access the schema instance at [`editor.model.schema`](../../api/module_engine_model_model-Model.html#member-schema). For an in-depth guide on using the schema API, see the [Schema Deep Dive guide](#ckeditor5/latest/framework/deep-dive/schema.html).

### View

Let’s look at the editing engine’s architecture again:

We have discussed the topmost layer – the model. The model layer creates an abstraction over the data. Its format was designed to allow storing and modifying data conveniently while enabling complex features. Most features operate on the model (reading from it and changing it).

The view, on the other hand, is an abstract representation of the DOM structure that should be presented to the user for editing and that should (in most cases) represent the editor’s input and output (the data returned by `editor.getData()`, data set by `editor.setData()`, pasted content, etc.).

This means:

* The view is another custom structure.
* It resembles the DOM. While the model’s tree structure only slightly resembled the DOM (for example, by introducing text attributes), the view is much closer. In other words, it is a **virtual DOM.**
* There are two “pipelines”: the [**editing pipeline**](#ckeditor5/latest/framework/architecture/editing-engine.html--editing-pipeline) (also called the “editing view”) and the [**data pipeline**](#ckeditor5/latest/framework/architecture/editing-engine.html--data-pipeline) (the “data view”). Think of them as two separate views of one model. The editing pipeline renders and handles the DOM that users see and can edit. The data pipeline is used when you call the `editor.getData()`, `editor.setData()`, or paste content into the editor.
* The views are rendered to the DOM by the [`ViewRenderer`](../../api/module_engine_view_renderer-ViewRenderer.html), which handles all the quirks required to tame `contentEditable` used in the editing pipeline.

The two views are visible in the API:

```js
editor.editing;                 // The editing pipeline (EditingController)
editor.editing.view;            // The editing view's controller
editor.editing.view.document;   // The editing view's document
editor.data;                    // The data pipeline (DataController)
```

> **Important**
>
> The data pipeline does not have a document or a view controller. It operates on detached view structures created for processing data.
>
> The data pipeline is much simpler than the editing pipeline. In the following sections, we’ll discuss the editing view.
>
> Refer to the [`EditingController`](../../api/module_engine_controller_editingcontroller-EditingController.html)'s and [`DataController`](../../api/module_engine_controller_datacontroller-DataController.html)'s API documentation for more details.

#### Element types and custom data

The structure of the view closely resembles that of the DOM. While the semantics of HTML are defined by its specification, the view structure is “DTD-free.” To provide additional context and better express content semantics, the view defines six element types ([`ViewContainerElement`](../../api/module_engine_view_containerelement-ViewContainerElement.html), [`ViewAttributeElement`](../../api/module_engine_view_attributeelement-ViewAttributeElement.html), [`ViewEmptyElement`](../../api/module_engine_view_emptyelement-ViewEmptyElement.html), [`ViewRawElement`](../../api/module_engine_view_rawelement-ViewRawElement.html), [`ViewUIElement`](../../api/module_engine_view_uielement-ViewUIElement.html), and [`ViewEditableElement`](../../api/module_engine_view_editableelement-ViewEditableElement.html)) as well as [“custom properties”](../../api/module_engine_view_element-ViewElement.html#function-getCustomProperty) (custom, non-rendered properties on elements). Editor features provide this additional information, and the [`ViewRenderer`](../../api/module_engine_view_renderer-ViewRenderer.html) and [converters](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion) then use it.

The element types are:

* **Container element:** Elements that build the content structure. Used for block elements like `<p>`, `<h1>`, `<blockQuote>`, `<li>`, etc.
* **Attribute element:** Most model text attributes convert to view attribute elements. Used mostly for inline styling elements like `<strong>`, `<i>`, `<a>`, `<code>`. The view writer flattens similar attribute elements. For example, `<a href="..."><a class="bar">x</a></a>` automatically optimizes to `<a href="..." class="bar">x</a>`.
* **Empty element:** Elements that must not have child nodes, like `<img>`.
* **UI element:** Elements that are not part of the “data” but need to be “inlined” in the content. The selection ignores them (jumps over them), as does the view writer in general. The contents and events from these elements are also filtered out.
* **Raw element:** Elements that work as data containers (“wrappers,” “sandboxes”), but their children are transparent to the editor. Useful to render non-standard data, but the editor should not be concerned with what it is or how it works. Users cannot place the selection inside a raw element, split it into smaller chunks, or modify its content directly.
* **Editable element:** Elements used as “nested editable elements” of non-editable content fragments. For example, a caption in an image widget, where the `<figure>` wrapping the image is not editable (it is a widget) and the `<figcaption>` inside it is an editable element.

Additionally, you can define [custom properties](../../api/module_engine_view_element-ViewElement.html#function-getCustomProperty) to store information like:

* Whether an element is a widget (added by [`toWidget()`](../../api/module_widget_utils.html#function-toWidget)).
* How an element should be marked when a [marker](#ckeditor5/latest/framework/architecture/editing-engine.html--markers) highlights it.
* Whether an element belongs to a particular feature – if it is a link, progress bar, caption, etc.

##### Non-semantic views

Not all view trees need to (or can) be built with semantic element types. View structures generated directly from input data (for instance, pasted HTML or with `editor.setData()`) consist only of [base element](../../api/module_engine_view_element-ViewElement.html) instances. These view structures are (usually) converted to model structures and then converted back to view structures for editing or data retrieval, at which point they become semantic views again.

The additional information in semantic views and the special operations feature developers want to perform on those trees (compared to simple tree operations on non-semantic views) means both structures need to be [modified by different tools](#ckeditor5/latest/framework/architecture/editing-engine.html--changing-the-view).

We’ll explain [conversion](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion) later in this guide. For now, just know that there are semantic views for rendering and data retrieval, and non-semantic views for data input.

#### Changing the view

Do not change the view manually unless you know exactly what you are doing. If the view needs to change, in most cases the model should change first. Then, the changes you apply to the model are converted to the view by specific converters (see [conversion](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion) for more details).

Sometimes you have to change the view manually if the model does not reflect the cause of the change. For example, the model does not store information about focus, which is a [property of the view](../../api/module_engine_view_document-ViewDocument.html#member-isFocused). When the focus changes, and you want to represent that in an element’s class, you need to change that class manually.

For that, like in the model, use the `change()` block (of the view) where you will have access to the view downcast writer.

```js
editor.editing.view.change( writer => {
    writer.insert( position, writer.createText( 'foo' ) );
} );
```

> **Important**
>
> There are two view writers:
>
> * [`ViewDowncastWriter`](../../api/module_engine_view_downcastwriter-ViewDowncastWriter.html) – available in the `change()` blocks, used during downcasting the model to the view. It operates on a “semantic view,” so a view structure that differentiates between different types of elements (see [Element types and custom data](#ckeditor5/latest/framework/architecture/editing-engine.html--element-types-and-custom-data)).
> * [`ViewUpcastWriter`](../../api/module_engine_view_upcastwriter-ViewUpcastWriter.html) – a writer to be used when pre-processing the “input” data (for example, pasted content), which usually happens before the conversion (upcasting) to the model. It operates on [“non-semantic views”](#ckeditor5/latest/framework/architecture/editing-engine.html--non-semantic-views).

#### Positions

Like [in the model](https://github.com/ckeditor/ckeditor5/pull/19651#positions-ranges-and-selections), there are 3 levels of classes in the view that describe points in the view structure: **positions**, **ranges**, and **selections**.

* A **position** is a single point in the document.
* A **range** consists of two positions (start and end).
* A **selection** consists of one or more ranges with a direction (whether it was made from left to right or right to left).

A view range is similar to its [DOM counterpart](https://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html). View positions are represented by a parent and an offset in that parent. This means, unlike model offsets, view offsets describe:

* Points between child nodes of the position’s parent if it is an element.
* Or points between characters of a text node if the position’s parent is a text node.

Therefore, view offsets work more like model indexes than model offsets.

| Parent  | Offset | Position                    |
| ------- | ------ | --------------------------- |
| `<p>`   | `0`    | `<p>^Foo<img></img>bar</p>` |
| `<p>`   | `1`    | `<p>Foo^<img></img>bar</p>` |
| `<p>`   | `2`    | `<p>Foo<img></img>^bar</p>` |
| `<img>` | `0`    | `<p>Foo<img>^</img>bar</p>` |
| `Foo`   | `1`    | `<p>F^oo<img></img>bar</p>` |
| `Foo`   | `3`    | `<p>Foo^<img></img>bar</p>` |

As you can see, two of these positions represent what you might consider the same point in the document:

* `{ parent: paragraphElement, offset: 1 }`
* `{ parent: fooTextNode, offset: 3 }`

Some browsers (Safari, Chrome, and Opera) consider them identical when used in a selection and often normalize the first position (anchored in an element) to a position anchored in a text node (the second position). Do not be surprised if the view selection is not directly where you expect it to be. The good news is that the CKEditor 5 renderer can tell that two positions are identical and avoids unnecessarily re-rendering the DOM selection.

> **Note**
>
> Sometimes in the documentation, you will find positions marked in HTML with `{}` and `[]` characters. The difference is that `{}` indicates positions anchored in text nodes and `[]` indicates positions in elements. For instance:
>
> ```html
> <p>{Foo]<b>Bar</b></p>
> ```
>
> describes a range that starts in the text node `Foo` at offset `0` and ends in the `<p>` element at offset `1`.

The inconvenient representation of DOM positions is yet another reason to think about and work with model positions.

#### Observers

To create a safer and more useful abstraction over native DOM events, the view implements the concept of [observers](../../api/module_engine_view_observer_observer-Observer.html). It improves the editor’s testability and simplifies listeners added by editor features by transforming native events into a more useful form.

An observer listens to one or more DOM events, does preliminary processing, and then fires a custom event on the [view document](../../api/module_engine_view_document-ViewDocument.html). An observer creates an abstraction not only of the event itself, but also of its data. Ideally, an event’s consumer should not have any access to the native DOM.

By default, the view adds these observers:

* [`MutationObserver`](../../api/module_engine_view_observer_mutationobserver-MutationObserver.html)
* [`SelectionObserver`](../../api/module_engine_view_observer_selectionobserver-SelectionObserver.html)
* [`FocusObserver`](../../api/module_engine_view_observer_focusobserver-FocusObserver.html)
* [`KeyObserver`](../../api/module_engine_view_observer_keyobserver-KeyObserver.html)
* [`FakeSelectionObserver`](../../api/module_engine_view_observer_fakeselectionobserver-FakeSelectionObserver.html)
* [`CompositionObserver`](../../api/module_engine_view_observer_compositionobserver-CompositionObserver.html)
* [`ArrowKeysObserver`](../../api/module_engine_view_observer_arrowkeysobserver-ArrowKeysObserver.html)

Additionally, some features add their own observers. For instance, the [clipboard feature](../../api/module_clipboard_clipboard-Clipboard.html) adds [`ClipboardObserver`](../../api/module_clipboard_clipboardobserver-ClipboardObserver.html).

> **Tip**
>
> For a complete list of events fired by observers, check the [`ViewDocument`](../../api/module_engine_view_document-ViewDocument.html)'s list of events.

You can add your own observer (which should be a subclass of [`Observer`](../../api/module_engine_view_observer_observer-Observer.html)) by using the [`view.addObserver()`](../../api/module_engine_view_view-EditingView.html#function-addObserver) method. Check the [code of existing observers](https://github.com/ckeditor/ckeditor5-engine/tree/master/src/view/observer) to learn how to write them.

> **Important**
>
> Since all events are by default fired on [`ViewDocument`](../../api/module_engine_view_document-ViewDocument.html), we recommend that third-party packages prefix their events with a project identifier to avoid name collisions. For example, MyApp’s features should fire `myApp:keydown` instead of `keydown`.

### Conversion

We have talked about the model and the view as two completely independent subsystems. It is time to connect them. The three main situations where these two layers meet are:

| Conversion name                                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Data upcasting](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html)                            | **Loading the data to the editor.** First, a [`DataProcessor`](../../api/module_engine_dataprocessor_dataprocessor-DataProcessor.html) processes the data (for example, an HTML string) into a view [`ViewDocumentFragment`](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html). Then, the conversion process turns this view document fragment into a model [document fragment](../../api/module_engine_model_documentfragment-ModelDocumentFragment.html). Finally, the editor inserts this content into the model document’s [root](../../api/module_engine_model_document-ModelDocument.html#member-roots). |
| [Data downcasting](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html--downcast-pipelines)    | **Retrieving the data from the editor.** First, the editor converts the content of the model’s root to a view document fragment. Then, a data processor transforms this view document fragment into the target data format.                                                                                                                                                                                                                                                                                                                                                                                                           |
| [Editing downcasting](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html--downcast-pipelines) | **Rendering the editor content to the user for editing.** This process runs throughout the editor’s lifetime after initialization. First, once _data upcasting_ finishes, the editor converts the model’s root to the view’s root. Afterward, the editor renders this view root to the user inside the editor’s `contentEditable` DOM element (also called “the editable element”). Whenever the model changes, the editor converts those changes to the view. If necessary (for example, if the DOM differs from the view), the editor re-renders the view to the DOM.                                                               |

Let’s look at the diagram of the engine’s MVC architecture and see where each conversion process happens:

#### Data pipeline

[**Data upcasting**](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html) is a process that starts in the bottom-left corner of the diagram (in the view layer), passes from the data view through a converter in the controller layer to the model document in the top. As you can see, it goes from bottom to top, hence “upcasting.” Furthermore, it is handled by the data pipeline, hence “data upcasting.” Note that data upcasting is also used to process pasted content (which is similar to loading data).

[**Data downcasting**](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html--downcast-pipelines) is the opposite process to data upcasting. It starts at the top and goes down to the bottom-left corner. Again, the conversion process name matches the direction and the pipeline.

#### Editing pipeline

[**Editing downcasting**](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html--downcast-pipelines) is a bit different from the other two processes:

* It takes place in the “editing pipeline” (the right branch of the diagram).
* It does not have a counterpart. Editing upcasting does not exist because editor features listen to [view events](#ckeditor5/latest/framework/architecture/editing-engine.html--observers), analyze what has happened, and apply necessary changes to the model whenever users perform actions. Therefore, this process does not involve conversion.
* Unlike [`DataController`](../../api/module_engine_controller_datacontroller-DataController.html) (which handles the _data pipeline_), [`EditingController`](../../api/module_engine_controller_editingcontroller-EditingController.html) maintains a single instance of the [`ViewDocument`](../../api/module_engine_view_document-ViewDocument.html) for its entire life. Every change in the model is converted to changes in that view, so changes in that view can then be rendered to the DOM (if needed – that is, if the DOM actually differs from the view at this stage).

#### More information

You can find a more in-depth introduction with examples in the [dedicated conversion guide](#ckeditor5/latest/framework/deep-dive/conversion/intro.html).

For additional information, you can also check out the [Implementing a block widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html--defining-converters) and [Implementing an inline widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-an-inline-widget.html--defining-converters) tutorials.

### Read next

Once you have learned how to implement editing features, it is time to add a UI for them. You can read about the CKEditor 5 standard UI framework and UI library in the UI library guide.

<a id="ckeditor5/latest/framework/architecture/intro.html">source file: "ckeditor5/latest/framework/architecture/intro.html"</a>

## Introduction to CKEditor 5 architecture

CKEditor 5 has a plugin-based architecture in which every feature (even typing and paragraph support) is a plugin. It rests on three main pillars: the [core editor architecture](#ckeditor5/latest/framework/architecture/core-editor-architecture.html), the [editing engine](#ckeditor5/latest/framework/architecture/editing-engine.html), and the [UI library](#ckeditor5/latest/framework/architecture/ui-library.html). The core is schema-less, built around a custom tree-structured data model and an editing-oriented virtual DOM.

### Basic CKEditor 5 architecture

#### Design

The framework was designed to be a highly flexible and universal platform for creating custom rich-text editing solutions. At the same time, it meets several goals that make implementing features as easy a task as possible.

* **Plugin-based architecture.** Everything is a plugin – even such crucial features as support for typing or `<p>` elements. You can remove plugins or replace them with your own implementations to achieve fully customized results.
* **Schema-less core.** The core makes minimal assumptions and can be controlled through the schema. This leaves all decisions to plugins and hence to you.
* **Collaboration-ready.** Or rather, real-time collaboration is **ready for you to use**! The editor implements [Operational Transformation](https://en.wikipedia.org/wiki/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](#ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration.html).
* **Custom data model.** The editing engine 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.** The editing engine features a custom, editing-oriented virtual DOM implementation that aims to hide browser quirks from your sight. **No more `contentEditable` nightmares!**
* **TypeScript.** The project is written in TypeScript and provides native type definitions. This helps create better, more reliable code that is easier to understand and maintain.
* **Granular, reusable features.** Features are implemented in a granular way. This allows for reusing and recomposing them which, in turn, makes it possible to customize and extend the editor. For instance, the [image feature](#ckeditor5/latest/features/images/images-overview.html) consists of over 10 plugins at the moment.
* **Extensibility.** 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 one another and communicate in standardized ways.
* **A beautiful UI.** Text editing is not only about typing – your users will need a UI to create links or manage images. We believe that a proper UX needs to be carefully designed and we did not skip this part. Having second thoughts about the proposed UI? No problem at all! You can always create your custom interface for CKEditor 5 thanks to its decoupled UI.
* **Quality.** All official packages have extensive test suites (100% code coverage is merely a step to that). All code has extensive [API documentation](../../api/index.html).
* **Minimal configuration.** To avoid bloat, features have minimal configuration. Deeper changes in their behavior can be done by recomposing them with custom features.
* **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 20 years of experience in creating rich-text editors and continue working day in and day out on improving your future-proof rich-text editor of choice.

#### Framework structure

The framework is made of several [npm packages](https://npmjs.com). Each package is available in the [`/packages`](https://github.com/ckeditor/ckeditor5/tree/master/packages) directory of the CKEditor 5 GitHub repository.

There are a few groups of packages:

* Core libraries – A set of packages which are the root of the framework.
* Editors – Packages that implement various types of editors.
* Features – Packages that implement end-user features.
* Themes – Packages that implement editor themes.

### Main components

CKEditor 5 Framework comes with its 3 main pillars:

* **[Core editor architecture](#ckeditor5/latest/framework/architecture/core-editor-architecture.html)**

The core editor architecture is implemented by the [`@ckeditor/ckeditor5-core`](../../api/core.html) package. It consists of some core classes and interfaces that glue everything together.

The main purpose of the core editor architecture is to lay the groundwork for implementing editor features. Therefore, it introduces concepts such as [plugins](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--plugins) and [commands](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--commands) which simplify and standardize the way of implementing features.

* **[Editing engine](#ckeditor5/latest/framework/architecture/editing-engine.html)**

The editing engine is implemented by the [`@ckeditor/ckeditor5-engine`](../../api/engine.html) package. It is the biggest and by far the most complex piece of the framework, implementing the custom data model, the view layer, conversion mechanisms, the rendering engine responsible for [taming `contentEditable`](https://medium.com/content-uneditable/contenteditable-the-good-the-bad-and-the-ugly-261a38555e9c) and a lot more.

* **[UI library](#ckeditor5/latest/framework/architecture/ui-library.html)**

The standard UI library is implemented by the [`@ckeditor/ckeditor5-ui`](../../api/ui.html) package. It contains a simple MVC implementation whose main goal is to best fit the CKEditor 5 needs. Furthermore, it introduces basic UI components to be used by editor features.

<a id="ckeditor5/latest/framework/architecture/plugins.html">source file: "ckeditor5/latest/framework/architecture/plugins.html"</a>

## Plugins in CKEditor 5

Features in CKEditor are introduced by plugins. In fact, without plugins, CKEditor 5 is an empty API with no use. Plugins provided by the CKEditor core team are available in [npm](https://www.npmjs.com/search?q=ckeditor5) (and [GitHub](https://github.com/ckeditor?utf8=%E2%9C%93\&q=ckeditor5\&type=\&language=), too) in the form of npm packages. A package may contain one or more plugins (for example, the [`@ckeditor/ckeditor5-image`](https://www.npmjs.com/package/@ckeditor/ckeditor5-image) package contains [several granular plugins](#ckeditor5/latest/features/images/images-overview.html)).

Starting with CKEditor 5 v42.0.0, we collect all plugins in two aggregate packages: `ckeditor5` and `ckeditor5-premium-features`. Using those two is the recommended way of setup. This way you get easy access to all the plugins, without the need to look which plugin is in which package.

### Common use cases

Plugins can be pretty much anything. They are pieces of code initialized by the editor if they are configured to be loaded. They can use the richness of the [CKEditor 5 Framework API](../../api/index.html) to enhance the editor or to better integrate it with your application.

Common use cases for plugins are:

* **Editing features**, like bold, heading, linking, or any other feature that the user can use to manipulate the content.
* **Adding semantic value** to the content, like annotations or accessibility features.
* **Third-party services integration**, for injecting external resources into the content, like videos or social network posts.
* **Handling image upload** and image manipulation features.
* **Providing widgets** for easy integration with application structured data.
* **Injecting analysis tools** that help enhance the quality of the content.
* And other infinite possibilities.

### Creating plugins

Creating your own plugins is a straightforward task, but it requires good knowledge about some aspects of the CKEditor 5 development environment. The following resources are recommended as a starting point:

* The [Plugin development guide](#ckeditor5/latest/framework/tutorials/crash-course/editor.html).
* The [Using package generator](#ckeditor5/latest/framework/development-tools/package-generator/using-package-generator.html), that provides a plugin development environment.

A good understanding of the [CKEditor 5 Framework](#ckeditor5/latest/framework/index.html) is also welcome when it comes to creating plugins.

### Using third-party plugins

A great way to enhance your editor with additional features is by using plugins created by the community. Such plugins are available as npm packages, so a quick [search on the “ckeditor5” keyword in npm](https://www.npmjs.com/search?q=ckeditor5) should work as a starting point.

Once you have plugins you want to include, read the [Configuring CKEditor 5 features](#ckeditor5/latest/getting-started/setup/configuration.html) guide.

### Plugins and HTML output

Listed below are all official CKEditor 5 packages as well as some partner packages together with their possible HTML output. If a plugin generates a different HTML output depending on its configuration, it is described in the “HTML output” column.

The classes, styles or attributes applied to an HTML element are all **possible** results. It does not mean they all will always be used.

`$block` is a generic structural element that may contain textual content. Features like headings or paragraph implement it to inherit common behaviors. You can read more about it in the [Schema](#ckeditor5/latest/framework/deep-dive/schema.html--generic-items) guide.

If a given plugin does not generate any output, the “HTML output” is described as “None.” Wildcard character `*` means any value is possible.

The data used to generate the following tables comes from the package metadata. You can read more about it in the [package metadata](#ckeditor5/latest/framework/contributing/package-metadata.html) guide.

#### `ckeditor5-adapter-ckfinder`

Source file: [`@ckeditor/ckeditor5-adapter-ckfinder/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-adapter-ckfinder/ckeditor5-metadata.json)

#### `ckeditor5-ai`

Source file: `@ckeditor/ckeditor5-ai/ckeditor5-metadata.json`

#### `ckeditor5-alignment`

Source file: [`@ckeditor/ckeditor5-alignment/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-alignment/ckeditor5-metadata.json)

#### `ckeditor5-autoformat`

Source file: [`@ckeditor/ckeditor5-autoformat/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-autoformat/ckeditor5-metadata.json)

| Plugin                                                                                                                                               | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Autoformat**[Feature guide](#ckeditor5/latest/features/autoformat.html)[API documentation](../../api/module_autoformat_autoformat-Autoformat.html) | None.       |

#### `ckeditor5-autosave`

Source file: [`@ckeditor/ckeditor5-autosave/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-autosave/ckeditor5-metadata.json)

| Plugin                                                                                                                                     | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Autosave**[Feature guide](#ckeditor5/latest/features/autosave.html)[API documentation](../../api/module_autosave_autosave-Autosave.html) | None.       |

#### `ckeditor5-basic-styles`

Source file: [`@ckeditor/ckeditor5-basic-styles/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-basic-styles/ckeditor5-metadata.json)

| Plugin                                                                                                                                                            | HTML output |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Bold**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_bold-Bold.html)                            | `<strong>`  |
| **Code**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_code-Code.html)                            | `<code>`    |
| **Italic**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_italic-Italic.html)                      | `<i>`       |
| **Strikethrough**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_strikethrough-Strikethrough.html) | `<s>`       |
| **Subscript**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_subscript-Subscript.html)             | `<sub>`     |
| **Superscript**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_superscript-Superscript.html)       | `<sup>`     |
| **Underline**[Feature guide](#ckeditor5/latest/features/basic-styles.html)[API documentation](../../api/module_basic-styles_underline-Underline.html)             | `<u>`       |

#### `ckeditor5-block-quote`

Source file: [`@ckeditor/ckeditor5-block-quote/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-block-quote/ckeditor5-metadata.json)

| Plugin                                                                                                                                                  | HTML output    |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
| **Block quote**[Feature guide](#ckeditor5/latest/features/block-quote.html)[API documentation](../../api/module_block-quote_blockquote-BlockQuote.html) | `<blockquote>` |

#### `ckeditor5-bookmark`

Source file: [`@ckeditor/ckeditor5-bookmark/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-bookmark/ckeditor5-metadata.json)

| Plugin                                                                                                                                      | HTML output  |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| **Bookmark**[Feature guide](#ckeditor5/latest/features/bookmarks.html)[API documentation](../../api/module_bookmark_bookmark-Bookmark.html) | `<a id="*">` |

#### `ckeditor5-case-change`

Source file: `@ckeditor/ckeditor5-case-change/ckeditor5-metadata.json`

| Plugin                                                                                                                                                  | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Case change**[Feature guide](#ckeditor5/latest/features/case-change.html)[API documentation](../../api/module_case-change_casechange-CaseChange.html) | None.       |

#### `ckeditor5-ckbox`

Source file: [`@ckeditor/ckeditor5-ckbox/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-ckbox/ckeditor5-metadata.json)

#### `ckeditor5-ckfinder`

Source file: [`@ckeditor/ckeditor5-ckfinder/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-ckfinder/ckeditor5-metadata.json)

| Plugin                                                                                                                                                     | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **CKFinder**[Feature guide](#ckeditor5/latest/features/file-management/ckfinder.html)[API documentation](../../api/module_ckfinder_ckfinder-CKFinder.html) | None.       |

#### `ckeditor5-cloud-services`

Source file: [`@ckeditor/ckeditor5-cloud-services/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-cloud-services/ckeditor5-metadata.json)

| Plugin                                                                                                                                                               | HTML output |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Cloud Services**[Feature guide](https://ckeditor.com/ckeditor-cloud-services)[API documentation](../../api/module_cloud-services_cloudservices-CloudServices.html) | None.       |

#### `ckeditor5-code-block`

Source file: [`@ckeditor/ckeditor5-code-block/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-code-block/ckeditor5-metadata.json)

#### `ckeditor5-comments`

Source file: `@ckeditor/ckeditor5-comments/ckeditor5-metadata.json`

#### `ckeditor5-document-outline`

Source file: `@ckeditor/ckeditor5-document-outline/ckeditor5-metadata.json`

#### `ckeditor5-easy-image`

Source file: [`@ckeditor/ckeditor5-easy-image/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-easy-image/ckeditor5-metadata.json)

| Plugin                                                                                  | HTML output |
| --------------------------------------------------------------------------------------- | ----------- |
| **Easy Image**[API documentation](../../api/module_easy-image_easyimage-EasyImage.html) | None.       |

#### `ckeditor5-email`

Source file: `@ckeditor/ckeditor5-email/ckeditor5-metadata.json`

#### `ckeditor5-emoji`

Source file: [`@ckeditor/ckeditor5-emoji/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-emoji/ckeditor5-metadata.json)

| Plugin                                                                                                                                            | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Emoji**[Feature guide](#ckeditor5/latest/features/emoji.html)[API documentation](../../api/module_emoji_emoji-Emoji.html)                       | None.       |
| **Emoji mention**[Feature guide](#ckeditor5/latest/features/emoji.html)[API documentation](../../api/module_emoji_emojimention-EmojiMention.html) | None.       |
| **Emoji picker**[Feature guide](#ckeditor5/latest/features/emoji.html)[API documentation](../../api/module_emoji_emojipicker-EmojiPicker.html)    | None.       |

#### `ckeditor5-essentials`

Source file: [`@ckeditor/ckeditor5-essentials/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-essentials/ckeditor5-metadata.json)

| Plugin                                                                                    | HTML output |
| ----------------------------------------------------------------------------------------- | ----------- |
| **Essentials**[API documentation](../../api/module_essentials_essentials-Essentials.html) | `<br>`      |

#### `ckeditor5-export-inline-styles`

Source file: `@ckeditor/ckeditor5-export-inline-styles/ckeditor5-metadata.json`

#### `ckeditor5-export-pdf`

Source file: `@ckeditor/ckeditor5-export-pdf/ckeditor5-metadata.json`

| Plugin                                                                                                                                                           | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Export to PDF**[Feature guide](#ckeditor5/latest/features/converters/export-pdf.html)[API documentation](../../api/module_export-pdf_exportpdf-ExportPdf.html) | None.       |

#### `ckeditor5-export-word`

Source file: `@ckeditor/ckeditor5-export-word/ckeditor5-metadata.json`

| Plugin                                                                                                                                                                | HTML output |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Export to Word**[Feature guide](#ckeditor5/latest/features/converters/export-word.html)[API documentation](../../api/module_export-word_exportword-ExportWord.html) | None.       |

#### `ckeditor5-find-and-replace`

Source file: [`@ckeditor/ckeditor5-find-and-replace/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-find-and-replace/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                         | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Find and replace**[Feature guide](#ckeditor5/latest/features/find-and-replace.html)[API documentation](../../api/module_find-and-replace_findandreplace-FindAndReplace.html) | None.       |

#### `ckeditor5-font`

Source file: [`@ckeditor/ckeditor5-font/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-font/ckeditor5-metadata.json)

#### `ckeditor5-footnotes`

Source file: `@ckeditor/ckeditor5-footnotes/ckeditor5-metadata.json`

#### `ckeditor5-format-painter`

Source file: `@ckeditor/ckeditor5-format-painter/ckeditor5-metadata.json`

| Plugin                                                                                                                                                                 | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Format painter**[Feature guide](#ckeditor5/latest/features/format-painter.html)[API documentation](../../api/module_format-painter_formatpainter-FormatPainter.html) | None.       |

#### `ckeditor5-fullscreen`

Source file: [`@ckeditor/ckeditor5-fullscreen/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-fullscreen/ckeditor5-metadata.json)

| Plugin                                                                                                                                                    | HTML output |
| --------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Fullscreen mode**[Feature guide](#ckeditor5/latest/features/fullscreen.html)[API documentation](../../api/module_fullscreen_fullscreen-Fullscreen.html) | None.       |

#### `ckeditor5-heading`

Source file: [`@ckeditor/ckeditor5-heading/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-heading/ckeditor5-metadata.json)

#### `ckeditor5-highlight`

Source file: [`@ckeditor/ckeditor5-highlight/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-highlight/ckeditor5-metadata.json)

#### `ckeditor5-horizontal-line`

Source file: [`@ckeditor/ckeditor5-horizontal-line/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-horizontal-line/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                      | HTML output |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Horizontal line**[Feature guide](#ckeditor5/latest/features/horizontal-line.html)[API documentation](../../api/module_horizontal-line_horizontalline-HorizontalLine.html) | `<hr>`      |

#### `ckeditor5-html-embed`

Source file: [`@ckeditor/ckeditor5-html-embed/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-html-embed/ckeditor5-metadata.json)

#### `ckeditor5-html-support`

Source file: [`@ckeditor/ckeditor5-html-support/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-html-support/ckeditor5-metadata.json)

#### `ckeditor5-image`

Source file: [`@ckeditor/ckeditor5-image/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-image/ckeditor5-metadata.json)

#### `ckeditor5-import-word`

Source file: `@ckeditor/ckeditor5-import-word/ckeditor5-metadata.json`

| Plugin                                                                                                                                                                              | HTML output |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Import from Word**[Feature guide](#ckeditor5/latest/features/converters/import-word/import-word.html)[API documentation](../../api/module_import-word_importword-ImportWord.html) | None.       |

#### `ckeditor5-indent`

Source file: [`@ckeditor/ckeditor5-indent/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-indent/ckeditor5-metadata.json)

#### `ckeditor5-language`

Source file: [`@ckeditor/ckeditor5-language/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-language/ckeditor5-metadata.json)

| Plugin                                                                                                                                                               | HTML output                |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |
| **Text part language**[Feature guide](#ckeditor5/latest/features/language.html)[API documentation](../../api/module_language_textpartlanguage-TextPartLanguage.html) | `<span
dir="*"
lang="*" >` |

#### `ckeditor5-line-height`

Source file: `@ckeditor/ckeditor5-line-height/ckeditor5-metadata.json`

| Plugin                                                                                                                                                  | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Line height**[Feature guide](#ckeditor5/latest/features/line-height.html)[API documentation](../../api/module_line-height_lineheight-LineHeight.html) | None.       |

#### `ckeditor5-link`

Source file: [`@ckeditor/ckeditor5-link/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-link/ckeditor5-metadata.json)

#### `ckeditor5-list`

Source file: [`@ckeditor/ckeditor5-list/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-list/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                                                                                                              | HTML output                                                                                                                                                                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Legacy list**[Feature guide](#ckeditor5/latest/features/lists/lists.html)[API documentation](../../api/module_list_legacylist-LegacyList.html)                                                                                                                    | `<ol>``<ul>`                                                                                                                                                                                                  |
|                                                                                                                                                                                                                                                                     | `<li>`HTML element may contain classes, styles or attributes, that are created by other plugins, which alter the `<$block>` element.                                                                          |
| **Legacy to-do list**[Feature guide](#ckeditor5/latest/features/lists/todo-lists.html)[API documentation](../../api/module_list_legacytodolist-LegacyTodoList.html)                                                                                                 | `<ul class="todo-list">`                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                     | `<li>`                                                                                                                                                                                                        |
|                                                                                                                                                                                                                                                                     | `<label class="todo-list__label">`                                                                                                                                                                            |
|                                                                                                                                                                                                                                                                     | `<span class="todo-list__label__description">`                                                                                                                                                                |
|                                                                                                                                                                                                                                                                     | `<input
checked="*"
disabled="*"
type="*" >`                                                                                                                                                                  |
| **Legacy list properties**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-styles)[API documentation](../../api/module_list_legacylistproperties-LegacyListProperties.html)                                                             | `<ol
style="list-style-type:*"
start="*"
reversed="*" >``<ul
style="list-style-type:*"
start="*"
reversed="*" >`                                                                                              |
| **List**[Feature guide](#ckeditor5/latest/features/lists/lists.html)[API documentation](../../api/module_list_list-List.html)                                                                                                                                       | `<ol>``<ul>`                                                                                                                                                                                                  |
|                                                                                                                                                                                                                                                                     | `<li>`                                                                                                                                                                                                        |
|                                                                                                                                                                                                                                                                     | `<li style="list-style-type:*">`If `config.list.enableSkipLevelLists` is set to `true`, intermediate `<li>` wrappers with `list-style-type: none` are emitted to bridge missing indent levels.                |
| **List formatting**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting-ListFormatting.html)                                                                | None.                                                                                                                                                                                                         |
| **List item bold integration**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting_listitemboldintegration-ListItemBoldIntegration.html)                    | `<li class="ck-list-marker-bold">`                                                                                                                                                                            |
| **List item italic integration**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting_listitemitalicintegration-ListItemItalicIntegration.html)              | `<li class="ck-list-marker-italic">`                                                                                                                                                                          |
| **List item font size integration**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting_listitemfontsizeintegration-ListItemFontSizeIntegration.html)       | `<li
class="ck-list-marker-font-size ck-list-marker-font-size-tiny ck-list-marker-font-size-small ck-list-marker-font-size-big ck-list-marker-font-size-huge"
style="--ck-content-list-marker-font-size:*" >` |
| **List item font color integration**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting_listitemfontcolorintegration-ListItemFontColorIntegration.html)    | `<li
class="ck-list-marker-color"
style="--ck-content-list-marker-color:*" >`                                                                                                                                 |
| **List item font family integration**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html--list-item-marker-formatting)[API documentation](../../api/module_list_listformatting_listitemfontfamilyintegration-ListItemFontFamilyIntegration.html) | `<li
class="ck-list-marker-font-family"
style="--ck-content-list-marker-font-family:*" >`                                                                                                                     |
| **To-do list**[Feature guide](#ckeditor5/latest/features/lists/todo-lists.html)[API documentation](../../api/module_list_todolist-TodoList.html)                                                                                                                    | `<ul class="todo-list">`                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                     | `<li>`                                                                                                                                                                                                        |
|                                                                                                                                                                                                                                                                     | `<label class="todo-list__label todo-list__label_without-description">`                                                                                                                                       |
|                                                                                                                                                                                                                                                                     | `<span class="todo-list__label__description">`                                                                                                                                                                |
|                                                                                                                                                                                                                                                                     | `<input
checked="*"
disabled="*"
type="*" >`                                                                                                                                                                  |
| **List properties**[Feature guide](#ckeditor5/latest/features/lists/lists-properties.html)[API documentation](../../api/module_list_listproperties-ListProperties.html)                                                                                             | `<ol
style="list-style-type:*"
start="*"
reversed="*"
type="*" >``<ul
style="list-style-type:*"
start="*"
reversed="*"
type="*" >`                                                                            |

#### `ckeditor5-list-multi-level`

Source file: `@ckeditor/ckeditor5-list-multi-level/ckeditor5-metadata.json`

#### `ckeditor5-markdown-gfm`

Source file: [`@ckeditor/ckeditor5-markdown-gfm/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-markdown-gfm/ckeditor5-metadata.json)

| Plugin                                                                                                                                         | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Markdown**[Feature guide](#ckeditor5/latest/features/markdown.html)[API documentation](../../api/module_markdown-gfm_markdown-Markdown.html) | None.       |

#### `ckeditor5-media-embed`

Source file: [`@ckeditor/ckeditor5-media-embed/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-media-embed/ckeditor5-metadata.json)

#### `ckeditor5-mention`

Source file: [`@ckeditor/ckeditor5-mention/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-mention/ckeditor5-metadata.json)

| Plugin                                                                                                                                 | HTML output                                |
| -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
| **Mention**[Feature guide](#ckeditor5/latest/features/mentions.html)[API documentation](../../api/module_mention_mention-Mention.html) | `<span
class="mention"
data-mention="*" >` |

#### `ckeditor5-merge-fields`

Source file: `@ckeditor/ckeditor5-merge-fields/ckeditor5-metadata.json`

| Plugin                                                                                                                                                       | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Merge fields**[Feature guide](#ckeditor5/latest/features/merge-fields.html)[API documentation](../../api/module_merge-fields_mergefields-MergeFields.html) | None.       |

#### `ckeditor5-minimap`

Source file: [`@ckeditor/ckeditor5-minimap/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-minimap/ckeditor5-metadata.json)

| Plugin                                                                                                                                        | HTML output |
| --------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Content minimap**[Feature guide](#ckeditor5/latest/features/minimap.html)[API documentation](../../api/module_minimap_minimap-Minimap.html) | None.       |

#### `ckeditor5-page-break`

Source file: [`@ckeditor/ckeditor5-page-break/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-page-break/ckeditor5-metadata.json)

| Plugin                                                                                                                                             | HTML output                                            |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| **Page break**[Feature guide](#ckeditor5/latest/features/page-break.html)[API documentation](../../api/module_page-break_pagebreak-PageBreak.html) | `<div
class="page-break"
style="page-break-after:*" >` |
|                                                                                                                                                    | `<span style="display:*">`                             |

#### `ckeditor5-pagination`

Source file: `@ckeditor/ckeditor5-pagination/ckeditor5-metadata.json`

#### `ckeditor5-paragraph`

Source file: [`@ckeditor/ckeditor5-paragraph/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-paragraph/ckeditor5-metadata.json)

| Plugin                                                                                | HTML output                                                                                                                                                                                                                                               |
| ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Paragraph**[API documentation](../../api/module_paragraph_paragraph-Paragraph.html) | `<p>`HTML element may contain classes, styles or attributes, that are created by other plugins, which alter the `<$block>` element.This element inherits all attributes, classes and styles that are allowed on the `<$block>` element by other features. |

#### `ckeditor5-paste-from-office`

Source file: [`@ckeditor/ckeditor5-paste-from-office/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-paste-from-office/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                                      | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Paste from Office**[Feature guide](#ckeditor5/latest/features/pasting/paste-from-office.html)[API documentation](../../api/module_paste-from-office_pastefromoffice-PasteFromOffice.html) | None.       |

#### `ckeditor5-paste-from-office-enhanced`

Source file: `@ckeditor/ckeditor5-paste-from-office-enhanced/ckeditor5-metadata.json`

#### `ckeditor5-real-time-collaboration`

Source file: `@ckeditor/ckeditor5-real-time-collaboration/ckeditor5-metadata.json`

#### `ckeditor5-remove-format`

Source file: [`@ckeditor/ckeditor5-remove-format/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-remove-format/ckeditor5-metadata.json)

| Plugin                                                                                                                                                            | HTML output |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Remove format**[Feature guide](#ckeditor5/latest/features/remove-format.html)[API documentation](../../api/module_remove-format_removeformat-RemoveFormat.html) | None.       |

#### `ckeditor5-restricted-editing`

Source file: [`@ckeditor/ckeditor5-restricted-editing/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-restricted-editing/ckeditor5-metadata.json)

#### `ckeditor5-revision-history`

Source file: `@ckeditor/ckeditor5-revision-history/ckeditor5-metadata.json`

#### `ckeditor5-select-all`

Source file: [`@ckeditor/ckeditor5-select-all/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-select-all/ckeditor5-metadata.json)

| Plugin                                                                                                                                             | HTML output |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Select all**[Feature guide](#ckeditor5/latest/features/select-all.html)[API documentation](../../api/module_select-all_selectall-SelectAll.html) | None.       |

#### `ckeditor5-show-blocks`

Source file: [`@ckeditor/ckeditor5-show-blocks/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-show-blocks/ckeditor5-metadata.json)

| Plugin                                                                                                                                                  | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Show blocks**[Feature guide](#ckeditor5/latest/features/show-blocks.html)[API documentation](../../api/module_show-blocks_showblocks-ShowBlocks.html) | None.       |

#### `ckeditor5-slash-command`

Source file: `@ckeditor/ckeditor5-slash-command/ckeditor5-metadata.json`

| Plugin                                                                                                                                                             | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Slash command**[Feature guide](#ckeditor5/latest/features/slash-commands.html)[API documentation](../../api/module_slash-command_slashcommand-SlashCommand.html) | None.       |

#### `ckeditor5-source-editing`

Source file: [`@ckeditor/ckeditor5-source-editing/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-source-editing/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                                     | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Source code editing**[Feature guide](#ckeditor5/latest/features/source-editing/source-editing.html)[API documentation](../../api/module_source-editing_sourceediting-SourceEditing.html) | None.       |

#### `ckeditor5-source-editing-enhanced`

Source file: `@ckeditor/ckeditor5-source-editing-enhanced/ckeditor5-metadata.json`

#### `ckeditor5-special-characters`

Source file: [`@ckeditor/ckeditor5-special-characters/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-special-characters/ckeditor5-metadata.json)

#### `ckeditor5-style`

Source file: [`@ckeditor/ckeditor5-style/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-style/ckeditor5-metadata.json)

| Plugin                                                                                                                      | HTML output                                                                             |
| --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| **Style**[Feature guide](#ckeditor5/latest/features/style.html)[API documentation](../../api/module_style_style-Style.html) | `<* class="*">`The plugin can output any arbitrary HTML depending on its configuration. |

#### `ckeditor5-table`

Source file: [`@ckeditor/ckeditor5-table/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-table/ckeditor5-metadata.json)

#### `ckeditor5-template`

Source file: `@ckeditor/ckeditor5-template/ckeditor5-metadata.json`

| Plugin                                                                                                                                     | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Template**[Feature guide](#ckeditor5/latest/features/template.html)[API documentation](../../api/module_template_template-Template.html) | None.       |

#### `ckeditor5-track-changes`

Source file: `@ckeditor/ckeditor5-track-changes/ckeditor5-metadata.json`

#### `ckeditor5-typing`

Source file: [`@ckeditor/ckeditor5-typing/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-typing/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                             | HTML output |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Text transformation**[Feature guide](#ckeditor5/latest/features/text-transformation.html)[API documentation](../../api/module_typing_texttransformation-TextTransformation.html) | None.       |

#### `ckeditor5-ui`

Source file: [`@ckeditor/ckeditor5-ui/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-ui/ckeditor5-metadata.json)

| Plugin                                                                                                                                                                                           | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Block toolbar**[Feature guide](#ckeditor5/latest/getting-started/setup/toolbar.html--block-toolbar)[API documentation](../../api/module_ui_toolbar_block_blocktoolbar-BlockToolbar.html)       | None.       |
| **Accessibility help**[Feature guide](#ckeditor5/latest/features/accessibility.html)[API documentation](../../api/module_ui_editorui_accessibilityhelp_accessibilityhelp-AccessibilityHelp.html) | None.       |

#### `ckeditor5-undo`

Source file: [`@ckeditor/ckeditor5-undo/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-undo/ckeditor5-metadata.json)

| Plugin                                                                                                                      | HTML output |
| --------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Undo**[Feature guide](#ckeditor5/latest/features/undo-redo.html)[API documentation](../../api/module_undo_undo-Undo.html) | None.       |

#### `ckeditor5-upload`

Source file: [`@ckeditor/ckeditor5-upload/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-upload/ckeditor5-metadata.json)

#### `ckeditor5-uploadcare`

Source file: `@ckeditor/ckeditor5-uploadcare/ckeditor5-metadata.json`

| Plugin                                                                                                                 | HTML output                                                                                                            |
| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| **Uploadcare**[API documentation](../../api/module_uploadcare_uploadcare-Uploadcare.html)                              | `<a data-uploadcare-resource-id="*">``<figure data-uploadcare-resource-id="*">``<img data-uploadcare-resource-id="*">` |
| **Uploadcare Image Edit**[API documentation](../../api/module_uploadcare_uploadcareimageedit-UploadcareImageEdit.html) | None.                                                                                                                  |

#### `ckeditor5-watchdog`

Source file: [`@ckeditor/ckeditor5-watchdog/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-watchdog/ckeditor5-metadata.json)

| Plugin                                                                                                                                                 | HTML output |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **Watchdog**[Feature guide](#ckeditor5/latest/features/watchdog.html)[API documentation](../../api/module_watchdog_editorwatchdog-EditorWatchdog.html) | None.       |

#### `ckeditor5-word-count`

Source file: [`@ckeditor/ckeditor5-word-count/ckeditor5-metadata.json`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-word-count/ckeditor5-metadata.json)

| Plugin                                                                                                                                             | HTML output |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| **Word count**[Feature guide](#ckeditor5/latest/features/word-count.html)[API documentation](../../api/module_word-count_wordcount-WordCount.html) | None.       |

#### `mathtype-ckeditor5`

Source file: _not published yet_

| Plugin                                                                      | HTML output                                                                                                                                                           |
| --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **MathType**[Feature guide](#ckeditor5/latest/features/math-equations.html) | `<* *="*">`For a complete list of available MathML element and attribute names, visit [MDN Web Docs for MathML](https://developer.mozilla.org/en-US/docs/Web/MathML). |

#### `wproofreader-ckeditor5`

Source file: _not published yet_

| Plugin                                                                                         | HTML output |
| ---------------------------------------------------------------------------------------------- | ----------- |
| **WProofreader**[Feature guide](#ckeditor5/latest/features/spelling-and-grammar-checking.html) | None.       |

<a id="ckeditor5/latest/framework/architecture/ui-components.html">source file: "ckeditor5/latest/framework/architecture/ui-components.html"</a>

## UI components

The CKEditor 5 framework provides several UI components that can be helpful when developing a new user interface. All UI classes come with the [`set()`](../../api/module_ui_view-View.html#function-set:KEY_VALUE) method, which sets the properties of the components, such as labels, icons, placeholders, etc.

> **Note**
>
> This article lists all available components and their variants. If you want to understand the implementation details, check the [UI library](#ckeditor5/latest/framework/architecture/ui-library.html) guide.

### Balloon

A balloon panel is a floating component that can appear depending on the context. It can be pinned to a specific position or added dynamically at the caret position. You can use it to display any UI within the editor. You can create a balloon panel as an instance of the [`BalloonPanelView`](../../api/module_ui_panel_balloon_balloonpanelview-BalloonPanelView.html) class.

**NPM**

```js
import { BalloonPanelView, ButtonView } from 'ckeditor5';

const balloonButton = new ButtonView();
balloonButton.set( { label: 'Balloon button', withText: true } );
balloonButton.render();

const balloon = new BalloonPanelView();
balloon.render();
balloon.content.add( balloonButton );

const positions = BalloonPanelView.defaultPositions;
balloon.pin( {
	target: document.getElementById( 'balloon' ),
	positions: [ positions.southArrowNorth ]
} );

document.body.append( balloon.element );
```

**CDN**

```js
const { BalloonPanelView, ButtonView } = CKEDITOR;

const balloonButton = new ButtonView();
balloonButton.set( { label: 'Balloon button', withText: true } );
balloonButton.render();

const balloon = new BalloonPanelView();
balloon.render();
balloon.content.add( balloonButton );

const positions = BalloonPanelView.defaultPositions;
balloon.pin( {
	target: document.getElementById( 'balloon' ),
	positions: [ positions.southArrowNorth ]
} );

document.body.append( balloon.element );
```

Two positions describe the placement of the ballon. The first one describes the relationship between the element and the pinned balloon. The second one is the position of the balloon arrow. It creates many possible balloon positions:

* `northWestArrowSouthWest`
* `northWestArrowSouthMiddleWest`
* `northWestArrowSouth`
* `northWestArrowSouthMiddleEast`
* `northWestArrowSouthEast`
* `northArrowSouthWest`
* `northArrowSouthMiddleWest`
* `northArrowSouth`
* `northArrowSouthMiddleEast`
* `northArrowSouthEast`
* `northEastArrowSouthWest`
* `northEastArrowSouthMiddleWest`
* `northEastArrowSouth`
* `northEastArrowSouthMiddleEast`
* `northEastArrowSouthEast`
* `southWestArrowNorthWest`
* `southWestArrowNorthMiddleWest`
* `southWestArrowNorth`
* `southWestArrowNorthMiddleEast`
* `southWestArrowNorthEast`
* `southArrowNorthWest`
* `southArrowNorthMiddleWest`
* `southArrowNorth`
* `southArrowNorthMiddleEast`
* `southArrowNorthEast`
* `southEastArrowNorthWest`
* `southEastArrowNorthMiddleWest`
* `southEastArrowNorth`
* `southEastArrowNorthMiddleEast`
* `southEastArrowNorthEast`
* `viewportStickyNorth`

### Button

There are two basic buttons in the CKEditor 5 UI library: a standard button and a switch. You can instantiate the standard button with the [`ButtonView`](../../api/module_ui_button_buttonview-ButtonView.html) class. By modifying the passed configuration, you can get different button variants and states. The [`ButtonLabelView`](../../api/module_ui_button_buttonlabelview-ButtonLabelView.html) class is a default implementation of the button’s label. It supports dynamic text via the [`text`](../../api/module_ui_button_buttonlabelview-ButtonLabelView.html#member-text) property.

#### Action

To get an action button, add the `ck-button-action` class.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const actionButton = new ButtonView();

actionButton.set( {
	label: 'Action button',
	withText: true,
	class: 'ck-button-action'
} );
actionButton.render();

document.getElementById( 'button-action' ).append( actionButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const actionButton = new ButtonView();

actionButton.set( {
	label: 'Action button',
	withText: true,
	class: 'ck-button-action'
} );
actionButton.render();

document.getElementById( 'button-action' ).append( actionButton.element );
```

#### Rounded

To get a rounded button, add the `ck-rounded-corners` class.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const roundedButton = new ButtonView();

roundedButton.set( {
	label: 'Rounded button',
	withText: true,
	class: 'ck-rounded-corners'
} );
roundedButton.render();

document.getElementById( 'button-rounded' ).append( roundedButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const roundedButton = new ButtonView();

roundedButton.set( {
	label: 'Rounded button',
	withText: true,
	class: 'ck-rounded-corners'
} );
roundedButton.render();

document.getElementById( 'button-rounded' ).append( roundedButton.element );
```

#### Bold

To get a bold button, add the `ck-button-bold` class.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const boldButton = new ButtonView();

boldButton.set( {
	label: 'Bold button',
	withText: true,
	class: 'ck-button-bold'
} );
boldButton.render();

document.getElementById( 'button-bold' ).append( boldButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const boldButton = new ButtonView();

boldButton.set( {
	label: 'Bold button',
	withText: true,
	class: 'ck-button-bold'
} );
boldButton.render();

document.getElementById( 'button-bold' ).append( boldButton.element );
```

#### Icon

To get a button with an icon, import it first. Then set the `icon` property on the button. You can also add a custom icon to the dropdown by [providing the entire XML string of the icon](#ckeditor5/latest/framework/architecture/ui-library.html--setting-label-icon-and-tooltip). There are also classes you can use to style icons appropriately.

**NPM**

```js
import { ButtonView, IconCheck } from 'ckeditor5';

const saveButton = new ButtonView();

saveButton.set( {
	label: 'Save',
	withText: false,
	icon: IconCheck,
	class: 'ck-button-save'
} );
saveButton.render();

document.getElementById( 'button-icon' ).append( saveButton.element );
```

**CDN**

```js
const { ButtonView, IconCheck } = CKEDITOR;

const saveButton = new ButtonView();

saveButton.set( {
	label: 'Save',
	withText: false,
	icon: IconCheck,
	class: 'ck-button-save'
} );
saveButton.render();

document.getElementById( 'button-icon' ).append( saveButton.element );
```

#### Keystrokes

To get a button with a shortcut, add the `keystroke` property. To display the shortcut on the button, set the [`withKeystroke`](../../api/module_ui_button_button-Button.html#member-withKeystroke) property to `true`. If you also add a label, it will display next to the shortcut. You do not need to worry about different shortcuts for different operating systems – the shortcut is relative to the OS. For example, macOS will display the `Ctrl`+`I` shortcut as ⌘+`I`.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const keystrokeButton = new ButtonView();

keystrokeButton.set( {
	label: 'Italic',
	withText: true,
	withKeystroke: true,
	keystroke: 'Ctrl+I'
} );
keystrokeButton.render();

document.getElementById( 'button-keystroke' ).append( keystrokeButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const keystrokeButton = new ButtonView();

keystrokeButton.set( {
	label: 'Italic',
	withText: true,
	withKeystroke: true,
	keystroke: 'Ctrl+I'
} );
keystrokeButton.render();

document.getElementById( 'button-keystroke' ).append( keystrokeButton.element );
```

#### Tooltip

To get a button with a tooltip, add the `tooltip` property. You can use it to display additional information on button hover. If you set it to `true`, a label value is displayed.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const tooltipButton = new ButtonView();

tooltipButton.set( {
	label: 'Tooltip button',
	withText: true,
	tooltip: 'The content of the tooltip',
	tooltipPosition: 's'
} );
tooltipButton.render();

document.getElementById( 'button-tooltip' ).append( tooltipButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const tooltipButton = new ButtonView();

tooltipButton.set( {
	label: 'Tooltip button',
	withText: true,
	tooltip: 'The content of the tooltip',
	tooltipPosition: 's'
} );
tooltipButton.render();

document.getElementById( 'button-tooltip' ).append( tooltipButton.element );
```

By default, the tooltip will appear to the south of the button. However, you can adjust its position with the [`tooltipPosition`](../../api/module_ui_tooltipmanager-TooltipPosition.html) property. You can set the property to:

* `n` – North
* `w` – West
* `s` – South
* `e` – East
* `se` – South-east
* `sw` – South-west

A tooltip needs the [`TooltipManager`](../../api/module_ui_tooltipmanager-TooltipManager.html) to work correctly. You need to add it during CKEditor creation.

```js
ClassicEditor
    .create( {
        // Editor configuration.
        //
    } )
    .then( editor => {
        this.tooltipManager = new TooltipManager( editor );
    } )
    .catch( error => {
        // Error handling.
        //
    } );
```

#### States

There are properties you can set to get various button states.

##### Enabled

Buttons are enabled and clickable by default. You can also set the state explicitly by adding the [`isEnabled`](../../api/module_ui_button_button-Button.html#member-isEnabled) property with a `true` value.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const enabledButton = new ButtonView();

enabledButton.set( {
	label: 'Enabled state',
	withText: true,
	isEnabled: true
} );
enabledButton.render();

document.getElementById( 'button-enabled' ).append( enabledButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const enabledButton = new ButtonView();

enabledButton.set( {
	label: 'Enabled state',
	withText: true,
	isEnabled: true
} );
enabledButton.render();

document.getElementById( 'button-enabled' ).append( enabledButton.element );
```

##### Disabled

To disable a button, set the [`isEnabled`](../../api/module_ui_button_button-Button.html#member-isEnabled) property to `false`.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const disabledButton = new ButtonView();

disabledButton.set( {
	label: 'Disabled state',
	withText: true,
	isEnabled: false
} );
disabledButton.render();

document.getElementById( 'button-disabled' ).append( disabledButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const disabledButton = new ButtonView();

disabledButton.set( {
	label: 'Disabled state',
	withText: true,
	isEnabled: false
} );
disabledButton.render();

document.getElementById( 'button-disabled' ).append( disabledButton.element );
```

##### On

Some actions in the editor can constantly be active. To indicate them, you can set the [`isOn`](../../api/module_ui_button_button-Button.html#member-isOn) property to `true`.

**NPM**

```js
import { ButtonView } from 'ckeditor5';

const onButton = new ButtonView();

onButton.set( { label: 'On state', withText: true, isOn: true } );
onButton.render();

document.getElementById( 'button-on' ).append( onButton.element );
```

**CDN**

```js
const { ButtonView } = CKEDITOR;

const onButton = new ButtonView();

onButton.set( { label: 'On state', withText: true, isOn: true } );
onButton.render();

document.getElementById( 'button-on' ).append( onButton.element );
```

### Switch

You need a different class to instantiate a switch button – [`SwitchButtonView`](../../api/module_ui_button_switchbuttonview-SwitchButtonView.html). To make it work properly, you also need to add an event listener with the [`on()`](../../api/module_ui_button_switchbuttonview-SwitchButtonView.html#function-on) method. Every click triggers the flip of the [`isOn`](../../api/module_ui_button_switchbuttonview-SwitchButtonView.html#member-isOn) property. It is responsible for turning the button on and off.

**NPM**

```js
import { SwitchButtonView } from 'ckeditor5';

const switchButton = new SwitchButtonView();

switchButton.set( {
	label: 'Switch button',
	withText: true,
	isOn: false
} );
switchButton.render();
switchButton.on( 'execute', () => { switchButton.isOn = !switchButton.isOn } );

document.getElementById( 'button-switch' ).append( switchButton.element );
```

**CDN**

```js
const { SwitchButtonView } = CKEDITOR;

const switchButton = new SwitchButtonView();

switchButton.set( {
	label: 'Switch button',
	withText: true,
	isOn: false
} );
switchButton.render();
switchButton.on( 'execute', () => { switchButton.isOn = !switchButton.isOn } );

document.getElementById( 'button-switch' ).append( switchButton.element );
```

### Dropdown

A dropdown consists of two elements: a button and a panel. The button expands the dropdown menu. The dropdown panel can hold any UI element.

You can use the [`createDropdown()`](../../api/module_ui_dropdown_utils.html#function-createDropdown) helper method to create a dropdown. By default, it uses the [`DropdownButtonView`](../../api/module_ui_dropdown_button_dropdownbuttonview-DropdownButtonView.html) class. You can replace it with the [`ButtonView`](../../api/module_ui_button_buttonview-ButtonView.html) or [`SplitButtonView`](../../api/module_ui_dropdown_button_splitbuttonview-SplitButtonView.html) class.

#### List

Inside a dropdown, you can put a list. To do so, you can use the [`addListToDropdown()`](../../api/module_ui_dropdown_utils.html#function-addListToDropdown) helper function. Also, you must add items to a collection before putting them inside the dropdown.

**NPM**

```js
import {
    addListToDropdown,
    Collection,
    createDropdown,
    Locale,
    UIModel
} from 'ckeditor5';

const locale = new Locale();

const listDropdown = createDropdown( locale );
listDropdown.buttonView.set( {
	label: 'List dropdown',
	withText: true
} );
addListToDropdown( listDropdown, collection );
listDropdown.render();

document.getElementById( 'dropdown-list' ).append( listDropdown.element );
```

**CDN**

```js
const {
    addListToDropdown,
    Collection,
    createDropdown,
    Locale,
    UIModel
} = CKEDITOR;

const locale = new Locale();

const listDropdown = createDropdown( locale );
listDropdown.buttonView.set( {
	label: 'List dropdown',
	withText: true
} );
addListToDropdown( listDropdown, collection );
listDropdown.render();

document.getElementById( 'dropdown-list' ).append( listDropdown.element );
```

#### Toolbar

You can use the [`addToolbarToDropdown()`](../../api/module_ui_dropdown_utils.html#function-addToolbarToDropdown) helper function to add a toolbar to the dropdown. Inside the toolbar, you can put buttons.

**NPM**

```js
import {
	addToolbarToDropdown,
	ButtonView,
	createDropdown,
	Locale,
	IconBold,
	IconItalic
} from 'ckeditor5';

const locale = new Locale();

const bold = new ButtonView();
const italic = new ButtonView();

bold.set( { label: 'Bold', withText: false, icon: IconBold } );
italic.set( { label: 'Italic', withText: false, icon: IconItalic } );

const buttons = [ bold, italic ];

const toolbarDropdown = createDropdown( locale );
toolbarDropdown.buttonView.set( {
	label: 'Toolbar dropdown',
	withText: true
} );
addToolbarToDropdown( toolbarDropdown, buttons );
toolbarDropdown.render();

document.getElementById( 'toolbar-button' ).append( toolbarDropdown.element );
```

**CDN**

```js
const {
	addToolbarToDropdown,
	ButtonView,
	createDropdown,
	Locale,
	IconBold,
	IconItalic
} = CKEDITOR;

const locale = new Locale();

const bold = new ButtonView();
const italic = new ButtonView();

bold.set( { label: 'Bold', withText: false, icon: IconBold } );
italic.set( { label: 'Italic', withText: false, icon: IconItalic } );

const buttons = [ bold, italic ];

document.getElementById( 'toolbar-button' ).append( toolbarDropdown.element );
```

#### Menu

Finally, you can add a multi-level menu to a dropdown. Use the [`addMenuToDropdown()`](../../api/module_ui_dropdown_utils.html#function-addMenuToDropdown) helper function to simplify the process.

**NPM**

```js
import {
	addMenuToDropdown,
    createDropdown
} from 'ckeditor5';

const locale = new Locale(); // Can be `editor.locale`.
const body = new BodyCollection(); // Can be `editor.ui.view.body`.

const menuDropdown = createDropdown( locale );

// The menu items definitions.
const definition = [
	{
		id: 'menu_1',
		menu: 'Menu 1',
		children: [
			{
				id: 'menu_1_a',
				label: 'Item A'
			},
			{
				id: 'menu_1_b',
				label: 'Item B'
			}
		]
	},
	{
		id: 'top_a',
		label: 'Top Item A'
	},
	{
		id: 'top_b',
		label: 'Top Item B'
	}
];

addMenuToDropdown( menuDropdown, body, definition );

menuDropdown.render();

document.getElementById( 'menu-dropdown' ).append( menuDropdown.element );
```

**CDN**

```js
const {
	addMenuToDropdown,
    createDropdown
} = CKEDITOR;

const locale = new Locale(); // Can be `editor.locale`.
const body = new BodyCollection(); // Can be `editor.ui.view.body`.

const menuDropdown = createDropdown( locale );

addMenuToDropdown( menuDropdown, body, definition );

menuDropdown.render();

document.getElementById( 'menu-dropdown' ).append( menuDropdown.element );
```

#### Split button

Besides the standard button, you can also use the split button for a dropdown. It has two clickable sections: one for the main action and a second for expanding the dropdown with more options.

**NPM**

```js
import {
	addToolbarToDropdown,
	ButtonView,
	createDropdown,
	SplitButtonViewm,
	Locale,
	IconBold,
	IconItalic
} from 'ckeditor5';

const locale = new Locale();

const bold = new ButtonView();
const italic = new ButtonView();

bold.set( { label: 'Bold', withText: false, icon: IconBold } );
italic.set( { label: 'Italic', withText: false, icon: IconItalic } );

const buttons = [ bold, italic ];

const splitButtonDropdown = createDropdown( locale, SplitButtonView );
addToolbarToDropdown( splitButtonDropdown, buttons);
splitButtonDropdown.buttonView.set ( {
	label: 'Split button dropdown',
	withText: true
} );
splitButtonDropdown.render();

document.getElementById( 'dropdown-split-button' ).append( buttonDropdown.element );
```

**CDN**

```js
const {
	addToolbarToDropdown,
	ButtonView,
	createDropdown,
	SplitButtonViewm,
	Locale,
	IconBold,
	IconItalic
} = CKEDITOR;

const locale = new Locale();

const bold = new ButtonView();
const italic = new ButtonView();

bold.set( { label: 'Bold', withText: false, icon: IconBold } );
italic.set( { label: 'Italic', withText: false, icon: IconItalic } );

const buttons = [ bold, italic ];

document.getElementById( 'dropdown-split-button' ).append( buttonDropdown.element );
```

#### States

Dropdowns use buttons. Because of that, states and properties remain the same.

##### Enabled

Buttons in dropdowns are enabled and clickable by default. You can also set the state explicitly by adding the [`isEnabled`](../../api/module_ui_dropdown_button_dropdownbutton-DropdownButton.html#member-isEnabled) property with a `true` value.

**NPM**

```js
import { createDropdown, Locale } from 'ckeditor5';

const locale = new Locale();

const enabledDropdown = createDropdown( locale );
enabledDropdown.buttonView.set( {
	label: 'Enabled state',
	isEnabled: true,
	withText: true
} );
enabledDropdown.render();

document.getElementById( 'dropdown-enabled' ).append( enabledDropdown.element );
```

**CDN**

```js
const { createDropdown, Locale } = CKEDITOR;

const locale = new Locale();

const enabledDropdown = createDropdown( locale );
enabledDropdown.buttonView.set( {
	label: 'Enabled state',
	isEnabled: true,
	withText: true
} );
enabledDropdown.render();

document.getElementById( 'dropdown-enabled' ).append( enabledDropdown.element );
```

##### Disabled

To disable a button, set the [`isEnabled`](../../api/module_ui_dropdown_button_dropdownbutton-DropdownButton.html#member-isEnabled) property to `false`. It prevents the dropdown from being expanded.

**NPM**

```js
import { createDropdown, Locale } from 'ckeditor5';

const locale = new Locale();

const disabledDropdown = createDropdown( locale );
disabledDropdown.buttonView.set( {
	label: 'Disabled state',
	isEnabled: false,
	withText: true
} );
disabledDropdown.render();

document.getElementById( 'dropdown-disabled' ).append( disabledDropdown.element );
```

**CDN**

```js
const { createDropdown, Locale } = CKEDITOR;

const locale = new Locale();

const disabledDropdown = createDropdown( locale );
disabledDropdown.buttonView.set( {
	label: 'Disabled state',
	isEnabled: false,
	withText: true
} );
disabledDropdown.render();

document.getElementById( 'dropdown-disabled' ).append( disabledDropdown.element );
```

### Dialog

A dialog window is a draggable pop-up that you can display on top of the editor contents. It remains open when the user interacts with the editing area. You can use it to display any detached UI. Dialogs are brought by the [`Dialog`](../../api/module_ui_dialog_dialog-Dialog.html) plugin.

**NPM**

```js
// Necessary imports. Remember to install the packages first.
import {
	ButtonView,
	Dialog,
	View,
	Plugin,
	ClassicEditor,
	Paragraph,
	Essentials,
	Bold,
	Italic
} from 'ckeditor5';

// Create a plugin that brings a button that toggles the visibility of a dialog window.
// Read more about creating the plugins here: https://ckeditor.com/docs/ckeditor5/latest/framework/architecture/plugins.html.
class MinimalisticDialog extends Plugin {
	// Make sure the "Dialog" plugin is loaded.
	get requires() {
		return [ Dialog ];
	}

init() {
		// Add a button to the component factory so it is available for the editor.
		this.editor.ui.componentFactory.add( 'showDialog', locale => {
			const buttonView = new ButtonView( locale );

buttonView.set( {
				label: 'Show a dialog',
				tooltip: true,
				withText: true
			} );

// Define the button behavior on press.
			buttonView.on( 'execute', () => {
				const dialog = this.editor.plugins.get( 'Dialog' );

// If the button is turned on, hide the dialog.
				if ( buttonView.isOn ) {
					dialog.hide();
					buttonView.isOn = false;

return;
				}

buttonView.isOn = true;

// Otherwise, show the dialog.
				// Create a view with some simple content. It will be displayed as a dialog's body.
				const textView = new View( locale );

textView.setTemplate( {
					tag: 'div',
					attributes: {
						style: {
							padding: 'var(--ck-spacing-large)',
							whiteSpace: 'initial',
							width: '100%',
							maxWidth: '500px'
						},
						tabindex: -1
					},
					children: [
						'This is the content of the dialog.',
						'You can put here text, images, inputs, buttons, etc.'
					]
				} );

// Tell the plugin to display a dialog with the title, content, and one action button.
				dialog.show( {
					title: 'Dialog with text',
					content: textView,
					actionButtons: [
						{
							label: 'OK',
							class: 'ck-button-action',
							withText: true,
							onExecute: () => dialog.hide()
						}
					],
					onHide() { buttonView.isOn = false; }
				} );
			} );

return buttonView;
		} );
	}
}

// Create an editor instance. Remember to have an element with the `[id="editor"]` attribute in the document.
ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Essentials, Paragraph, Bold, Italic, MinimalisticDialog, Dialog ],
		toolbar: [ 'bold', 'italic', '|', 'showDialog' ]
	} )
	.catch( error => {
		console.error( error.stack );
	} );
```

**CDN**

```js
// Necessary imports. Remember to install the packages first.
const {
	ButtonView,
	Dialog,
	View,
	Plugin,
	ClassicEditor,
	Paragraph,
	Essentials,
	Bold,
	Italic
} = CKEDITOR;

init() {
		// Add a button to the component factory so it is available for the editor.
		this.editor.ui.componentFactory.add( 'showDialog', locale => {
			const buttonView = new ButtonView( locale );

buttonView.set( {
				label: 'Show a dialog',
				tooltip: true,
				withText: true
			} );

// Define the button behavior on press.
			buttonView.on( 'execute', () => {
				const dialog = this.editor.plugins.get( 'Dialog' );

// If the button is turned on, hide the dialog.
				if ( buttonView.isOn ) {
					dialog.hide();
					buttonView.isOn = false;

return;
				}

buttonView.isOn = true;

// Otherwise, show the dialog.
				// Create a view with some simple content. It will be displayed as a dialog's body.
				const textView = new View( locale );

return buttonView;
		} );
	}
}

// Create an editor instance. Remember to have an element with the `[id="editor"]` attribute in the document.
ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Essentials, Paragraph, Bold, Italic, MinimalisticDialog, Dialog ],
		toolbar: [ 'bold', 'italic', '|', 'showDialog' ]
	} )
	.catch( error => {
		console.error( error.stack );
	} );
```

See the guide about the [API of the dialog system](#ckeditor5/latest/framework/architecture/ui-library.html--dialogs-and-modals).

### Modal

Modal is a specific kind of dialog window. While open, it does not allow to interact with the editor content – it has to be closed first. You can use a modal to enforce the user interaction or interrupt them in some important situations.

To create a modal, use the optional [`isModal`](../../api/module_ui_dialog_dialog-DialogDefinition.html#member-isModal) property of the [`Dialog#show()`](../../api/module_ui_dialog_dialog-Dialog.html#function-show) method.

**NPM**

```js
// Necessary imports. Remember to install the packages first.
import {
	ButtonView,
	Dialog,
	View,
	Plugin,
	ClassicEditor,
	Paragraph,
	Essentials,
	Bold,
	Italic
} from 'ckeditor5';

// Create a plugin that brings a button which toggles the visibility of a modal window.
// Read more about creating the plugins here: https://ckeditor.com/docs/ckeditor5/latest/framework/architecture/plugins.html.
class MinimalisticModal extends Plugin {
	// Make sure the "Dialog" plugin is loaded.
	get requires() {
		return [ Dialog ];
	}

init() {
		// Add a button to the component factory so it is available for the editor.
		this.editor.ui.componentFactory.add( 'showModal', locale => {
			const buttonView = new ButtonView( locale );

buttonView.set( {
				label: 'Show a modal',
				tooltip: true,
				withText: true
			} );

// Define the button behavior on press.
			buttonView.on( 'execute', () => {
				const dialog = this.editor.plugins.get( 'Dialog' );

// If the button is turned on, hide the modal.
				if ( buttonView.isOn ) {
					dialog.hide();
					buttonView.isOn = false;

return;
				}

buttonView.isOn = true;

// Otherwise, show the modal.
				// First, create a view with some simple content. It will be displayed as the dialog's body.
				const textView = new View( locale );

textView.setTemplate( {
					tag: 'div',
					attributes: {
						style: {
							padding: 'var(--ck-spacing-large)',
							whiteSpace: 'initial',
							width: '100%',
							maxWidth: '500px'
						},
						tabindex: -1
					},
					children: [
						'This is a sample content of the modal.',
						'You can put here text, images, inputs, buttons, etc.'
					]
				} );

// Tell the plugin to display a modal with the title, content, and one action button.
				dialog.show( {
					isModal: true,
					title: 'Modal with text',
					content: textView,
					actionButtons: [
						{
							label: 'OK',
							class: 'ck-button-action',
							withText: true,
							onExecute: () => dialog.hide()
						}
					],
					onHide() { buttonView.isOn = false; }
				} );
			} );

return buttonView;
		} );
	}
}

// Create an editor instance. Remember to have an element with the `[id="editor"]` attribute in the document.
ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
		plugins: [ Essentials, Paragraph, Bold, Italic, MinimalisticDialog, Dialog ],
		toolbar: [ 'bold', 'italic', '|', 'showModal' ]
	} )
	.catch( error => {
		console.error( error.stack );
	} );
```

**CDN**

```js
// Necessary imports. Remember to install the packages first.
const {
	ButtonView,
	Dialog,
	View,
	Plugin,
	ClassicEditor,
	Paragraph,
	Essentials,
	Bold,
	Italic
} = CKEDITOR;

init() {
		// Add a button to the component factory so it is available for the editor.
		this.editor.ui.componentFactory.add( 'showModal', locale => {
			const buttonView = new ButtonView( locale );

buttonView.set( {
				label: 'Show a modal',
				tooltip: true,
				withText: true
			} );

// Define the button behavior on press.
			buttonView.on( 'execute', () => {
				const dialog = this.editor.plugins.get( 'Dialog' );

// If the button is turned on, hide the modal.
				if ( buttonView.isOn ) {
					dialog.hide();
					buttonView.isOn = false;

return;
				}

buttonView.isOn = true;

// Otherwise, show the modal.
				// First, create a view with some simple content. It will be displayed as the dialog's body.
				const textView = new View( locale );

textView.setTemplate( {
					tag: 'div',
					attributes: {
						style: {
							padding: 'var(--ck-spacing-large)',
							whiteSpace: 'initial',
							width: '100%',
							maxWidth: '500px'
						},
						tabindex: -1
					},
					children: [
						'This is a sample content of the modal.',
						'You can put here text, images, inputs, buttons, etc.'
					]
				} );

return buttonView;
		} );
	}
}

// Create an editor instance. Remember to have an element with the `[id="editor"]` attribute in the document.
ClassicEditor
	.create( {
		attachTo: document.querySelector( '#editor' ),
		licenseKey: '<YOUR_LICENSE_KEY>',
		plugins: [ Essentials, Paragraph, Bold, Italic, MinimalisticDialog, Dialog ],
		toolbar: [ 'bold', 'italic', '|', 'showModal' ]
	} )
	.catch( error => {
		console.error( error.stack );
	} );
```

See the guide about the [API of the dialog system](#ckeditor5/latest/framework/architecture/ui-library.html--dialogs-and-modals).

### Icons

The CKEditor 5 library has a collection of icons representing different editor functionalities. Icons are SVG files and follow the style of the surrounding text. You can instantiate an icon with the [`IconView`](../../api/module_ui_icon_iconview-IconView.html) class. The [`content`](../../api/module_ui_icon_iconview-IconView.html#member-content) property stores the SVG source of the icon.

**NPM**

```js
import { IconView, IconBold } from 'ckeditor5';

const icon = new IconView();

icon.content = IconBold;
icon.render();

document.getElementById( 'icon-bold' ).append( icon.element );
```

**CDN**

```js
const { IconView, IconBold } = CKEDITOR;

const icon = new IconView();

icon.content = IconBold;
icon.render();

document.getElementById( 'icon-bold' ).append( icon.element );
```

CKEditor 5 features use different icons. You can find them in the `@ckeditor/ckeditor5-icons` package.

You can also [add a custom icon to the dropdown](#ckeditor5/latest/framework/architecture/ui-library.html--setting-label-icon-and-tooltip) by providing the entire XML string of the icon

### Input

The CKEditor 5 UI library contains some input elements. Usually, they are used in dropdowns and balloon panels, but you can also use them in the main toolbar.

To create them, use the [`LabeledFieldView`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html) class, which takes two parameters:

* An instance of the [`locale`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html#member-locale) class.
* A helper function, depending on the type of field you want to create.

#### Text

To create a text field, pass the [`createLabeledInputText()`](../../api/module_ui_labeledfield_utils.html#constant-createLabeledInputText) helper function as the second parameter to the [`LabeledFieldView`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html) class.

**NPM**

```js
import { createLabeledInputText, LabeledFieldView, Locale } from 'ckeditor5';

const locale = new Locale();

const textInput = new LabeledFieldView( locale, createLabeledInputText );
textInput.set( { label: 'Text input', value: 'Value of the input' } );
textInput.render();

document.getElementById( 'input-text' ).append( textInput.element );
```

**CDN**

```js
const { createLabeledInputText, LabeledFieldView, Locale } = CKEDITOR;

const locale = new Locale();

const textInput = new LabeledFieldView( locale, createLabeledInputText );
textInput.set( { label: 'Text input', value: 'Value of the input' } );
textInput.render();

document.getElementById( 'input-text' ).append( textInput.element );
```

#### Number

To create a number field, pass the [`createLabeledInputNumber()`](../../api/module_ui_labeledfield_utils.html#constant-createLabeledInputNumber) helper function as the second parameter to the [`LabeledFieldView`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html) class.

**NPM**

```js
import { createLabeledInputNumber, LabeledFieldView, Locale } from 'ckeditor5';

const locale = new Locale();

const numberInput = new LabeledFieldView( locale, createLabeledInputNumber );
numberInput.set( { label: 'Number input', value: 'Value of the input' } );
numberInput.render();

document.getElementById( 'input-number' ).append( numberInput.element );
```

**CDN**

```js
const { createLabeledInputNumber, LabeledFieldView, Locale } = CKEDITOR;

const locale = new Locale();

const numberInput = new LabeledFieldView( locale, createLabeledInputNumber );
numberInput.set( { label: 'Number input', value: 'Value of the input' } );
numberInput.render();

document.getElementById( 'input-number' ).append( numberInput.element );
```

#### States

Similarly to buttons, inputs can be enabled or disabled. The property names remain the same.

##### Enabled

Inputs are enabled by default. You can also set the state explicitly by adding the [`isEnabled`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html#member-isEnabled) property with a `true` value.

**NPM**

```js
import { createLabeledInputText, LabeledFieldView, Locale } from 'ckeditor5';

const locale = new Locale();

const enabledInput = new LabeledFieldView( locale, createLabeledInputText );
enabledInput.set( { label: 'Enabled state', isEnabled: true } );
enabledInput.render();

document.getElementById( 'input-enabled' ).append( enabledInput.element );
```

**CDN**

```js
const { createLabeledInputText, LabeledFieldView, Locale } = CKEDITOR;

const locale = new Locale();

const enabledInput = new LabeledFieldView( locale, createLabeledInputText );
enabledInput.set( { label: 'Enabled state', isEnabled: true } );
enabledInput.render();

document.getElementById( 'input-enabled' ).append( enabledInput.element );
```

##### Disabled

To disable an input, set the [`isEnabled`](../../api/module_ui_labeledfield_labeledfieldview-LabeledFieldView.html#member-isEnabled) property to `false`. It prevents the input from getting users’ data.

**NPM**

```js
import { createLabeledInputText, LabeledFieldView, Locale } from 'ckeditor5';

const locale = new Locale();

const disabledInput = new LabeledFieldView( locale, createLabeledInputText );
disabledInput.set( { label: 'Disabled state', isEnabled: false } );
disabledInput.render();

document.getElementById( 'input-disabled' ).append( disabledInput.element );
```

**CDN**

```js
const { createLabeledInputText, LabeledFieldView, Locale } = CKEDITOR;

const locale = new Locale();

const disabledInput = new LabeledFieldView( locale, createLabeledInputText );
disabledInput.set( { label: 'Disabled state', isEnabled: false } );
disabledInput.render();

document.getElementById( 'input-disabled' ).append( disabledInput.element );
```

### Search

A search component allows you to filter a list of items based on a specified query. It consists of several components and interfaces:

* To create it, use the main [`SearchTextView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html) class.
* The [`queryView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html#member-queryView) property allows the user to enter the search query.
* The [`infoView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html#member-infoView) property displays additional information about the search results.
* The [`filteredView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html#member-filteredView) is a view filtered by the search query. Remember to specify the [`filter()`](../../api/module_ui_search_filteredview-FilteredView.html#function-filter) and [`focus()`](../../api/module_ui_search_filteredview-FilteredView.html#function-focus) methods for this view.

Some sub-components and classes that can help with better presentation of the results:

* The [`SearchResultsView`](../../api/module_ui_search_searchresultsview-SearchResultsView.html) component hosts the filtered and the information views. It is a sub-component of the [`SearchTextView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html).
* The [`AutocompleteView`](../../api/module_ui_autocomplete_autocompleteview-AutocompleteView.html) component lists proposed results when the user starts typing and hides them when it is out of focus. It extends the [`SearchTextView`](../../api/module_ui_search_text_searchtextview-SearchTextView.html) class.
* To group list items, you can use the [`ListItemGroupView`](../../api/module_ui_list_listitemgroupview-ListItemGroupView.html) class.
* To highlight some results (or some text in general), you can use the [`HighlightedTextView`](../../api/module_ui_highlightedtext_highlightedtextview-HighlightedTextView.html) class.

**NPM**

```js
import { ListView, SearchTextView, Locale } from 'ckeditor5';

const locale = new Locale();

const filteredView = new ListView();
filteredView.filter = () => {
	return {
		resultsCount: 1,
		totalItemsCount: 5
	};
};

const searchView = new SearchTextView( locale, {
	filteredView,
	queryView: {
		label: 'Label'
	}
} );

searchView.render();

document.querySelector( '.ui-search' ).append( searchView.element );
```

**CDN**

```js
const { ListView, SearchTextView, Locale } = CKEDITOR;

const locale = new Locale();

const filteredView = new ListView();
filteredView.filter = () => {
	return {
		resultsCount: 1,
		totalItemsCount: 5
	};
};

const searchView = new SearchTextView( locale, {
	filteredView,
	queryView: {
		label: 'Label'
	}
} );

searchView.render();

document.querySelector( '.ui-search' ).append( searchView.element );
```

Check out the [AI Assistant](#ckeditor5/latest/features/ai/ai-assistant/ai-assistant-overview.html--demo) feature to see how all the UI pieces work together in a more complex setup.

### Spinner

You can use a spinner to indicate some loading process. There is only one essential property here – [`isVisible`](../../api/module_ui_spinner_spinnerview-SpinnerView.html#member-isVisible). As the name suggests, it controls whether the component is visible. The default is `false`.

**NPM**

```js
import { SpinnerView } from 'ckeditor5';

const spinner = new SpinnerView();

spinner.set( { isVisible: true } );
spinner.render();

document.querySelector( '.ui-spinner' ).append( spinner.element );
```

**CDN**

```js
const { SpinnerView } = CKEDITOR;

const spinner = new SpinnerView();

spinner.set( { isVisible: true } );
spinner.render();

document.querySelector( '.ui-spinner' ).append( spinner.element );
```

### Textarea

The textarea is a component for inserting long blocks of text. You can specify the visible height of the component using the [`minRows`](../../api/module_ui_textarea_textareaview-TextareaView.html#member-minRows) property. Specify the [`maxRows`](../../api/module_ui_textarea_textareaview-TextareaView.html#member-minRows) property if you do not want the component to exceed a certain height. Textarea dimensions do not need to be fixed, and you can allow users to change them with the [`resize`](../../api/module_ui_textarea_textareaview-TextareaView.html#member-resize) option. By default, the property is set to `'none'`, and resizing is not allowed.

**NPM**

```js
import { TextareaView } from 'ckeditor5';

const textarea = new TextareaView();

textarea.set( {
	minRows: 4,
	maxRows: 10,
	resize: 'horizontal'
} );
textarea.render();

document.querySelector( '.ui-textarea' ).append( textarea.element );
```

**CDN**

```js
const { TextareaView } = CKEDITOR;

const textarea = new TextareaView();

textarea.set( {
	minRows: 4,
	maxRows: 10,
	resize: 'horizontal'
} );
textarea.render();

document.querySelector( '.ui-textarea' ).append( textarea.element );
```

### Toolbar

A toolbar is a base for other components. Usually, you would put other UI elements inside it. It can also be nested inside a balloon or dropdown. You can use the [`ToolbarView`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html) class to instantiate a toolbar.

#### Text

You can put different UI elements inside a toolbar. A simple text node is one example. You can use the [`items`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html#member-items) property to add a component to a toolbar.

**NPM**

```js
import { ToolbarView, View,	Locale } from 'ckeditor5';

const locale = new Locale();

const text = new View();
text.element = document.createTextNode( 'Toolbar text' );

const toolbarText = new ToolbarView( locale );
toolbarText.items.add( text );
toolbarText.render();

document.getElementById( 'toolbar-text' ).append( toolbarText.element );
```

**CDN**

```js
const { ToolbarView, View,	Locale } = CKEDITOR;

const locale = new Locale();

const text = new View();
text.element = document.createTextNode( 'Toolbar text' );

const toolbarText = new ToolbarView( locale );
toolbarText.items.add( text );
toolbarText.render();

document.getElementById( 'toolbar-text' ).append( toolbarText.element );
```

#### Button

You can place any previously listed button inside a toolbar.

**NPM**

```js
import { ButtonView, ToolbarView, Locale } from 'ckeditor5';

const locale = new Locale();

const button = new ButtonView();
button.set( { label: 'Button', withText: true } );

const toolbarButton = new ToolbarView( locale );
toolbarButton.items.add( button );
toolbarButton.render();

document.getElementById( 'toolbar-button' ).append( toolbarButton.element );
```

**CDN**

```js
const { ButtonView, ToolbarView, Locale } = CKEDITOR;

const locale = new Locale();

const button = new ButtonView();
button.set( { label: 'Button', withText: true } );

const toolbarButton = new ToolbarView( locale );
toolbarButton.items.add( button );
toolbarButton.render();

document.getElementById( 'toolbar-button' ).append( toolbarButton.element );
```

#### Wrap

A toolbar automatically wraps if you add more items and the space is limited.

**NPM**

```js
import { ButtonView, ToolbarView, Locale } from 'ckeditor5';

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const buttons = [ createButton(), createButton(), createButton() ];

const toolbarWrap = new ToolbarView( locale );
buttons.forEach( button => toolbarWrap.items.add( button ) );
toolbarWrap.render();
toolbarWrap.element.style.width = '150px';

document.getElementById( 'toolbar-wrap' ).append( toolbarWrap.element );
```

**CDN**

```js
const { ButtonView, ToolbarView, Locale } = CKEDITOR;

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const buttons = [ createButton(), createButton(), createButton() ];

const toolbarWrap = new ToolbarView( locale );
buttons.forEach( button => toolbarWrap.items.add( button ) );
toolbarWrap.render();
toolbarWrap.element.style.width = '150px';

document.getElementById( 'toolbar-wrap' ).append( toolbarWrap.element );
```

#### Separator

You can divide toolbar elements with a separator to create logically connected groups. To instantiate a separator, use the [`ToolbarSeparatorView`](../../api/module_ui_toolbar_toolbarseparatorview-ToolbarSeparatorView.html) class. Adding the created instance between desired components will separate them visually.

**NPM**

```js
import { ButtonView, ToolbarSeparatorView, ToolbarView,	Locale } from 'ckeditor5';

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const separator = new ToolbarSeparatorView();

const items = [ createButton(), separator, createButton() ];

const toolbarSeparator = new ToolbarView( locale );
items.forEach( item => toolbarSeparator.items.add( item ) );
toolbarSeparator.render();

document.getElementById( 'toolbar-separator' ).append( toolbarSeparator.element );
```

**CDN**

```js
const { ButtonView, ToolbarSeparatorView, ToolbarView,	Locale } = CKEDITOR;

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const separator = new ToolbarSeparatorView();

const items = [ createButton(), separator, createButton() ];

const toolbarSeparator = new ToolbarView( locale );
items.forEach( item => toolbarSeparator.items.add( item ) );
toolbarSeparator.render();

document.getElementById( 'toolbar-separator' ).append( toolbarSeparator.element );
```

#### Multi-row

By default, a toolbar has one row. However, it can span into multiple rows. You can instantiate a line break with the [`ToolbarLineBreakView`](../../api/module_ui_toolbar_toolbarlinebreakview-ToolbarLineBreakView.html) class. Adding the created instance after a desired component will place the following UI elements into the next row.

**NPM**

```js
import { ButtonView, ToolbarLineBreakView, ToolbarView, Locale } from 'ckeditor5';

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const newLine = new ToolbarLineBreakView( locale );

const items = [ createButton(), newLine, createButton() ];

const toolbarMultiRow = new ToolbarView( locale );
items.forEach( item => toolbarMultiRow.items.add( item ) );
toolbarMultiRow.render();

document.getElementById( 'toolbar-multirow' ).append( toolbarMultiRow.element );
```

**CDN**

```js
const { ButtonView, ToolbarLineBreakView, ToolbarView, Locale } = CKEDITOR;

const locale = new Locale();

function createButton() {
	const button = new ButtonView();
	button.set( { label: 'Button', withText: true } );
	return button;
}

const newLine = new ToolbarLineBreakView( locale );

const items = [ createButton(), newLine, createButton() ];

const toolbarMultiRow = new ToolbarView( locale );
items.forEach( item => toolbarMultiRow.items.add( item ) );
toolbarMultiRow.render();

document.getElementById( 'toolbar-multirow' ).append( toolbarMultiRow.element );
```

#### Compact

There is also a smaller version of a toolbar. To get a compact toolbar, set the [`isCompact`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html#member-isCompact) property to `true`.

**NPM**

```js
import { ButtonView, ToolbarView, Locale } from 'ckeditor5';

const locale = new Locale();

const button = new ButtonView();
button.set( { label: 'Button', withText: true } );

const toolbarCompact = new ToolbarView( locale );
toolbarCompact.isCompact = true;
toolbarCompact.items.add( button );
toolbarCompact.render();

document.getElementById( 'toolbar-compact' ).append( toolbarCompact.element );
```

**CDN**

```js
const { ButtonView, ToolbarView, Locale } = CKEDITOR;

const locale = new Locale();

const button = new ButtonView();
button.set( { label: 'Button', withText: true } );

const toolbarCompact = new ToolbarView( locale );
toolbarCompact.isCompact = true;
toolbarCompact.items.add( button );
toolbarCompact.render();

document.getElementById( 'toolbar-compact' ).append( toolbarCompact.element );
```

<a id="ckeditor5/latest/framework/architecture/ui-library.html">source file: "ckeditor5/latest/framework/architecture/ui-library.html"</a>

## UI library

The standard UI library of CKEditor 5 is [`@ckeditor/ckeditor5-ui`](https://www.npmjs.com/package/@ckeditor/ckeditor5-ui). It provides base classes and helpers that allow for building a modular UI that seamlessly integrates with other components of the ecosystem.

### Views

Views use [templates](#ckeditor5/latest/framework/architecture/ui-library.html--templates) to build the UI. They also provide observable interfaces that other features (like [plugins](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--plugins) or [commands](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--commands)) can use to change the DOM without any actual interaction with the native API.

> **Note**
>
> You can localize all views using the `locale` instance with which they were created. Check the [localization guide](#ckeditor5/latest/framework/deep-dive/ui/localization.html) to see how to use the `t()` function available in the `locale` instance.

#### Definition

You can define a simple input view class as follows:

```js
class SimpleInputView extends View {
    constructor( locale ) {
        super( locale );

// An entry point to binding observables with DOM attributes,
        // events, and text nodes.
        const bind = this.bindTemplate;

// Views define their interface (state) using observable properties.
        this.set( {
            isEnabled: false,
            placeholder: ''
        } );

this.setTemplate( {
            tag: 'input',
            attributes: {
                class: [
                    'foo',
                    // The value of "view#isEnabled" will control the presence
                    // of the class.
                    bind.if( 'isEnabled', 'ck-enabled' ),
                ],

// The HTML "placeholder" attribute is also controlled by the observable.
                placeholder: bind.to( 'placeholder' ),
                type: 'text'
            },
            on: {
                // DOM "keydown" events will fire the "view#input" event.
                keydown: bind.to( 'input' )
            }
        } );
    }

setValue( newValue ) {
        this.element.value = newValue;
    }
}
```

Views encapsulate the DOM they render. Because the UI is organized according to the _view-per-tree_ rule, it is clear which view is responsible for which part of the UI. It is unlikely that a collision occurs between two features writing to the same DOM node.

More often than not, views become children of other views (collections), nodes in the [UI view tree](#ckeditor5/latest/framework/architecture/ui-library.html--view-collections-and-the-ui-tree):

```js
class ParentView extends View {
    constructor( locale ) {
        super( locale );

const childA = new SimpleInputView( locale );
        const childB = new SimpleInputView( locale );

this.setTemplate( {
            tag: 'div',
            children: [
                childA,
                childB
            ]
        } );
    }
}

const parent = new ParentView( locale );

parent.render();

// This will insert <div><input .. /><input .. /></div>.
document.body.appendChild( parent.element );
```

It is also possible to create standalone views that do not belong to any collection. They must be [rendered](../../api/module_ui_view-View.html#function-render) before injection into the DOM:

```js
const view = new SimpleInputView( locale );

view.render();

// This will insert <input class="foo" type="text" placeholder="" />
document.body.appendChild( view.element );
```

#### Interaction

Features can interact with the state of the DOM via the observable properties of the view, so the following:

```js
view.isEnabled = true;
view.placeholder = 'Type some text';
```

will result in:

```html
<input class="foo ck-enabled" type="text" placeholder="Type some text" />
```

Alternatively, they can [bind](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--event-system-and-observables) them directly to their own observable properties:

```js
view.bind( 'placeholder', 'isEnabled' ).to( observable, 'placeholderText', 'isEnabled' );

// The following will be automatically reflected in the "view#placeholder" and
// "view.element#placeholder" HTML attribute in the DOM.
observable.placeholderText = 'Some placeholder';
```

Also, since views propagate DOM events, features can now react to the user actions:

```js
// Each "keydown" event in the input will execute a command.
view.on( 'input', () => {
    editor.execute( 'myCommand' );
} );
```

#### Best practices

A complete view should provide an interface for the features, encapsulating DOM nodes and attributes. Features should not touch the DOM of the view using the native API. Any kind of interaction must be handled by the view that owns a [`element`](../../api/module_ui_view-View.html#member-element) to avoid collisions:

```js
// This will change the value of the input.
view.setValue( 'A new value of the input.' );

// WRONG! This is **NOT** the right way to interact with the DOM because it
// collides with an observable binding to the "#placeholderText". The value will
// be permanently overridden when the state of the observable changes.
view.element.placeholder = 'A new placeholder';
```

### Templates

[Templates](../../api/module_ui_template-Template.html) render DOM elements and text nodes in the UI library. Used primarily by [views](#ckeditor5/latest/framework/architecture/ui-library.html--views), they are the lowest layer of the UI connecting the application to the web page.

> **Note**
>
> Check out the [`TemplateDefinition`](../../api/module_ui_template-TemplateDefinition.html) to learn more about the template syntax and other advanced concepts.

Templates support [observable properties](#ckeditor5/latest/framework/architecture/core-editor-architecture.html--event-system-and-observables) bindings and handle native DOM events. A simple template can look like this:

```js
new Template( {
    tag: 'p',
    attributes: {
        class: [
            'foo',
            bind.to( 'class' )
        ],
        style: {
            backgroundColor: 'yellow'
        }
    },
    on: {
        click: bind.to( 'clicked' )
    },
    children: [
        'A paragraph.'
    ]
} ).render();
```

It renders to an HTML element:

```html
<p class="foo bar" style="background-color: yellow;">A paragraph.</p>
```

where `observable#class` is `"bar"`. The `observable` in the example above can be a [view](#ckeditor5/latest/framework/architecture/ui-library.html--views) or any object which is [observable](../../api/module_utils_observablemixin-Observable.html). When the value of the `class` attribute changes, the template updates the `class` attribute in the DOM. From now on the element is permanently bound to the state of the application.

Similarly, when rendered, the template also takes care of DOM events. A binding to the `click` event in the definition makes the `observable` always fire the `clicked` event upon an action in the DOM. This way the `observable` provides an event interface of the DOM element and all the communication should pass through it.

### View collections and the UI tree

Views are organized into [collections](../../api/module_ui_viewcollection-ViewCollection.html), which manage their elements and propagate DOM events even further. Adding or removing a view in a collection moves the [view’s element](../../api/module_ui_view-View.html#member-element) in the DOM to reflect the position.

Each editor UI has a “root view” (like [`ClassicEditor#view`](../../api/module_editor-classic_classiceditorui-ClassicEditorUI.html#member-view)), which can be found under `editor.ui.view`. Such a view usually defines the container element of the editor and the undermost view collections that other features can populate.

For instance, the `BoxedEditorUiView` class defines two collections:

* [`top`](../../api/module_ui_editorui_boxed_boxededitoruiview-BoxedEditorUIView.html#member-top) – A collection that hosts the toolbar.
* [`main`](../../api/module_ui_editorui_boxed_boxededitoruiview-BoxedEditorUIView.html#member-main) – A collection that contains the editable area of the editor.

It also inherits the [`body`](../../api/module_ui_editorui_editoruiview-EditorUIView.html#member-body) collection which resides directly in the `<body>` of the web page. It stores floating elements like [balloon panels](../../api/module_ui_panel_balloon_balloonpanelview-BalloonPanelView.html).

Plugins can populate the root view collections with their children. Such child views become a part of the UI tree and will be managed by the editor. This means that, for example, they will be initialized and destroyed along with the editor.

```js
class MyPlugin extends Plugin {
    init() {
        const editor = this.editor;
        const view = new MyPluginView();

editor.ui.top.add( view );
    }
}
```

`MyPluginView` can [create its view collections](../../api/module_ui_view-View.html#function-createCollection) and populate them during the life cycle of the editor. There is no limit to the depth of the UI tree, which usually looks like this:

```
EditorUIView
    ├── "top" collection
    │    └── ToolbarView
    │        └── "items" collection
    │            ├── DropdownView
    │            │    ├── ButtonView
    │            │    └── PanelView
    │            ├── ButtonViewA
    │            ├── ButtonViewB
    │            └── ...
    ├── "main" collection
    │    └── InlineEditableUIView
    └── "body" collection
        ├── BalloonPanelView
        │    └── "content" collection
        │        └── ToolbarView
        ├── BalloonPanelView
        │    └── "content" collection
        │        └── ...
        └── ...
```

### Using the existing components

The framework provides some common [components](../../api/ui.html) like [`ButtonView`](../../api/module_ui_button_buttonview-ButtonView.html) or [`ToolbarView`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html). They can be helpful when developing a new user interface.

For example, to create a toolbar with some buttons inside, you need to import the `ToolbarView` and `ButtonView` classes first:

**NPM**

```js
import { ButtonView, ToolbarView } from 'ckeditor5';
```

**CDN**

```js
const { ButtonView, ToolbarView } = CKEDITOR;
```

Create the toolbar and a couple of buttons with labels first. Then append the buttons to the toolbar:

```js
const toolbar = new ToolbarView();
const buttonFoo = new ButtonView();
const buttonBar = new ButtonView();

buttonFoo.set( {
    label: 'Foo',
    withText: true
} );

buttonBar.set( {
    label: 'Bar',
    withText: true
} );

toolbar.items.add( buttonFoo );
toolbar.items.add( buttonBar );
```

The toolbar can now join the [UI tree](#ckeditor5/latest/framework/architecture/ui-library.html--view-collections-and-the-ui-tree) or it can be injected straight into the DOM. To keep the example simple, proceed with the latter scenario:

```js
toolbar.render();

document.body.appendChild( toolbar.element );
```

The result should look like this:

The toolbar renders but it does not do much. To execute an action when the button is clicked, you must define a listener. To shorten the code and instead of two listeners define just one, the buttons can [delegate](../../api/module_utils_emittermixin-Emitter.html#function-delegate) the [`execute`](../../api/module_ui_button_button-Button.html#event-execute) event to their parent:

```js
buttonFoo.delegate( 'execute' ).to( toolbar );
buttonBar.delegate( 'execute' ).to( toolbar );

toolbar.on( 'execute', evt => {
    console.log( `The "${ evt.source.label }" button was clicked!` );
} );
```

#### Dropdowns

The framework implements the [dropdown](../../api/module_ui_dropdown_dropdownview-DropdownView.html) component which can host any sort of UI in its panel. It is composed of a [button](../../api/module_ui_dropdown_dropdownview-DropdownView.html#member-buttonView) (to open the dropdown) and a [panel](../../api/module_ui_dropdown_dropdownview-DropdownView.html#member-panelView) (the container).

The button can be either:

* A standard [`ButtonView`](../../api/module_ui_button_buttonview-ButtonView.html).
* A [`SplitButtonView`](../../api/module_ui_dropdown_button_splitbuttonview-SplitButtonView.html), for more complex use cases.

The dropdown panel exposes its [children](../../api/module_ui_dropdown_dropdownpanelview-DropdownPanelView.html#member-children) collection which aggregates the child [views](../../api/module_ui_view-View.html). The most common views displayed in the dropdown panel are:

* [`ListView`](../../api/module_ui_list_listview-ListView.html) - dropdown list
* [`ToolbarView`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html) - dropdown toolbar
* [`DropdownMenuRootListView`](../../api/module_ui_dropdown_menu_dropdownmenurootlistview-DropdownMenuRootListView.html) - dropdown menu

The framework provides a set of helpers to make the dropdown creation process easier. It is still possible to compose a custom dropdown from scratch using the base classes. However, for most needs, we highly recommend using provided helper functions.

The [`createDropdown`](../../api/module_ui_dropdown_utils.html#function-createDropdown) helper creates a [`DropdownView`](../../api/module_ui_dropdown_dropdownview-DropdownView.html) with either a [`ButtonView`](../../api/module_ui_button_buttonview-ButtonView.html) or a [`SplitButtonView`](../../api/module_ui_dropdown_button_splitbuttonview-SplitButtonView.html).

**NPM**

```js
import { createDropdown, SplitButtonView } from 'ckeditor5';

const dropdownView = createDropdown( locale, SplitButtonView );
```

**CDN**

```js
const { createDropdown, SplitButtonView } = CKEDITOR;

const dropdownView = createDropdown( locale, SplitButtonView );
```

This kind of (default) dropdown comes with a set of behaviors:

* It closes the panel when it loses the focus, for example, when the user moved the focus elsewhere.
* It closes the panel upon the [`execute`](../../api/module_ui_dropdown_dropdownview-DropdownView.html#event-execute) event.
* It focuses the view hosted in the panel, for example, when navigating the toolbar using the keyboard.

##### Setting label, icon, and tooltip

To customize the button of the dropdown, use the [`buttonView`](../../api/module_ui_dropdown_dropdownview-DropdownView.html#member-buttonView) property. It gives direct access to the [`ButtonView` instance](../../api/module_ui_button_buttonview-ButtonView.html) used by your dropdown.

> **Note**
>
> If your dropdown was created using the [`SplitButtonView`](../../api/module_ui_dropdown_button_splitbuttonview-SplitButtonView.html), use the [`actionView`](../../api/module_ui_dropdown_button_splitbuttonview-SplitButtonView.html#member-actionView) to access its main region. For example: `dropdownView.buttonView.actionView.set( /* ... */ )`.

To control the label of the dropdown, first make it visible using the [`withText`](../../api/module_ui_button_buttonview-ButtonView.html#member-withText) property. Then set the text of the [`label`](../../api/module_ui_button_buttonview-ButtonView.html#member-label):

```js
const dropdownView = createDropdown( locale );

dropdownView.buttonView.set( {
    withText: true,
    label: 'Label of the button',
} );
```

The dropdown button can display an icon too. First, import the SVG file. Then pass it to the [`icon`](../../api/module_ui_button_buttonview-ButtonView.html#member-icon) property of the button:

```js
import iconFile from 'path/to/icon.svg';

// The code that creates a dropdown view.
// ...

dropdownView.buttonView.set( {
    icon: iconFile
} );
```

You can use one of the [icons available in the editor](#ckeditor5/latest/framework/architecture/ui-components.html--icons). You can also add a custom icon to the dropdown by providing the entire XML string of the icon, like in this example:

```html
<svg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M10.187 17H5.773c-.637 0-1.092-.138-1.364-.415-.273-.277-.409-.718-.409-1.323V4.738c0-.617.14-1.062.419-1.332.279-.27.73-.406 1.354-.406h4.68c.69 0 1.288.041 1.793.124.506.083.96.242 1.36.478.341.197.644.447.906.75a3.262 3.262 0 0 1 .808 2.162c0 1.401-.722 2.426-2.167 3.075C15.05 10.175 16 11.315 16 13.01a3.756 3.756 0 0 1-2.296 3.504 6.1 6.1 0 0 1-1.517.377c-.571.073-1.238.11-2 .11zm-.217-6.217H7v4.087h3.069c1.977 0 2.965-.69 2.965-2.072 0-.707-.256-1.22-.768-1.537-.512-.319-1.277-.478-2.296-.478zM7 5.13v3.619h2.606c.729 0 1.292-.067 1.69-.2a1.6 1.6 0 0 0 .91-.765c.165-.267.247-.566.247-.897 0-.707-.26-1.176-.778-1.409-.519-.232-1.31-.348-2.375-.348H7z"/></svg>
```

If you want to have an icon that changes its color depending on the state of the button, you should remove all of the fill and stroke attributes.

The `withText` and `icon` properties are independent so your dropdown can have:

* Just a text label.
* Just an icon.
* Both a label and an icon at the same time.

> **Note**
>
> Even if your dropdown has no visible label (`withText` is `false`), we recommend setting the `label` property anyway. Assistive technologies like screen readers need it to work correctly with the editor.

Dropdowns can also display tooltips when hovered. Use the [`tooltip`](../../api/module_ui_button_buttonview-ButtonView.html#member-tooltip) property of the button to enable this feature. You can include keystroke information in the tooltip or create custom tooltips. Check out the documentation of the property to learn more.

```js
dropdownView.buttonView.set( {
    // The tooltip text will repeat the label.
    tooltip: true
} );
```

##### Adding a list to a dropdown

The [`ListView`](../../api/module_ui_list_listview-ListView.html) can be added to a dropdown using the [`addListToDropdown`](../../api/module_ui_dropdown_utils.html#function-addListToDropdown) helper.

**NPM**

```js
import { UIModel, addListToDropdown, createDropdown, Collection } from 'ckeditor5';

// The default dropdown.
const dropdownView = createDropdown( locale );

// The collection of the list items.
const items = new Collection();

items.add( {
	type: 'button',
	model: new UIModel( {
		withText: true,
		label: 'Foo'
	} )
} );

items.add( {
	type: 'button',
	model: new UIModel( {
		withText: true,
		label: 'Bar'
	} )
} );

// Create a dropdown with a list inside the panel.
addListToDropdown( dropdownView, items );
```

**CDN**

```js
const { UIModel, addListToDropdown, createDropdown, Collection } = CKEDITOR;

// The default dropdown.
const dropdownView = createDropdown( locale );

// The collection of the list items.
const items = new Collection();

items.add( {
	type: 'button',
	model: new UIModel( {
		withText: true,
		label: 'Foo'
	} )
} );

items.add( {
	type: 'button',
	model: new UIModel( {
		withText: true,
		label: 'Bar'
	} )
} );

// Create a dropdown with a list inside the panel.
addListToDropdown( dropdownView, items );
```

##### Adding a toolbar to a dropdown

A [`ToolbarView`](../../api/module_ui_toolbar_toolbarview-ToolbarView.html) can be added to a dropdown using the [`addToolbarToDropdown`](../../api/module_ui_dropdown_utils.html#function-addToolbarToDropdown) helper.

**NPM**

```js
import { ButtonView, SplitButtonView, addToolbarToDropdown, createDropdown } from 'ckeditor5';

const buttons = [];

// Add a simple button to the array of toolbar items.
buttons.push( new ButtonView() );

// Add another component to the array of toolbar items.
buttons.push( componentFactory.create( 'componentName' ) );

const dropdownView = createDropdown( locale, SplitButtonView );

// Create a dropdown with a toolbar inside the panel.
addToolbarToDropdown( dropdownView, buttons );
```

**CDN**

```js
const { ButtonView, SplitButtonView, addToolbarToDropdown, createDropdown } = CKEDITOR;

const buttons = [];

// Add a simple button to the array of toolbar items.
buttons.push( new ButtonView() );

// Add another component to the array of toolbar items.
buttons.push( componentFactory.create( 'componentName' ) );

const dropdownView = createDropdown( locale, SplitButtonView );

// Create a dropdown with a toolbar inside the panel.
addToolbarToDropdown( dropdownView, buttons );
```

A common practice is making the main dropdown button [enabled](../../api/module_ui_dropdown_dropdownview-DropdownView.html#member-isEnabled) when one of the toolbar items is enabled:

```js
// Enable the dropdown's button when any of the toolbar items is enabled.
dropdownView.bind( 'isEnabled' ).toMany( buttons, 'isEnabled',
    ( ...areEnabled ) => areEnabled.some( isEnabled => isEnabled )
);
```

##### Adding a menu to a dropdown

A multi-level menu can be added to a dropdown using the [`addMenuToDropdown`](../../api/module_ui_dropdown_utils.html#function-addMenuToDropdown) helper.

**NPM**

```js
import { addMenuToDropdown, createDropdown } from 'ckeditor5';

// The default dropdown.
const dropdownView = createDropdown( editor.locale );

addMenuToDropdown( dropdownView, editor.body.ui.view, definition );
```

**CDN**

```js
const { addMenuToDropdown, createDropdown } = CKEDITOR;

// The default dropdown.
const dropdownView = createDropdown( editor.locale );

addMenuToDropdown( dropdownView, editor.body.ui.view, definition );
```

Most probably you will want to perform some action when one of the defined buttons is pressed:

```js
dropdownView.on( 'execute', evt => {
    const id = evt.source.id;

console.log( id ); // E.g. will print "menu_1_a" when "Item A" is pressed.
} );
```

#### Dialogs and modals

The framework provides the UI dialog component. The dialog system in CKEditor 5 is brought by the [`Dialog` plugin](../../api/module_ui_dialog_dialog-Dialog.html). It offers API for displaying [views](#ckeditor5/latest/framework/architecture/ui-library.html--views) in dialogs. In a sense, this plugin corresponds to another one that manages views in balloons (popovers) across the UI ([`ContextualBalloon` plugin](../../api/module_ui_panel_balloon_contextualballoon-ContextualBalloon.html)).

Dialog is a pop-up window that does not close when the user clicks outside of it. It allows for interacting with the editor and its content while being open (unless it is a modal, which blocks the interaction with the rest of the page until closed). A dialog is also [draggable](../../api/module_ui_bindings_draggableviewmixin.html#function-DraggableViewMixin) with a mouse or touch if you configure it to display a [header](#ckeditor5/latest/framework/architecture/ui-library.html--header). Only one dialog can be open at a time – opening another one closes the previously visible one.

Check out these [example plugins](#ckeditor5/latest/framework/architecture/plugins.html) that display:

* a [dialog window](#ckeditor5/latest/framework/architecture/ui-components.html--dialog),
* a [modal window](#ckeditor5/latest/framework/architecture/ui-components.html--modal).

Learn more about the [structure and behavior](#ckeditor5/latest/framework/architecture/ui-library.html--structure-and-behavior) of dialog windows.

##### Modals

Modals are similar to the dialogs – they share the same structure rules, API, etc. The major difference is that while a modal is open, the user cannot interact with the editor or the rest of the page. They are covered with a non-transparent overlay. You can use a modal, for example, to force the user to take one of the specified actions.

```js
editor.plugins.get( 'Dialog' ).show( {
    isModal: true,

// The rest of the dialog definition.
} );
```

There are different ways to close a modal:

* Clicking the “Close” button in the corner (if the [header](#ckeditor5/latest/framework/architecture/ui-library.html--header) is visible).
* Using the `Esc` keystroke or one of the [action buttons](#ckeditor5/latest/framework/architecture/ui-library.html--action-buttons).

> **Warning**
>
> Below you will learn about the ways to disable some of these methods. Remember to always leave at least one option to close the modal. Otherwise, you will lock the users inside a modal.

##### Structure and behavior

A dialog can consist of three parts, each of which is optional:

* The [header](#ckeditor5/latest/framework/architecture/ui-library.html--header) (also used as a drag handler).
* The [content](#ckeditor5/latest/framework/architecture/ui-library.html--content) (the body of the dialog).
* The [action buttons](#ckeditor5/latest/framework/architecture/ui-library.html--action-buttons) area (a collection of buttons).

You cannot change the order of these parts.

###### Header

A header may consist of any combination of three elements:

* The icon.
* The title.
* The “Close” button.

By default, the “Close” button (“X”) is added to the header as long as you provide an icon or a title. To hide it, set the `hasCloseButton` flag to `false`:

**NPM**

```js
import { IconPencil } from 'ckeditor5';

// ...

editor.plugins.get( 'Dialog' ).show( {
	icon: IconPencil,
	title: 'My first dialog',
	// Do not display the "Close" button.
	hasCloseButton: false,

// The rest of the dialog definition.
} );
```

**CDN**

```js
const { IconPencil } = CKEDITOR;

// ...

editor.plugins.get( 'Dialog' ).show( {
	icon: IconPencil,
	title: 'My first dialog',
	// Do not display the "Close" button.
	hasCloseButton: false,

// The rest of the dialog definition.
} );
```

> **Note**
>
> If you decide to hide the “Close” button, remember to leave some other way to close the dialog. The `Esc` keystroke also closes the dialog but it may not be available, for example, for touch screen users.

###### Content

This part can be a single [view](#ckeditor5/latest/framework/architecture/ui-library.html--views) or a collection of views. They will be displayed directly inside the body of the dialog. Below, you can find an example of how to insert a block of text into the dialog.

```js
const textView = new View( locale );

textView.setTemplate( {
    tag: 'div',
    attributes: {
        style: {
            padding: 'var(--ck-spacing-large)',
            whiteSpace: 'initial',
            width: '100%',
            maxWidth: '500px'
        },
        tabindex: -1
    },
    children: [
        'This is a sample content of the dialog.',
        'You can put here text, images, inputs, buttons, etc.'
    ]
} );

editor.plugins.get( 'Dialog' ).show( {
    title: 'Info dialog with text',
    content: textView,

// The rest of the dialog definition.
} );
```

The content of the dialog determines its dimensions. If you want to display a dialog with a fixed size, make sure the content has a fixed size too. For displaying long text, we recommend setting `max-height: [fixed value]` together with `overflow: auto` on the content container (element). This will restrict the vertical space the dialog will use on the screen.

###### Action buttons

The last segment of the dialog is the actions area, where the buttons are displayed. You can fully customize their behavior using the `onCreate()` and `onExecute()` callbacks. Below you can find an example of the configuration for the four custom buttons:

* The “OK” button that closes the dialog and has a custom CSS class set.
* The “Set custom title” button that changes the dialog title.
* The “This button will be enabled in…” button that changes its state after a few seconds.
* The “Cancel” button that closes the dialog.

```js
editor.plugins.get( 'Dialog' ).show( {
    // ...

actionButtons: [
        {
            label: 'OK',
            class: 'ck-button-action',
            withText: true,
            onExecute: () => dialog.hide()
        },
        {
            label: 'Set custom title',
            withText: true,
            onExecute: () => {
                dialog.view.headerView.label = 'New title';
            }
        },
        {
            label: 'This button will be enabled in 5...',
            withText: true,
            onCreate: buttonView => {
                buttonView.isEnabled = false;
                let counter = 5;

const interval = setInterval( () => {
                    buttonView.label = `This button will be enabled in ${ --counter }...`;

if ( counter === 0 ) {
                        clearInterval( interval );
                        buttonView.label = 'This button is now enabled!';
                        buttonView.isEnabled = true;
                    }
                }, 1000 );
            }
        },
        {
            label: 'Cancel',
            withText: true,
            onExecute: () => dialog.hide()
        }
    ]
} );
```

You can also bind the button state to the content to ensure some required actions were taken by the user. See the example of the “Yes/No modal” definition. It requires the user to mark the checkbox to close the modal:

```js
// First, create the content to be injected into a the modal.
// In this example a simple switch button is used.
const switchButtonView = new SwitchButtonView( locale );

switchButtonView.set( {
    label: t( 'I accept the terms and conditions' ),
    withText: true
} );

// Manage the state of the switch button when the user clicks it.
switchButtonView.on( 'execute', () => {
    switchButtonView.isOn = !switchButtonView.isOn;
} );

// Then show the modal.
editor.plugins.get( 'Dialog' ).show( {
    id: 'yesNoModal',
    isModal: true,
    title: 'Accept the terms to enable the "Yes" button',
    hasCloseButton: false,
    content: switchButtonView,
    actionButtons: [
        {
            label: t( 'Yes' ),
            class: 'ck-button-action',
            withText: true,
            onExecute: () => dialog.hide(),
            onCreate: buttonView => {
                // By default, the "Yes" button in the dialog is disabled.
                buttonView.isEnabled = false;

// The "Yes" button will be enabled as soon as the user
                // toggles the switch button.
                switchButtonView.on( 'change:isOn', () => {
                    buttonView.isEnabled = switchButtonView.isOn;
                } );
            }
        },
        {
            label: t( 'No' ),
            withText: true,
            onExecute: () => dialog.hide()
        }
    ],
    // Disable the "Esc" key.
    onShow: dialog => {
        dialog.view.on( 'close', ( evt, data ) => {
            if ( data.source === 'escKeyPress' ) {
                evt.stop();
            }
        }, { priority: 'high' } );
    }
} );
```

##### Accessibility

Dialogs provide full keyboard accessibility.

* While a dialog is open, strike the `Ctrl`+`F6` combination to move the focus between the editor and the dialog.
* You can also close a dialog at any time by pressing the `Esc` key (even if the “Close” button is hidden).
* To navigate through the dialog, use the `Tab` and `Shift`+`Tab` keystrokes.

The content of the dialog is also available for screen readers.

##### API

The dialog’s lifecycle (creating and destroying) is managed by the [`Dialog` plugin](../../api/module_ui_dialog_dialog.html). It provides two public methods: [`show()`](../../api/module_ui_dialog_dialog-Dialog.html#function-show) and [`hide()`](../../api/module_ui_dialog_dialog-Dialog.html#function-hide). Both of them fire the respective events ([`show`](../../api/module_ui_dialog_dialog-DialogShowEvent.html) and [`hide`](../../api/module_ui_dialog_dialog-DialogHideEvent.html)), so it is possible to hook after or before them.

###### The `Dialog#show()` method

The [`Dialog#show()`](../../api/module_ui_dialog_dialog-Dialog.html#function-show) method hides any visible dialog and displays a new one. It accepts a dialog definition that allows to shape the structure and behavior of the dialog. See the [`DialogDefinition`](../../api/module_ui_dialog_dialog-DialogDefinition.html) API to learn more about the possibilities it gives.

###### The `Dialog#show:[id]` event

When the [`Dialog#show()`](#ckeditor5/latest/framework/architecture/ui-library.html--the-dialogshow-method) function gets called, a namespaced [`show:[id]`](../../api/module_ui_dialog_dialog-DialogShowEvent.html) event is fired. This allows for customizing the dialog’s behavior.

For example, you can change the default position of the “Find and replace” dialog from the editor corner to the bottom with the following code:

**NPM**

```js
import { DialogViewPosition } from 'ckeditor5';

// ...

editor.plugins.get( 'Dialog' ).on( 'show:findAndReplace', ( evt, data ) => {
	Object.assign( data, { position: DialogViewPosition.EDITOR_BOTTOM_CENTER } );
}, { priority: 'high' } );
```

**CDN**

```js
const { DialogViewPosition } = CKEDITOR;

// ...

editor.plugins.get( 'Dialog' ).on( 'show:findAndReplace', ( evt, data ) => {
	Object.assign( data, { position: DialogViewPosition.EDITOR_BOTTOM_CENTER } );
}, { priority: 'high' } );
```

You can also listen to the general `'show'` event to customize all dialogs at once.

###### The `Dialog#hide()` method

Executing the [`Dialog#hide()`](../../api/module_ui_dialog_dialog-Dialog.html#function-hide) method will hide the dialog. It will also call the [`onHide()`](#ckeditor5/latest/framework/architecture/ui-library.html--using-the-onshow-and-onhide-callbacks) callback if it was provided in the respective [`Dialog#show()`](../../api/module_ui_dialog_dialog-Dialog.html#function-show) method call.

###### The `Dialog#hide:[id]` event

Similarly to the [`show:[id]`](#ckeditor5/latest/framework/architecture/ui-library.html--the-dialogshowid-event) event, the [`hide:[id]`](../../api/module_ui_dialog_dialog-DialogHideEvent.html) event gets fired when the [`Dialog#hide()`](#ckeditor5/latest/framework/architecture/ui-library.html--the-dialoghide-method) is called. It allows for executing custom actions:

```js
// Logs after the "Find and Replace" dialog gets hidden.
editor.plugins.get( 'Dialog' ).on( 'hide:findAndReplace', () => {
    console.log( 'The "Find and Replace" dialog was hidden.' );
} );
```

You can also listen to the general `'hide'` event to react to all dialogs at once.

###### The `DialogView#close` event

When the `Esc` key or the “Close” button is pressed with the dialog open, the [`DialogView`](../../api/module_ui_dialog_dialogview-DialogView.html) fires the [`close`](../../api/module_ui_dialog_dialogview-DialogViewCloseEvent.html) event with the according `source` parameter. Then the [`Dialog` plugin](../../api/module_ui_dialog_dialog-Dialog.html) hides (and destroys) the dialog.

You can control this behavior, for example, disabling the `Esc` key handling:

```js
editor.plugins.get( 'Dialog' ).view.on( 'close', ( evt, data ) => {
    if ( data.source === 'escKeyPress' ) {
        evt.stop();
    }
} )
```

You can also pass such code directly in the `show()` method call in the `onShow` callback:

```js
editor.plugins.get( 'Dialog' ).show( {
    onShow: dialog => {
        dialog.view.on( 'close', ( evt, data ) => {
            if ( data.source === 'escKeyPress' ) {
                evt.stop();
            }
        }, { priority: 'high' } );
    }
    // The rest of the dialog definition.
} );
```

> **Warning**
>
> Blocking the usage of the `Esc` key limits the accessibility. It is considered a bad practice. If you need to do this, remember to always leave at least one way to close the dialog or modal.

###### Using the `onShow` and `onHide` callbacks

The [`DialogDefinition`](../../api/module_ui_dialog_dialog-DialogDefinition.html) accepts two callbacks. They allow customizing the actions after the dialog is shown ([`onShow()`](../../api/module_ui_dialog_dialog-DialogDefinition.html#member-onShow)) and hidden ([`onHide()`](../../api/module_ui_dialog_dialog-DialogDefinition.html#member-onHide)).

The `onShow` callback allows you to manipulate the dialog values or set additional listeners. In the [`DialogView#event:close` event](#ckeditor5/latest/framework/architecture/ui-library.html--the-dialogviewclose-event) section you can find an example of how to disable the `Esc` key with it. The code below shows how to bootstrap the dynamic field filling.

**NPM**

```js
// Import necessary classes.
import { View, InputTextView } from 'ckeditor5';

// Create an input.
const input = new InputTextView();
const dialogBody = new View();

dialogBody.setTemplate( {
	tag: 'div',
	children: [
		// Other elements of the view.
		input
	]
	// The rest of the template.
} );

editor.plugins.get( 'Dialog' ).show( {
	onShow: () => {
		// Set the dynamic initial input value.
		input.value = getDataFromExternalSource();
	},
	// The rest of the dialog definition.
} );
```

**CDN**

```js
// Import necessary classes.
const { View, InputTextView } = CKEDITOR;

// Create an input.
const input = new InputTextView();
const dialogBody = new View();

dialogBody.setTemplate( {
	tag: 'div',
	children: [
		// Other elements of the view.
		input
	]
	// The rest of the template.
} );

editor.plugins.get( 'Dialog' ).show( {
	onShow: () => {
		// Set the dynamic initial input value.
		input.value = getDataFromExternalSource();
	},
	// The rest of the dialog definition.
} );
```

The `onHide` callback will be particularly helpful to reset the state of the component or its controller once the dialog is closed.

```js
// Executing inside a class with the "controller" property that has the state connected to the dialog.
editor.plugins.get( 'Dialog' ).show( {
    onHide: dialog => {
        this.controller.reset(); // Reset the controller state once the dialog is hidden.
    },
    // The rest of the dialog definition.
} );
```

##### Visibility and positioning

Only one dialog can be visible at the same time. Opening another dialog (from the same or another editor instance) will close the previous dialog.

If not specified otherwise, the dialog will display in the center of the editor’s editing area. A modal will display in the center of the screen. Custom dialogs can have their position set to one of the pre-configured options (see [`DialogViewPosition`](../../api/module_ui_dialog_dialogview.html#constant-DialogViewPosition)). The relative positioning is disabled once the dialog is manually dragged by the user.

* When you develop your dialog, specify the [`position`](../../api/module_ui_dialog_dialog-DialogDefinition.html#member-position) property in a definition passed to the [`Dialog#show()`](../../api/module_ui_dialog_dialog-Dialog.html#function-show) method, for instance:

**NPM**

```js
import { DialogViewPosition } from 'ckeditor5';

// ...

const dialog = editor.plugins.get( 'Dialog' );

dialog.show( {
	// ...

// Change the default position of the dialog.
	position: DialogViewPosition.EDITOR_BOTTOM_CENTER
} );
```

**CDN**

```js
const { DialogViewPosition } = CKEDITOR;

// ...

const dialog = editor.plugins.get( 'Dialog' );

dialog.show( {
	// ...

// Change the default position of the dialog.
	position: DialogViewPosition.EDITOR_BOTTOM_CENTER
} );
```

* To change the position of an existing dialog or manage positions dynamically, use the [`show`](../../api/module_ui_dialog_dialog-DialogShowEvent.html) event listener (see the [example code](#ckeditor5/latest/framework/architecture/ui-library.html--the-dialogshowid-event)).

Sometimes, when the content of the dialog or the environment changes (for example, the editor is resized), you may want to force-update the position of the dialog. This will restore its position to the [configured default](../../api/module_ui_dialog_dialog-DialogDefinition.html#member-position). It will also reset any manual positioning (dragging) done by the user. To do so, use the [`updatePosition`](../../api/module_ui_dialog_dialogview-DialogView.html#function-updatePosition) method.

```js
editor.plugins.get( 'Dialog' ).view.updatePosition();
```

#### Best practices

For the best user experience, the editing view should get [focused](../../api/module_engine_view_view-EditingView.html#function-focus) upon any user action (like executing a command) to make sure the editor retains focus:

```js
// Execute some action on the "dropdown#execute" event.
dropdownView.buttonView.on( 'execute', () => {
    editor.execute( 'command', { value: "command-value" } );
    editor.editing.view.focus();
} );
```

### Keystrokes and focus management

The framework offers built-in classes that help manage keystrokes and focus in the UI. They are useful when it comes to bringing accessibility features to the application.

> **Note**
>
> If you want to know how the editor handles focus under the hood and what tools make it possible, check out the [Deep dive into focus tracking](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html) guide.

#### Focus tracker

The [`FocusTracker`](../../api/module_utils_focustracker-FocusTracker.html) class can observe some HTML elements and determine if one of them is focused either by the user (clicking, typing) or using the `HTMLElement.focus()` DOM method.

**NPM**

```js
import { FocusTracker } from 'ckeditor5';

// More imports.
// ...

const focusTracker = new FocusTracker();
```

**CDN**

```js
const { FocusTracker } = CKEDITOR;

// More imports.
// ...

const focusTracker = new FocusTracker();
```

To register elements in the tracker, use the [`add()`](../../api/module_utils_focustracker-FocusTracker.html#function-add) method:

```js
focusTracker.add( document.querySelector( '.some-element' ) );
focusTracker.add( viewInstance.element );
```

Observing the focus tracker’s [`isFocused`](../../api/module_utils_focustracker-FocusTracker.html#member-isFocused) observable property allows you to determine whether one of the registered elements is currently focused:

```js
focusTracker.on( 'change:isFocused', ( evt, name, isFocused ) => {
    if ( isFocused ) {
        console.log( 'The', focusTracker.focusedElement, 'is focused now.' );
    } else {
        console.log( 'The elements are blurred.' );
    }
} );
```

This information is useful when implementing a certain type of UI whose behavior depends on the focus. For example, contextual panels and floating balloons containing forms should hide when the user decides to abandon them.

Learn more about the focus tracker class in the [Deep dive into focus tracking](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class) guide.

#### Keystroke handler

The [`KeystrokeHandler`](../../api/module_utils_keystrokehandler-KeystrokeHandler.html) listens to the keystroke events fired by an HTML element or any of its descendants. It executes pre-defined actions when the keystroke is pressed. Usually, each [view](#ckeditor5/latest/framework/architecture/ui-library.html--views) creates its keystroke handler instance. It takes care of the keystrokes fired by the elements the view has rendered.

**NPM**

```js
import { KeystrokeHandler } from 'ckeditor5';

// More imports.
// ...

const keystrokeHandler = new KeystrokeHandler();
```

**CDN**

```js
const { KeystrokeHandler } = CKEDITOR;

// More imports.
// ...

const keystrokeHandler = new KeystrokeHandler();
```

To define the scope of the keystroke handler in the DOM, use the [`listenTo()`](../../api/module_utils_keystrokehandler-KeystrokeHandler.html#function-listenTo) method:

```js
keystrokeHandler.listenTo( document.querySelector( '.some-element' ) );
keystrokeHandler.listenTo( viewInstance.element );
```

> **Note**
>
> Check out the list of [known key names](../../api/module_utils_keyboard.html#constant-keyCodes) supported by the keystroke handler.

Keystroke action callbacks are functions. To prevent the default action of the keystroke and stop further propagation, use the `cancel()` function provided in the callback.

```js
keystrokeHandler.set( 'Tab', ( keyEvtData, cancel ) => {
    console.log( 'Tab was pressed!' );

// This keystroke has been handled and can be canceled.
    cancel();
} );
```

> **Note**
>
> There is also an [`EditingKeystrokeHandler`](../../api/module_core_editingkeystrokehandler-EditingKeystrokeHandler.html) class which has the same API as `KeystrokeHandler` but it offers direct keystroke bindings to editor commands.
>
> The editor provides such a keystroke handler under the [`editor.keystrokes`](../../api/module_core_editor_editor-Editor.html#member-keystrokes) property so any plugin can register keystrokes associated with editor commands. For example, the [`Undo`](../../api/module_undo_undo-Undo.html) plugin registers `editor.keystrokes.set( 'Ctrl+Z', 'undo' );` to execute its `undo` command.

When you assign multiple callbacks to the same keystroke, you can use priorities to decide which one to handle first and whether to execute other callbacks at all:

```js
keystrokeHandler.set( 'Ctrl+A', ( keyEvtData ) => {
    console.log( 'A normal priority listener.' );
} );

keystrokeHandler.set( 'Ctrl+A', ( keyEvtData ) => {
    console.log( 'A high priority listener.' );

// The normal priority listener will not be executed.
    cancel();
}, { priority: 'high' } );
```

Pressing `Ctrl`+`A` will log:

```
"A high priority listener."
```

> **Note**
>
> Check out the [event system deep dive guide](#ckeditor5/latest/framework/deep-dive/event-system.html--listener-priorities) to learn more about event listener priorities.

<a id="ckeditor5/latest/framework/contributing/changelog-entries.html">source file: "ckeditor5/latest/framework/contributing/changelog-entries.html"</a>

## Changelog entries

CKEditor 5 uses Markdown file-based changelog system inspired by tools like Changesets. Contributions are noted in a human-readable Markdown files stored in the repository. These files describe the nature of the change (bug fix, feature, breaking change, etc.) and are committed alongside the actual code. These entries will be automatically compiled into the final changelog during the release process.

### How to create a new file

Create a new Markdown file in the `.changelog/` directory to add a changelog entry. Each file **must** describe **one change only**. You can create as many files as you need to explain the changes.

> **Note**
>
> The easiest and preferred way to create a changelog entry is by running:
>
> ```bash
> pnpm run nice
> ```
>
> `nice` stands for **N**ew **I**ndividual **C**hangelog **E**ntry.

This command creates a new Markdown file with a file name based on the current date and Git branch name: `YYYYMMDDHHMMSS_{branch-name}.md`. The branch name is automatically slugified (only letters, numbers, `-`, and `_` are allowed).

_Example: `20250617103000_fix-toolbar-alignment.md`_

The file will include a predefined frontmatter template. **You must manually fill in the details** (like `type`, `scope`, `closes`, and the summary of your change).

### Format of a changelog entry

Each changelog entry is a Markdown file with a frontmatter section followed by a summary and optional context. Here is a breakdown of all available fields:

| Field              | Required? | Description                                                                                                                |
| ------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
| `type`             | ✅ Yes     | Type of the change. See the allowed values and their impact in the table below.                                            |
| `scope`            | ❌ No      | Affected package(s), using short names like `ckeditor5-core`.                                                              |
| `closes`           | ❌ No      | List of issues this change resolves. Use numbers (`123`), full references (`ckeditor/ckeditor5#123`), or full URLs.        |
| `see`              | ❌ No      | Related issues that provide context but are not directly resolved by this change. Same format as `closes`.                 |
| `communityCredits` | ❌ No      | GitHub usernames of external contributors who should be credited for this change.                                          |
| _(body)_           | ✅ Yes     | After the frontmatter, add a short and meaningful summary of the change. Optionally include extended context or rationale. |

> **Note**
>
> **Tip**: Keep the summary clear and user-facing – this is what will appear in the final changelog.

The changelog entry format is designed to be both human-friendly and machine-readable. It uses a simple frontmatter structure followed by a short description of the change. Each field in the frontmatter serves a specific purpose, from determining the entry’s visibility to linking it with related issues or acknowledging community contributions.

Using these fields correctly ensures that the changelog remains accurate, meaningful, and consistent across releases. The sections below explain the available fields in more detail and provide guidance on when and how to use them.

#### Allowed values for the `type` field

| Type                  | Release | Description                                                                                                                                              |
| --------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Feature               | `minor` | A new feature. Introduces user-facing functionality.                                                                                                     |
| Fix                   | `patch` | A bug fix. Use also for small improvements that do not qualify as new features.                                                                          |
| Other                 | `patch` | Enhancement or refactor. It is not a fix or feature. Example: public API cleanup.                                                                        |
| Major breaking change | `major` | A change in the integration layer or the plugin development API. See [versioning policy](#ckeditor5/latest/updating/versioning-policy.html) for details. |
| Minor breaking change | `minor` | Low-level customizable API layer. See [versioning policy](#ckeditor5/latest/updating/versioning-policy.html) for details.                                |

#### Package name (`scope`)

Changes affect one or more packages. List the package that was most impacted by the change first.

However, it is possible to skip this part if many packages are affected. This usually indicates a generic change. In this case, having all the packages listed would reduce the readability of the changelog.

The package name is based on the npm package name, but the `@ckeditor/` prefix is stripped.

If your change is related to the main package, use `ckeditor5` as the package name.

> **Note**
>
> If the commit introduces a breaking change across the entire project (a generic change), you do not need to specify the package name.

#### Referencing issues

When creating PRs that address specific issues, use the following messages to indicate them.

* `Closes` – When the PR resolves an issue.
* `See` – When the PR references an issue but has not resolved it yet.

Both fields (`closes` and `see`) can contain multiple references, but they must follow the same format:

* `14724` – A simple issue number.
* `ckeditor/ckeditor5#14724` – A full reference to an issue in the CKEditor 5 repository.
* `https://github.com/ckeditor/ckeditor5/issues/14724` – A full URL to an issue in the CKEditor 5 repository.

#### Giving credit

When closing a PR submitted by a non-core contributor, add information about the contributor to the changelog entry file using the `communityCredits` field. It should contain a list of GitHub usernames of contributors who should be credited for this change.

#### Description

Write a concise and meaningful summary of the change. This main message will appear in the public changelog, so keep it clear, user-facing, and relevant.

Use the `ClassName#methodName()` format when referencing methods. This ensures consistency across all entries.

**Example:**

```
MarkerCollection#has()
```

You may include multiple sentences if additional context is helpful.

#### Examples of correct entry formatting

> **Note**
>
> Unlike the previous Git-based system, which captured all commit types, including internal changes, the new file-based changelog focuses exclusively on public, user-facing changes, ensuring the final changelog remains clear and relevant to end users.

A new feature without any breaking changes.

```md
---
type: Feature
scope:
  - ckeditor5-ui
closes:
  - 1
---

Added support for RTL languages.

RTL content will now be rendered correctly.
```

A generic bug fix for an existing feature that affects many packages (closes two tickets):

```md
---
type: Fix
closes:
  - 2
  - 3
---

The editor will be great again.
```

An improvement that is not backward compatible and sent by a non-core contributor. Public API was changed:

```md
---
type: Other
scope:
  - ckeditor5-utils
closes:
  - 9
---

Extracted the `utils#foo()` to a separate package.
```

```md
---
type: Feature
scope:
  - ckeditor5-engine
closes:
  - 9
---

Introduced the `engine#foo()` method.
```

```md
---
type: Major breaking change
scope:
  - ckeditor5-utils
see:
  - 9
---

The `utils#foo()` method was moved to the `engine` package.
```

For the entries shown above, the changelog will look like this:

```md
Changelog
=========

## [51.0.0](https://github.com/ckeditor/ckeditor5/compare/v50.1.1...v51.0.0) (June 17, 2025)

### MAJOR BREAKING CHANGES [ℹ️](https://ckeditor.com/docs/ckeditor5/latest/framework/guides/support/versioning-policy.html#major-and-minor-breaking-changes)

* **[utils](https://www.npmjs.com/package/@ckeditor/ckeditor5-utils)**: The `utils#foo()` method was moved to the `engine` package. See [#9](https://github.com/ckeditor/ckeditor5/issues/9).

### Features

* **[engine](https://www.npmjs.com/package/@ckeditor/ckeditor5-engine)**: Introduced the `engine#foo()` method. Closes [#9](https://github.com/ckeditor/ckeditor5/issues/9).
* **[ui](https://www.npmjs.com/package/@ckeditor/ckeditor5-ui)**: Added support for RTL languages. Closes [#1](https://github.com/ckeditor/ckeditor5/issues/1).

RTL content will now be rendered correctly.

### Bug fixes

* The editor will be great again. Closes [#2](https://github.com/ckeditor/ckeditor5/issues/2), [#3](https://github.com/ckeditor/ckeditor5/issues/3).

### Other changes

* **[utils](https://www.npmjs.com/package/@ckeditor/ckeditor5-utils)**: Extracted the `utils#foo()` to a separate package. Closes [#9](https://github.com/ckeditor/ckeditor5/issues/9).
```

#### Fixing errors

If the entry message is wrong, you can fix it by editing the Markdown file in the `.changelog/` directory and preparing a new pull request.

### Handling pull requests

When creating a pull request, you may propose a changelog entry (as recommended in the pull request template).

The reviewer must validate the proposed message and apply necessary changes. It can be done using the GitHub interface (as suggestions).

As a reviewer, make sure to check the following aspects of the proposed changelog entry and add or correct them if needed:

* The language and grammar of the message
* The type of the change
* Mentioned issue(s) number
* Breaking changes
* Any additional relevant information

You must be aware that the message will end up in the changelog and must be understandable in the broad context of the entire editor. It is not for you – it is for other developers.

When closing a PR, you do not have to copy anything. Pick your merge strategy (for example, “Squash and merge”), and GitHub will handle the rest.

<a id="ckeditor5/latest/framework/contributing/code-style.html">source file: "ckeditor5/latest/framework/contributing/code-style.html"</a>

## Code style

[CKEditor 5 development environment](#ckeditor5/latest/framework/contributing/development-environment.html) has ESLint enabled on CI. This means that code style issues are detected automatically. Additionally, `.editorconfig` files are present in every repository to automatically adjust your IDE settings (if it is configured to read them).

Here is a quick summary of these rules.

### General

**LF for line endings**. Never use CRLF.

The recommended maximum **line length is 120 characters**. It cannot exceed 140 characters.

### Whitespace

**No trailing spaces**. Empty lines should not contain any spaces.

Whitespace **inside parenthesis** and **before and after operators**:

```js
function foo( a, b, c, d, e ) {
    if ( a > b ) {
        c = ( d + e ) * 2;
    }
}

foo( bar() );
```

No whitespace for an **empty parenthesis**:

```js
const a = () => {
    // Statements.
    // ...
};

a();
```

No whitespace **before colon and semicolon**:

```js
let a, b;

a( 1, 2, 3 );

for ( const i = 0; i < 100; i++ ) {
    // Statements.
    // ...
}
```

### Indentation

Indentation with **tab**, for both code and comments. Never use spaces.

If you want to have the code readable, set the **tab** to **4 spaces** in your IDE.

```js
class Bar {
    a() {
        while ( b in a ) {
            if ( b == c ) {
                // Statements.
                // ...
            }
        }
    }
}
```

**Multiple lines condition**. Use **one tab** for each line:

```js
if (
    some != really.complex &&
    condition || with &&
    ( multiple == lines )
) {
    // Statements.
    // ...
}

while (
    some != really.complex &&
    condition || with &&
    ( multiple == lines )
) {
    // Statements.
    // ...
}
```

> **Note**
>
> We do our best to avoid complex conditions. As a rule of thumb, we first recommend finding a way to move the complexity out of the condition, for example, to a separate function with early returns for each “sentence” in such a condition.
>
> However, overdoing things is not good as well and sometimes such a condition can be perfectly readable (which is the ultimate goal here).

### Braces

Braces **start at the same line** as the head statement and end aligned with it:

```js
function a() {
    // Statements.
    // ...
}

if ( a ) {
    // Statements.
    // ...
} else if ( b ) {
    // Statements.
    // ...
} else {
    // Statements.
    // ...
}

try {
    // Statements.
    // ...
} catch ( e ) {
    // Statements.
    // ...
}
```

### Blank lines

The code should read like a book, so put blank lines between “paragraphs” of code. This is an open and contextual rule, but some recommendations would be to separate the following sections:

* variable, class and function declarations,
* `if()`, `for()` and similar blocks,
* steps of an algorithm,
* `return` statements,
* comment sections (comments should be preceded with a blank line, but if they are the “paragraph” themselves, they should also be followed with one),
* etc.

Example:

```js
class Foo extends Plugin {
    constructor( editor ) {
        super( editor );

/**
        * Some documentation...
        */
        this.foo = new Foo();

/**
        * Some documentation...
        */
        this.isBar = false;
    }

method( bar ) {
        const editor = this.editor;
        const selection = editor.model.document.selection;

for ( const range of selection.getRanges() ) {
            const position = range.start;

if ( !position ) {
                return false;
            }

// At this stage this and this need to happen.
            // We considered doing this differently, but it has its shortcomings.
            // Refer to the tests and issue #3456 to learn more.

const result = editor.model.checkSomething( position );

if ( result ) {
                return true;
            }
        }

return true;
    }

performAlgorithm() {
        // 1. Do things A and B.
        this.a();
        this.b();

// 2. Check C.
        if ( c() ) {
            d();
        }

// 3. Check whether we are fine.
        const areWeFine = 1 || 2 || 3;

this.check( areWeFine );

// 4. Finalize.
        this.finalize( areWeFine );

return areWeFine;
    }
}
```

### Multi-line statements and calls

Whenever there is a multi-line function call:

* Put the first parameter in a new line.
* Put every parameter in a separate line indented by one tab.
* Put the last closing parenthesis in a new line, at the same indentation level as the beginning of the call.

Examples:

```js
const myObj = new MyClass(
    'Some long parameters',
    'To make this',
    'Multi line'
);

fooBar(
    () => {
        // Statements.
        // ...
    }
);

fooBar(
    new MyClass(
        'Some long parameters',
        'To make this',
        'Multi line'
    )
);

fooBar(
    'A very long string',
    () => {
        // Some kind of a callback.
        // ...
    },
    5,
    new MyClass(
        'It looks well',
        paramA,
        paramB,
        new ShortClass( 2, 3, 5 ),
        'Even when nested'
    )
);
```

> **Note**
>
> These examples are just showcasing how to structure such function calls. However, it is best to avoid them.
>
> It is generally recommended to avoid having functions that accept more than 3 arguments. Instead, it is better to wrap them in an object so all parameters can be named.
>
> It is also recommended to split such long statements into multiple shorter ones, for example, by extracting some longer parameters to separate variables.

### Strings

Use **single quotes**:

```js
const a = 'I\'m an example for quotes';
```

Long strings can be **concatenated with plus** (`+`):

```js
const html =
    'Line 1\n' +
    'Line 2\n' +
    'Line 3';
```

or you can use template strings. The second and third line will be indented in this case:

```js
const html =
    `Line 1
    Line 2
    Line 3`;
```

Strings of HTML should use indentation for readability:

```js
const html =
    `<p>
        <span>${ a }</span>
    </p>`;
```

### Comments

* Comments are always **preceded by a blank line**.
* Comments start with a **capital first letter** and require a period at the end (since they are sentences).
* There must be a **single space at the start** of the text, right after the comment token.

**Block comments** (`/** ... */`) are used for **documentation only**. Asterisks are aligned with space:

```js
/**
 * Documentation for the following method.
 *
 * @returns {Object} Something.
 */
someMethod() {
    // Statements.
    // ...
}
```

All **other comments** use **line comments** (`//`):

```js
// A comment about the following statement.
foo();

// Multiple line comments
// go through several
// line comments as well.
```

**Comments related to tickets or issues** should not describe the whole issue fully. A short description should be used instead, together with the ticket number in parenthesis:

```js
// Do this otherwise because of a Safari bug. (#123)
foo();
```

### Linting

CKEditor 5 development environment uses [ESLint](https://eslint.org), including its [native CSS linting support](https://eslint.org/blog/2025/02/eslint-css-support/).

A couple of useful links:

* [Disabling ESLint with inline comments](https://eslint.org/docs/latest/use/configure/).
* [CKEditor 5 ESLint preset](https://github.com/ckeditor/ckeditor5-linters-config/blob/master/packages/eslint-config-ckeditor5/eslint.config.mjs) (npm: [`eslint-config-ckeditor5`](https://www.npmjs.com/package/eslint-config-ckeditor5)).

> **Note**
>
> Avoid using automatic code formatters on existing code. It is fine to automatically format code that you are editing, but you should not be changing the formatting of the code that is already written to not pollute your PRs. You should also not rely solely on automatic corrections.

### Visibility levels

Each class property (including methods, symbols, getters, or setters) can be public, protected, or private. The default visibility is public, so you should not document that a property is public – there is no need to do this.

Additional rules apply to private properties:

* The names of private and protected properties that are exposed in a class prototype (or in any other way) should be prefixed with an underscore.
* When documenting a private variable that is not added to a class prototype (or exposed in any other way), `//` comments should be used and using `@private` is not necessary.
* A symbol property (like `this[ Symbol( 'symbolName' ) ]`) should be documented as `@property {Type} _symbolName`.

Example:

```js
class Foo {
    /**
    * The constructor (public, as its visibility isn't defined).
    */
    constructor() {
        /**
        * Public property.
        */
        this.foo = 1;

/**
        * Protected property.
        *
        * @protected
        */
        this._bar = 1;

/**
        * @private
        * @property {Number} _bom
        */
        this[ Symbol( 'bom' ) ] = 1;
    }

/**
    * @private
    */
    _somePrivateMethod() {}
}

// Some private helper.
//
// @returns {Number}
function doSomething() {
    return 1;
}
```

#### Accessibility

The table below shows the accessibility of properties:

|              | Class | Package | Subclass | World |
| ------------ | ----- | ------- | -------- | ----- |
| `@public`    | yes   | yes     | yes      | yes   |
| `@protected` | yes   | yes     | yes      | no    |
| `@private`   | yes   | no      | no       | no    |

(yes – accessible, no – not accessible)

For instance, a protected property is accessible from its own class in which it was defined, from its whole package, and from its subclasses (even if they are not in the same package).

> **Note**
>
> Protected properties and methods are often used for testability. Since tests are located in the same package as the code, they can access these properties.

### Getters

You can use ES6 getters to simplify class API:

```js
class Position {
    // More methods.
    // ...

get offset() {
        return this.path[ this.path.length - 1 ];
    }
}
```

A getter should feel like a natural property. There are several recommendations to follow when creating getters:

* They should be fast.
* They should not throw.
* They should not change the object state.
* They should not return new instances of an object every time (so `foo.bar == foo.bar` is true). It is OK to create a new instance for the first call and cache it if it is possible.

### Order within class definition

Within the class definition, order the methods and properties as follows:

1. Constructor.
2. Getters and setters.
3. Iterators.
4. Public instance methods.
5. Public static methods.
6. Protected instance methods.
7. Protected static methods.
8. Private instance methods.
9. Private static methods.

The order within each group is left for the implementer.

### Tests

There are some special rules and tips for tests.

#### Test organization

* Always use an outer `describe()` in a test file. Do not allow any globals, especially hooks (`beforeEach()`, `afterEach()`, etc.) outside the outermost `describe()`.

* The outermost `describe()` calls should create meaningful groups, so when all tests are run together a failing TC can be identified within the code base. For example:

```js
  describe( 'Editor', () => {
      describe( 'constructor()', () => {
          it( /* ... */ );
      } );

// More test cases.
      // ...
  } );
  ```

Using titles like `utils` is not fine as there are multiple utilities in the entire project. `Table utils` would be better.

* Test descriptions (`it()`) should be written like documentation (what you do and what should happen), for example, _“the foo dialog closes when the X button is clicked”_. Also, _“…case 1”_, _“…case 2”_ in test descriptions are not helpful.

* Avoid test descriptions like _“does not crash when two ranges get merged.”_ Instead, explain what is actually expected to happen. For instance: _“leaves 1 range when two ranges get merged.”_

* Most often, using words like “correctly,” “works fine” is a code smell. Think about the requirements – when writing them you do not say that feature X should “work fine.” You document how it should work.

* Ideally, it should be possible to recreate an algorithm just by reading the test descriptions.

* Avoid covering multiple cases under one `it()`. It is OK to have multiple assertions in one test, but not to test, for example, how method `foo()` works when it is called with 1, then with 2, then 3, etc. There should be a separate test for each case.

* Every test should clean up after itself, including destroying all editors and removing all elements that have been added.

#### Test implementation

Tests run on [Vitest](https://vitest.dev/). See the [Testing environment](#ckeditor5/latest/framework/contributing/testing-environment.html) guide to learn how to execute them.

* Import every test API you use explicitly from `vitest`. Test globals are not enabled:

```js
  import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
  ```

* Avoid using real timeouts. Use [fake timers](https://vitest.dev/api/vi.html#fake-timers) instead **when possible**. Timeouts make tests really slow.

Fake timers are not restored automatically, so switch back to the real ones in the cleanup hook:

```js
  beforeEach( () => {
      vi.useFakeTimers();
  } );

afterEach( () => {
      vi.useRealTimers();
  } );

it( 'calls the callback after 100 ms', () => {
      const callbackSpy = vi.fn().mockName( 'callback' );

scheduleCallback( callbackSpy );
      vi.advanceTimersByTime( 100 );

expect( callbackSpy ).toHaveBeenCalledOnce();
  } );
  ```

* However, do not over-optimize (especially since performance is not a priority in tests). In most cases, it is completely fine (and hence recommended) to create a separate editor for every `it()`.

* We aim at having 100% coverage of _all distinctive scenarios_. Covering 100% branches in the code is not the goal here – it is a by-product of covering real scenarios.

Think about this: when you fix a bug by adding a parameter to an existing function call, you do not affect code coverage (that line was called anyway). However, you had a bug, meaning that your test suite did not cover it. Therefore, a test must be created for that code change.

* Assert with the [Vitest `expect()` matchers](https://vitest.dev/api/expect.html). Use `toBe()` to compare primitives and object references, and `toEqual()` to compare structures by value:

```js
  expect( editor.getData() ).toBe( '<p>foo</p>' );
  expect( command.value ).toEqual( { type: 'bulleted' } );
  ```

Vitest still exposes the Chai-style chained assertions used before the migration, but do not write new ones. It should be `expect( x ).toBe( y )`. **NOT**: ~~`expect( x ).to.equal( y )`~~.

* The testing environment also registers a few [custom matchers](#ckeditor5/latest/framework/contributing/testing-environment.html--custom-vitest-matchers), such as `toEqualMarkup()`. Prefer them over plain string comparisons when asserting markup, as they produce far more readable diffs.

* When using spies, pay attention to the readability of assertions and failure messages.

* [`vi.spyOn()`](https://vitest.dev/api/vi.html#vi-spyon) names the spy after the method it replaces, but a bare [`vi.fn()`](https://vitest.dev/api/vi.html#vi-fn) does not. Name standalone spies with `mockName()`:

```js
    const myMethodSpy = vi.spyOn( obj, 'myMethod' );
    const someCallbackSpy = vi.fn().mockName( 'someCallback' );
    ```

* The name is then used in the failure message:

```js
    expect( myMethodSpy ).toHaveBeenCalledOnce();
    // expected "myMethod" to be called once, but got 2 times
    ```

* Do not clean up spies and stubs by hand. The shared Vitest configuration enables [`restoreMocks`](https://vitest.dev/config/restoremocks), [`unstubGlobals`](https://vitest.dev/config/unstubglobals), and [`unstubEnvs`](https://vitest.dev/config/unstubenvs), so every `vi.spyOn()`, `vi.fn()`, `vi.stubGlobal()`, and `vi.stubEnv()` is restored before each test. Therefore:

* Do not call `vi.restoreAllMocks()`, `vi.unstubAllGlobals()`, or `vi.unstubAllEnvs()` in cleanup hooks. The only reason to restore something manually is when a mock set up in `beforeEach()` must be dropped for a single test, or when the teardown itself (`editor.destroy()`, for example) has to run against the real implementation.
  * Create stubs in `beforeEach()` or in the test itself, never in `beforeAll()`. A stub created in `beforeAll()` would be silently removed before the second test of the suite runs.

### Naming

#### JavaScript code names

Variables, functions, namespaces, parameters and all undocumented cases must be named in [lowerCamelCase](https://en.wikipedia.org/wiki/CamelCase):

```js
let a;
let myLongNamedVariable = true;

function foo() {}

function longNamedFunction( example, longNamedParameter ) {}
```

Classes must be named in [UpperCamelCase](https://en.wikipedia.org/wiki/CamelCase):

```js
class MyClass() {}

const a = new MyClass();
```

Mixins must be named in [UpperCamelCase](https://en.wikipedia.org/wiki/CamelCase), post-fixed with “Mixin”:

```js
const SomeMixin = {
    method1: /* ... */,
    method2: /* ... */
};
```

Global namespacing variables must be named in [ALLCAPS](https://en.wikipedia.org/wiki/All_caps):

```js
const CKEDITOR_TRANSLATIONS = {};
```

##### Private properties and methods

Private properties and methods are **prefixed with an underscore**:

```js
CKEDITOR._counter;
something._doInternalTask();
```

##### Methods and functions

Methods and functions are **almost always** verbs or actions:

```js
// Good
execute();
this.getNextNumber()

// Bad
this.editable();
this.status();
```

##### Properties and variables

Properties and variables are **almost always** nouns:

```js
const editor = this.editor;
this.name;
this.editable;
```

**Boolean properties and variables** are **always** prefixed by an auxiliary verb:

```js
this.isDirty;
this.hasChildren;
this.canObserve;
this.mustRefresh;
```

#### Buttons, Commands and Plugins

##### Buttons

All buttons should follow the **verb + noun** or the **noun** convention. Examples:

* The **verb + noun** convention:

* `insertTable`
  * `selectAll`
  * `uploadImage`

* The **noun** convention:

* `bold`
  * `mediaEmbed`
  * `restrictedEditing`

##### Commands

As for commands, it is trickier. There are more combinations of their names possible than there are for buttons. Examples:

* The **feature-related** convention:

* **noun-based** case:

* `codeBlock`
    * `fontColor`
    * `shiftEnter`

* **verb-based** case:

* `indent`
    * `removeFormat`
    * `selectAll`

* The **feature + sub-feature** convention:

* `imageStyle`
  * `imageTextAlternative`
  * `tableAlignment`

For commands, the **noun + verb** (or the **feature + action**) naming conventions **should not be used**, because it does not sound natural (_what do_ vs. _do what_). In most cases the proper name should start with the **action** followed by the **feature** name:

* `checkTodoList`
* `insertTable`
* `uploadImage`

##### Plugins

Plugins should follow the **feature** or the **feature + sub-feature** convention. Examples:

* The **feature** convention:

* `Bold`
  * `Paragraph`
  * `SpecialCharacters`

* The **feature + sub-feature** convention:

* `ImageResize`
  * `ListProperties`
  * `TableClipboard`

Plugins must be named in [UpperCamelCase](https://en.wikipedia.org/wiki/CamelCase).

#### Shortcuts

For local variables **commonly accepted short versions** for long names are fine:

```js
const attr, doc, el, fn, deps, err, id, args, uid, evt, env;
```

The following are **the only short versions accepted for property names**:

```js
this.lang;
this.config;
this.id;
this.env;
```

#### Acronyms and proper names

Acronyms and, partially, proper names are naturally written in uppercase. This may stand against code style rules described above – especially when there is a need to include an acronym or a proper name in a variable or class name. In such case, one should follow these rules:

* Acronyms:

* All lowercase if at the beginning of the variable name: `let domError`.
  * Default camel case at the beginning of the class name: `class DomError`.
  * Default camel case inside the variable or class name: `function getDomError()`.

* Proper names:

* All lowercase if at the beginning of the variable: `let ckeditorError`.
  * Original case if at the beginning of the class name: `class CKEditorError`.
  * Original case inside the variable or class name: `function getCKEditorError()`.

However, two-letter acronyms and proper names (if originally written uppercase) should be uppercase. For example: `getUI`, not `getUi`.

> **Note**
>
> Two most frequently used acronyms which cause problems:
>
> * **DOM** – It should be e.g. `getDomNode()`,
> * **HTML** – It should be e.g. `toHtml()`.

#### CSS classes

CSS class naming pattern is based on [BEM](https://en.bem.info/) methodology and code style. All names are in lowercase with an optional dash (`-`) between the words.

Top–level building **blocks** begin with a mandatory `ck-` prefix:

```css
.ck-dialog
.ck-toolbar
.ck-dropdown-menu
```

**Elements** belonging to the block namespace are delimited by double underscore (`__`):

```css
.ck-dialog__header
.ck-toolbar__group
.ck-dropdown-menu__button-collapser
```

**Modifiers** are delimited by a single underscore (`_`). Key-value modifiers\
follow the `block-or-element_key_value` naming pattern:

```css
/* Block modifier */
.ck-dialog_hidden
/* Element modifier */
.ck-toolbar__group_collapsed
/* Block modifier as key_value  */
.ck-dropdown-menu_theme_some-theme
```

In HTML:

```html
<div class="ck-reset_all ck-dialog ck-dialog_theme_lark ck-dialog_visible">
    <div class="ck-dialog__top ck-dialog__top_small">
        <h1 class="ck-dialog__top-title">Title of the dialog</h1>
        ...
    </div>
    ...
</div>
```

#### ID attributes

HTML ID attribute naming pattern follows [CSS classes](#ckeditor5/latest/framework/contributing/code-style.html--css-classes) naming guidelines. Each ID must begin with the `ck-` prefix and consist of dash–separated (`-`) words in lowercase:

```html
<div id="ck">...</div>
<div id="ck-unique-div">...</div>
<div id="ck-a-very-long-unique-identifier">...</div>
```

#### File names

File and directory names must follow a standard that makes their syntax easy to predict:

* All lowercase.

* Only alphanumeric characters are accepted.

* Words are separated by dashes (`-`) ([kebab-case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles)).

* Code entities are considered single words, so the `DataProcessor` class is defined in the `dataprocessor.js` file.
  * However, a test file covering for “mutations in multi-root editors”: `mutations-in-multi-root-editors.js`.

* HTML files have the `.html` extension.

##### Examples

* `ckeditor.js`
* `tools.js`
* `editor.js`
* `dataprocessor.js`
* `build-all.js` and `build-min.js`
* `test-core-style-system.html`

##### Standard files

Widely used standard files do not obey the above rules:

* `README.md`, `LICENSE.md`, `CONTRIBUTING.md`, `CHANGES.md`
* `.gitignore` and all standard “dot-files”
* `node_modules`

### CKEditor 5 custom ESLint rules

In addition to the rules provided by ESLint, CKEditor 5 uses a few custom rules described below.

#### Importing between packages: `ckeditor5-rules/no-relative-imports`

While importing modules from the same package, it is allowed to use relative paths, like this:

```js
// Assume we edit a file located in the path: `packages/ckeditor5-engine/src/model/model.js`

import Position from './position';
import insertContent from './utils/insertcontent';
```

While importing modules from other packages, it is not allowed to use relative paths, and the import must be done using the package name, like this:

👎 Examples of incorrect code for this rule:

```js
// Assume we edit a file located in the path: `packages/ckeditor5-engine/src/model/model.js`

import CKEditorError from '../../../ckeditor5-utils/src/ckeditorerror';
```

Even if the import statement works locally, it will throw an error when developers install packages from npm.

👍 Examples of correct code for this rule:

```js
// Assume we edit a file located in the path: `packages/ckeditor5-engine/src/model/model.js`

import { CKEditorError } from 'ckeditor5';
```

[History of the change.](https://github.com/ckeditor/ckeditor5/issues/7128)

#### Description of an error: `ckeditor5-rules/ckeditor-error-message`

Each time a new error is created, it needs a description to be displayed on the [error codes](#ckeditor5/latest/support/error-codes.html) page, like this:

👎 Examples of incorrect code for this rule:

```js
// Missing the error's description.

throw new CKEditorError( 'ckeditor5-example-error', this );

// ESLint shouldn't expect the definition of the error as it is already described.

throw new CKEditorError( 'editor-wrong-element', this );
```

👍 Examples of correct code for this rule:

```js
// This error occurs for the first time in the project, so it needs to be defined.

/**
 * Description of why the error was thrown and how to fix the code.
 *
 * @error ckeditor5-example-error
 */
throw new CKEditorError( 'ckeditor5-example-error', this );

// This error is already described, so we don't need to provide its documentation.
// We need to disable ESLint for checking the rule.
// It is a good practice to include a note that explains where it is described.

// Documented in core/editor/editor.js
// eslint-disable-next-line ckeditor5-rules/ckeditor-error-message
throw new CKEditorError( 'editor-wrong-element', this );
```

[History of the change.](https://github.com/ckeditor/ckeditor5/issues/7822)

#### Cross package imports: `ckeditor5-rules/no-cross-package-imports`

It is allowed to import modules from other packages:

```js
import { toArray } from '@ckeditor/ckeditor5-utils';
```

However, some packages cannot import modules from CKEditor 5 as it could lead to code duplication and errors in runtime. Hence, the rule disables this kind of import.

Currently, it applies to the `@ckeditor/ckeditor5-watchdog` package.

👎 Examples of incorrect code for this rule:

```js
// Assume we edit a file located in the `packages/ckeditor5-watchdog/` directory.

import { toArray } from '@ckeditor/ckeditor5-utils';
import { toArray } from 'ckeditor5';
```

[History of the change.](https://github.com/ckeditor/ckeditor5/issues/9318)

#### Non-public members marked as @internal : `ckeditor5-rules/non-public-members-as-internal`

> **Warning**
>
> This rule should only be used on `.ts` files.

To remove non-public members from type definitions, use the `@internal` tag in the member’s JSDoc.

Then you can use the `"stripInternal": true` option in `tsconfig.json` to remove them from declaration types.

👎 Examples of incorrect code for this rule:

```ts
class ClassWithSecrets {
    private _shouldNotBeEmitted: string;
}
```

👍 Examples of correct code for this rule:

```ts
class ClassWithSecrets {
    /**
    * @internal
    */
    private _shouldNotBeEmitted: string;
}
```

#### Declaring module augmentation for the core package: `ckeditor5-rules/allow-declare-module-only-in-augmentation-file`

> **Warning**
>
> This rule should only be used on `.ts` files.

The main entry points (`index.ts` files) in most modules have a side effect import `import './augmentation'` which uses module augmentation to populate the editor types with information about available plugins, configurations and commands.

This rule forces all `declare module '@ckeditor/ckeditor5-core'` to be defined in this `augmentation.ts` file.

#### Importing from modules: `ckeditor5-rules/allow-imports-only-from-main-package-entry-point`

This rule ensures that all imports from the `@ckeditor/*` packages are done through the main package entry points. This is required for the editor types to work properly and to ease migration to the installation methods introduced in CKEditor 5 v42.0.0.

👎 Example of incorrect code for this rule:

```ts
// Importing from the `/src/` folder is not allowed.
import Table from '@ckeditor/ckeditor5-table/src/table';

// Importing from the `/theme/` folder is not allowed.
import BoldIcon from '@ckeditor/ckeditor5-icons/theme/icons/bold.svg';
```

👍 Examples of correct code for this rule:

```ts
// ✔️ Importing from the main entry point is allowed.
import { Table } from 'ckeditor5';
```

#### Require `as const`: `ckeditor5-rules/require-as-const-returns-in-methods`

> **Warning**
>
> This rule should only be used on `.ts` files.

In TypeScript, the types inferred from some values are simplified. For example, the type of `const test = [1, 2, 3];` is `number[]`, but in some cases a more specific type may be needed. Using `as const` can help with this. For example, the type of `const test1 = [1, 2, 3] as const;` is `readonly [1, 2, 3]`.

The `require-as-const-returns-in-methods` rule requires some methods that depend on the exact type of returned data (for example, `'delete'` literal string instead of the generic `string` in the `pluginName` method) to have all return statements with `as const`.

👎 Examples of incorrect code for this rule:

```ts
export default class Delete extends Plugin {
    public static get pluginName(): string {
        return 'Delete';
    }
}
```

```ts
export default class Delete extends Plugin {
    public static get pluginName(): 'Delete' {
        return 'Delete';
    }
}
```

👍 Examples of correct code for this rule:

```ts
export default class Delete extends Plugin {
    public static get pluginName() {
        return 'Delete' as const;
    }
}
```

#### Disallow TypeScript enums: `ckeditor5-rules/no-enum`

> **Warning**
>
> This rule should only be used on `.ts` files.

TypeScript `enum` declarations are disallowed because they emit runtime code that is hard to tree-shake, behave inconsistently between numeric and string enums, and do not mix well with structural typing. Prefer a `const` object combined with a union type derived from its values, which produces a lighter and more predictable output.

👎 Examples of incorrect code for this rule:

```ts
enum Direction {
    Up = 'up',
    Down = 'down'
}
```

👍 Examples of correct code for this rule:

```ts
const Direction = {
    Up: 'up',
    Down: 'down'
} as const;

type Direction = typeof Direction[ keyof typeof Direction ];
```

#### Imports within a package: `ckeditor5-rules/no-scoped-imports-within-package`

All imports defined in every package, that point to a file from the same package, must be relative. You cannot use the scoped imports, if the target file is located in the same package as the import declaration. The resolved scoped import points to the package inside the `node_modules`, but not to the current working directory, and the source code in these two places may differ from each other.

👎 Examples of incorrect code for this rule:

```ts
// Assume we edit a file located in the path: `packages/ckeditor5-alignment/src/alignment.ts`.

// Both imports are incorrect.
import { AlignmentEditing } from '@ckeditor/ckeditor5-alignment';
import AlignmentEditing from '@ckeditor/ckeditor5-alignment/src/alignmentediting';
```

👍 Examples of correct code for this rule:

```ts
// Assume we edit a file located in the path: `packages/ckeditor5-alignment/src/alignment.ts`.

import AlignmentEditing from './alignmentediting';
```

[History of the change.](https://github.com/ckeditor/ckeditor5/issues/14329)

#### Mandatory file extensions in imports: `ckeditor5-rules/require-file-extensions-in-imports`

As required by the [ECMAScript (ESM)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) standard, all imports and re-exports must include a file extension. If they do not include it, this rule will try to automatically detect the correct file extension. It is impossible in these two cases:

* The file extension is different that `.ts`, `.js`, or `.json`.
* The file does not exist in the file system.

The second case is common for the documentation files, because its pieces are located in different directories and repositories. These pieces are merged during the build step, but before that, the imports are technically invalid.

In such cases, you must add the file extension manually. Imports with file extensions are not validated.

#### Valid `@module` tags: `ckeditor5-rules/validate-module-tag`

> **Warning**
>
> This rule should only be used on `.ts` files in package `src/` directories.

This rule requires a file-level `@module` JSDoc tag at the top of each TypeScript source file in `packages/*/src`. The tag value must match the file path.

For example, `packages/ckeditor5-feature/src/featureediting.ts` should start with `@module feature/featureediting`. For `index.ts` files, both `@module feature` and `@module feature/index` are allowed. The `augmentation.ts` file is excluded from this rule.

#### Require or disallow certain plugin flags: `ckeditor5-rules/ckeditor-plugin-flags`

> **Warning**
>
> This rule should only be used on `.ts` files.

This rule ensures that plugin flags are either correctly set or not set at all. It checks whether the flags have the correct type and value, preventing common mistakes and ensuring compliance with the CKEditor 5 plugin API.

Options:

* `requiredFlags` – (optional) An array of flags that must be set in the plugin.
* `disallowedFlags` – (optional) An array of flags that must not be set in the plugin.

The example configuration below requires the `isFooPlugin` flag to be set to `true` and disallows the `isBarPlugin` flag:

```json
{
    "requiredFlags": [
        {
            "name": "isFooPlugin",
            "returnValue": true
        }
    ],
    "disallowedFlags": [ "isBarPlugin" ]
}
```

👎 Examples of incorrect code for this rule:

```ts
export default class MyPlugin extends Plugin {
    static get pluginName() {
        return 'MyPlugin';
    }

public static override get isBarPlugin(): false {
        return false;
    }
}
```

The `isBarPlugin` flag is disallowed, and the plugin has it set to `false`. Additionally, the `isFooPlugin` flag is required but not defined.

👍 Examples of correct code for this rule:

```ts
export default class MyPlugin extends Plugin {
    static get pluginName() {
        return 'MyPlugin';
    }

public static override get isFooPlugin(): true {
        return true;
    }
}
```

The `isFooPlugin` flag is required and set to `true`, and the `isBarPlugin` flag is not defined.

#### SVG imports only in the `@ckeditor/ckeditor5-icons` package

This rule ensures that SVG files are imported and exported only in the `@ckeditor/ckeditor5-icons` package. This package should include all icons used in CKEditor 5.

#### CSS imports only in the main package entry point

This rule ensures that CSS files are imported only in the main package entry point (`src/index.ts`). Each package imports `theme/index-editor.css` followed by `theme/index-content.css`. Individual source modules must not import CSS files.

#### Valid changelog entries

This rule ensures that changelog entry files are populated with proper data and a clear description of the change. For a full guide on how to populate changelog entries, see the [Changelog entries](#ckeditor5/latest/framework/contributing/changelog-entries.html) guide.

#### Disallow hardcoded `$root` literals: `ckeditor5-rules/no-literal-dollar-root`

This rule disallows the literal `'$root'` string anywhere it could be used as a schema context. Hardcoding `'$root'` is silently wrong when [`config.root.modelElement`](../../api/module_core_editor_editorconfig-RootConfig.html#member-modelElement) is customized: the runtime root no longer matches the literal, and any schema check or upcast against it operates against the wrong element name. See the [Root types](#ckeditor5/latest/getting-started/setup/root-types.html) guide for an overview of the available root model element types.

The rule also reports two specific patterns that have a name-agnostic replacement and provides an auto-fix for them:

* `node.is( 'element', '$root' )` → `node.is( 'rootElement' )`
* `node.name === '$root'` / `node.name !== '$root'` → `node.is( 'rootElement' )` / `!node.is( 'rootElement' )`

Options:

* `allowedPackages` – (optional) A list of package name fragments whose source files are exempt from the rule. Used for `ckeditor5-engine` and `ckeditor5-core` where `'$root'` is the canonical schema element name being defined.
* `allowedCalls` – (optional) A list of method names where a `'$root'` literal argument is permitted (e.g. `is` so that `node.is( '$root' )` is allowed alongside the canonical `node.is( 'rootElement' )` form).

The rule also has a narrow built-in exception: a `'$root'` literal under a `context` property of an options object passed to a view-event listener method (`listenTo()`, `on()`, `once()`, `off()`) is not flagged, because in that position `'$root'` is a view-tree bubbling target — not the schema element name.

👎 Examples of incorrect code for this rule:

```ts
const ROOT_NAME = '$root';

if ( node.is( 'element', '$root' ) ) { /* ... */ }

if ( modelElement.name === '$root' ) { /* ... */ }

writer.addRoot( newRoot, '$root' );
```

👍 Examples of correct code for this rule:

```ts
if ( node.is( 'rootElement' ) ) { /* ... */ }

if ( modelElement.is( 'rootElement' ) ) { /* ... */ }

// View-event listener `context` option — `'$root'` here is a view-tree bubbling target.
this.listenTo( viewDocument, 'arrowKey', handler, { context: '$root' } );

// Adding attributes to the default root element is the documented escape hatch.
schema.extend( '$root', { allowAttributes: [ 'foo' ] } );
```

If the literal `'$root'` is the right value at a call site, opt out with an `// eslint-disable-next-line` comment that explains why. A common case is a feature that is intentionally scoped to roots whose `modelElement` is the default `$root` and is not meant to operate on roots configured with a custom `modelElement`. Such a feature may register its schema only against `$root` on purpose:

```ts
// eslint-disable-next-line ckeditor5-rules/no-literal-dollar-root -- feature is registered only on the default `$root` by design
model.schema.register( 'myFeatureElement', { isBlock: true, allowIn: '$root' } );
```

#### Require explicit schema context: `ckeditor5-rules/require-explicit-data-context`

This rule flags calls to engine APIs whose schema-context argument silently defaults to `'$root'` when omitted. Like the rule above, the silent default is wrong as soon as a root is configured with a custom [`modelElement`](../../api/module_core_editor_editorconfig-RootConfig.html#member-modelElement), and the failure is hard to diagnose because no error is raised.

The rule reports calls to these APIs when their context argument is missing:

* [`data.parse( data, context )`](../../api/module_engine_controller_datacontroller-DataController.html#function-parse)
* [`data.toModel( view, context )`](../../api/module_engine_controller_datacontroller-DataController.html#function-toModel)
* [`document.createRoot( elementName, rootName )`](../../api/module_engine_model_document-ModelDocument.html#function-createRoot)
* [`writer.addRoot( rootName, elementName )`](../../api/module_engine_model_writer-ModelWriter.html#function-addRoot)
* [`upcastDispatcher.convert( viewElementOrFragment, writer, context )`](../../api/module_engine_conversion_upcastdispatcher-UpcastDispatcher.html#function-convert)

The receiver patterns are matched syntactically (the receiver’s final accessed property must be `data` / `document` / `upcastDispatcher`, or a bare identifier `writer` for `addRoot`). This intentionally excludes `MultiRootEditor#addRoot( rootName, options? )`, which has a different signature and resolves the model element name from its options object.

👎 Examples of incorrect code for this rule:

```ts
const fragment = editor.data.parse( html );
const fragment = editor.data.toModel( view );

editor.model.document.createRoot();

editor.model.change( writer => {
    writer.addRoot( 'main' );
} );

editor.data.upcastDispatcher.convert( viewFragment, writer );
```

👍 Examples of correct code for this rule:

```ts
const fragment = editor.data.parse( html, '$documentFragment' );
const fragment = editor.data.toModel( view, editor.model.document.getRoot()! );

editor.model.document.createRoot( '$inlineRoot' );

editor.model.change( writer => {
    writer.addRoot( 'main', '$inlineRoot' );
} );

editor.data.upcastDispatcher.convert( viewFragment, writer, [ '$root' ] );
```

If the default `'$root'` context is intentional (for example, an internal editor whose only root always uses the default model element), opt out with an `// eslint-disable-next-line` comment that explains why.

### CKEditor 5 custom CSS ESLint rules

In addition to the rules provided by ESLint and its CSS plugin, CKEditor 5 uses a few custom CSS rules described below.

#### Names of CSS variables within `.ck-content`: `ckeditor5-rules/ck-content-variable-name`

This rule aims to enforce convention of all variables targeting styling of elements within the editor (`.ck-content`) using a common prefix (`--ck-content-*`)

👎 Example of incorrect code for this rule:

```css
.ck-content {
    width: var(--variable-name);
}
```

👍 Example of correct code for this rule:

```css
.ck-content {
    width: var(--ck-content-variable-name);
}
```

[History of the change.](https://github.com/ckeditor/ckeditor5/issues/18805)

#### Content stylesheet placement: `ckeditor5-rules/content-styles-in-index-content`

This rule requires content styles scoped with `.ck-content` to be placed in `theme/index-content.css`. Editor-only content hosts, such as `.ck-editor__editable.ck-content`, stay in editor stylesheets.

#### Editor stylesheet placement: `ckeditor5-rules/no-editor-styles-in-index-content`

This rule prevents editor UI and editing-view selectors from being placed in `theme/index-content.css`. The content entry point may also contain supporting custom properties, font definitions, and keyframes.

#### Selector specificity order: `ckeditor5-rules/no-descending-specificity`

This rule reports selectors with lower specificity placed after overriding selectors with higher specificity that target the same element. Such a selector cannot win the cascade where both selectors apply, so the resulting order is misleading to readers and fragile during refactoring. It reimplements Stylelint’s [`no-descending-specificity`](https://stylelint.io/user-guide/rules/no-descending-specificity/) rule for ESLint.

Selectors are compared only within the same context (the same nesting parent and at-rule conditions) and only when they share the same key selector, that is, the last compound selector ignoring pseudo-classes. For example, `a:hover` and `a` are compared with each other, while `a::before` is not compared with `a`.

👎 Example of incorrect code for this rule:

```css
.ck-toolbar a {
    color: var(--ck-color-link);
}

a {
    color: var(--ck-color-text);
}
```

👍 Example of correct code for this rule:

```css
a {
    color: var(--ck-color-text);
}

.ck-toolbar a {
    color: var(--ck-color-link);
}
```

#### Custom property references require `var()`: `ckeditor5-rules/no-missing-var-function`

This rule reports custom property references used as declaration values without the `var()` function. A bare reference is not substituted by the browser, so the declaration silently does not work. It reimplements Stylelint’s [`custom-property-no-missing-var-function`](https://stylelint.io/user-guide/rules/custom-property-no-missing-var-function/) rule for ESLint.

Properties whose values legitimately contain dashed identifiers are not checked. This covers transition targets (`transition`, `transition-property`, and `will-change`) and the naming properties of anchor positioning, scroll-driven animations, and view transitions (for example, `anchor-name` or `view-transition-name`).

👎 Example of incorrect code for this rule:

```css
.ck-button {
    color: --ck-color-text;
    --ck-button-color: --ck-color-text;
}
```

👍 Example of correct code for this rule:

```css
.ck-button {
    color: var(--ck-color-text);
    --ck-button-color: var(--ck-color-text);
}
```

<a id="ckeditor5/latest/framework/contributing/contributing.html">source file: "ckeditor5/latest/framework/contributing/contributing.html"</a>

## Contributing

CKEditor 5 is an Open Source project and we will be most thankful for your contributions. You can help us by fixing issues, reporting them, or translating the editor interface. Community effort and engagement is what has been driving the development of our WYSIWYG editor projects since 2003!

### Fixing issues and coding features

Before you start, here are some things to keep in mind:

* We expect contributions to follow the high-quality code standards that we follow, including [coding style](#ckeditor5/latest/framework/contributing/contributing.html--code-style) and [tests](#ckeditor5/latest/framework/contributing/contributing.html--tests). Lack of attention to this point may either make it slow to adopt a contribution or even force us to reject it altogether.
* There is no guarantee that your contribution will be incorporated into the project code. Still, pull requests make it easy for you to keep them for your own use or for others who may be interested in them.
* If you plan to start working on a bigger task, it might be worth asking the core team (beforehand) whether a specific feature or a solution to an issue will be accepted.
* If you need any assistance when creating a patch or implementing a feature, ping us under the ticket.
* [Having a CLA](#ckeditor5/latest/framework/contributing/contributing.html--contributor-license-agreement-cla) is essential to have your contributions accepted.

#### Setting up the development environment

To learn how to set up the project and run tests see the [development environment](#ckeditor5/latest/framework/contributing/development-environment.html) guide.

#### Code style

Read more in the [code style](#ckeditor5/latest/framework/contributing/code-style.html) guide, where you can also check the [naming](#ckeditor5/latest/framework/contributing/code-style.html--naming) and [file name](#ckeditor5/latest/framework/contributing/code-style.html--file-names) guidelines.

Every package repository installs Git hooks that automatically lint and check the code for code style on commit. However, not every code style issue can be discovered this way, so please do not rely on tools too much.

#### Tests

We maintain a **100% code coverage** (including code branches) and pull requests with missing tests will not be accepted. However, keep in mind that 100% is not everything – every _change_ must be tested. This means that if you are fixing a bug and your patch did not change the code coverage, the change itself needs a test anyway.

Besides automated tests, you may be asked to create a manual test for the issue. Such manual tests let us quickly validate that the issue was really fixed and are later used during the testing phase (before a release) to make sure no regressions were created.

Read more about our [testing environment](#ckeditor5/latest/framework/contributing/testing-environment.html).

#### Creating a pull request

> **Note**
>
> GitHub provides an [excellent documentation about pull requests](https://help.github.com/categories/collaborating-with-issues-and-pull-requests/). If you are not sure what to do, this is the right place to start.

> **Note**
>
> The [Angular](https://github.com/ckeditor/ckeditor5-angular), [React](https://github.com/ckeditor/ckeditor5-react) and [Vue](https://github.com/ckeditor/ckeditor5-vue) integrations as well as [CKEditor 5 inspector](https://github.com/ckeditor/ckeditor5-inspector) and [development tools packages](https://github.com/ckeditor/ckeditor5-dev) are kept in separate repositories. The steps below assume that you want to propose a change in the [main CKEditor 5 repository](https://github.com/ckeditor/ckeditor5).

Assuming that you would like to propose some changes, these are the steps you should take to create a pull request:

1. Make sure to open a ticket in <https://github.com/ckeditor/ckeditor5> describing the issue, feature or problem that you want to solve in your pull request. This can be skipped in case of obvious and trivial changes (typos, documentation, etc.).

2. Make sure your [development environment](#ckeditor5/latest/framework/contributing/development-environment.html) is ready.

3. Go to GitHub and [fork the repository](https://help.github.com/articles/fork-a-repo). The forked repository will appear in your GitHub account as `https://github.com/YOUR-USERNAME/ckeditor5`.

4. Open your terminal, then go to the package (“repository”) folder in your development environment:

```shell
   $ cd path/to/ckeditor5
   ```

5. Start a new branch for your code. We use the `i/GITHUB-ISSUE-NUMBER` convention for branch names:

```shell
   $ git checkout -b i/GITHUB-ISSUE-NUMBER
   ```

6. Make the changes. Stick to the [code-style guidelines](#ckeditor5/latest/framework/contributing/contributing.html--code-style) and remember about [tests and 100% code coverage](#ckeditor5/latest/framework/contributing/contributing.html--tests)!

7. Commit your changes:

```shell
   $ git commit -m "Squashed a nasty bug in the link editing."
   ```

8. Now it is time to make your changes public. First, you need to let `git` know about the fork you created by adding the remote:

```shell
   $ git remote add my-fork https://github.com/YOUR-USERNAME/ckeditor5
   ```

9. Push your changes to your forked repository:

```shell
   $ git push my-fork i/GITHUB-ISSUE-NUMBER
   ```

10. Go to your forked repository on GitHub. Use the [pull request button](https://help.github.com/articles/about-pull-requests/) and follow the instructions.

11. **Let us know about your pull request!** The best way is to comment under the original issue.

Some additional things you should keep in mind:

* Your pull request should be minimal. It should change only things described in the ticket. Do not squeeze unrelated changes into your pull request.
* When making a pull request on GitHub, make sure to specify which ticket(s) your pull request resolves. It is also recommended to provide more information, like how to test the patch, issues that you encountered, decisions you had to make, known problems, etc.
* Make sure you signed the [Contributor License Agreement (CLA)](#ckeditor5/latest/framework/contributing/contributing.html--contributor-license-agreement-cla) and that tests pass. Test your changes!

### Translating

CKEditor 5 is a project with global impact, so contributing translations is both an easy and powerful way to help.

To make CKEditor 5 available in multiple languages, we use `.po` files for storing translations. These are text files commonly used in software development to translate interface texts. Each CKEditor 5 package keeps translation files in the `lang/translations` directory. To provide missing translations, just edit the `.po` file and prepare a [pull request](#ckeditor5/latest/framework/contributing/contributing.html--creating-a-pull-request).

Here as well, having a CLA in place is a requirement to become an official translator (see below).

### Reporting issues and requesting features

Read the [reporting issues](#ckeditor5/latest/support/index.html--reporting-issues) guide to learn more.

### Contributor License Agreement (CLA)

To accept contributions sent to us in the form of code, documentation, or translations, a Contributor License Agreement (CLA) must be in place to clarify the intellectual property license granted with them. This license is for your protection as a contributor as well as the protection of us and our users; it does not change your rights to use your own contributions for any other purpose.

To sign the CLA and to get more information, follow this link: <https://cla.ckeditor.com/>.

### Signing commits

Starting January 1, 2025, all commits targeting the main branches must be signed for security reasons. We therefore require you to sign all commits added to CKEditor 5’s codebase.

We use Git signing to ensure the commits added to the codebase are verified. By signing your commits, you can prove that you are the author and ensure that the code has not been tampered with. This aids the compliance with our SOC2 Type 2 certification.

Git commit signing attaches a unique cryptographic signature to a commit, which adds a layer of security, making it easier to trust the source of the code changes. To set up your digital signature, please refer to the GitHub [Signing commits](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits) guide. Please note that the GPG key must use the same values as a committer, so the name, surname, and email must be identical.

<a id="ckeditor5/latest/framework/contributing/development-environment.html">source file: "ckeditor5/latest/framework/contributing/development-environment.html"</a>

## Development environment

The CKEditor 5 codebase is divided into multiple [npm](http://npmjs.com/) packages. The main package is [`ckeditor5`](https://github.com/ckeditor/ckeditor5) which installs all project dependencies and various development-related resources such as:

* the testing environment setup,
* configuration for [pnpm](https://pnpm.io),
* translation management tools,
* documentation generator,
* and release tools.

The main package’s GitHub repository also [hosts all other CKEditor5 sub-packages](https://github.com/ckeditor/ckeditor5/tree/master/packages).

You can find all the official packages listed in the [CKEditor 5 repository’s README](https://github.com/ckeditor/ckeditor5#packages).

> **Note**
>
> Before version **19.0.0** CKEditor 5 was developed in a multi-repository architecture. If you would like to work with an older multi-repository release, please refer to the [older Development environment guide](https://ckeditor.com/docs/ckeditor5/19.0.0/framework/guides/contributing/development-environment.html) for multi-repository oriented instructions.

### Requirements

To start developing CKEditor 5 you will require:

* [Node.js](https://nodejs.org/en/) 24.11.0+
* [pnpm](https://pnpm.io/) 10.17.0+
* [Git](https://git-scm.com/)

### Setting up the CKEditor development environment

First, you need to install [pnpm](https://pnpm.io) to use it for dependency management.

It is best to install it in your system is to [follow the official pnpm installation guide](https://pnpm.io/installation).

Then clone the [CKEditor 5 repository](https://github.com/ckeditor/ckeditor5):

```bash
git clone https://github.com/ckeditor/ckeditor5.git
cd ckeditor5
```

And install all CKEditor 5 packages from the [npm registry](http://npmjs.com/).

```bash
pnpm install
```

### Running tests

Automated tests are executed with the packages’ own `test` scripts. The root `test` script translates a shorthand package selection into [pnpm filters](https://pnpm.io/filtering):

```bash
pnpm run test -f engine
```

This command will run the [`ckeditor5-engine`](https://github.com/ckeditor/ckeditor5-engine) package’s tests. To also generate the code coverage report, add the `--coverage` (alias `-c`) option.

To start a server for manual tests, use the `manual` task in the root of the repository:

```bash
pnpm run manual
```

You can read more about the [Testing environment](#ckeditor5/latest/framework/contributing/testing-environment.html).

### Generating documentation

To build the documentation, you need to run the `docs` task:

```bash
pnpm run docs
```

The documentation will be available in `build/docs/`.

This task accepts various flags for skipping certain steps, filtering guides or snippets, and more. Run `pnpm run docs -h` to see all available options and examples.

After building documentation, you can quickly start an HTTP server to serve them:

```bash
pnpm run docs:serve
```

#### Verifying documentation

To verify that all pages in our documentation can be opened without any errors, you do not need to do that manually, page by page. Instead, there is a web crawler that automatically traverses the documentation and it visits all pages that have been found. The crawler opens a headless Chromium browser and logs to the console any error that has been found.

To check pages in the documentation, build it (`pnpm run docs`), serve it (`pnpm run docs:serve`), and then run the crawler:

```bash
pnpm run docs:verify
```

> **Note**
>
> By default, the crawler scans `http://fake.ckeditor.com:8080`, so you need to adjust your hosts file first.

The crawler collects and opens all links from the documentation, except the API and assets.

The crawler accepts the following arguments:

* `--url` (alias `-u`) – The URL to start crawling. This argument is required. Thanks to it you can verify for example,a deployed documentation.
* `--depth` (alias `-d`) – A number that defines how many nested page levels should be examined. Infinity by default.
* `--exclude` (alias `-e`) – A string with URL exclusion – links that match the excluded part are skipped. You can define multiple exclusions by providing multiple `--exclude` (or `-e`) arguments. Not specifying a value removes default exclusions, if any. Nothing is excluded by default, but the `docs:verify` script has some predefined ones.
* `--concurrency` (alias `-c`) – Number of concurrent pages (browser tabs) to be used during the scan. By default all links are opened one by one, sequentially (concurrency is 1).
* `--quit` (alias `-q`) – A boolean argument that specifies, whether the scan should be terminated as soon as the first error is found. Disabled by default, so all found links are scanned regardless of whether they have errors or not.

For example, to check the documentation without the default exclusions (the API and assets links), using only 2 concurrent pages and terminate the scan as soon as first error is found, run this command:

```bash
pnpm run docs:verify -e -c 2 -q
```

##### Defining exclusions for web crawler

The crawler supports exclusions provided as text patterns, which are then searched for in the error messages as substrings. This pattern is just a plain text, not a regular expression. When a pattern (substring) is found, such an error is ignored - it is not listed after the finished scan and it does not mark the entire scan as failed. Only non-ignored errors are logged at the end of the scan.

The pattern for ignoring an error must be defined in `<meta>` tag on a page, where an error occurs. This `<meta>` tag must have `x-cke-crawler-ignore-patterns` name and `content` value provided as JSON object, where:

* Each key is the error type, that can be detected by the crawler.
* Each value is the text or an array of texts, that are used for finding a match in error messages. The special wildcard value `*` can be used to ignore all errors for a given error type.

The following error types are supported: `uncaught-exception`, `request-failure`, `response-failure`, `console-error`, `navigation-error` and `page-crash`:

* `uncaught-exception` – As the name suggests, these are uncaught exceptions from the page.

* `request-failure` – This error occurs, when the request has not been sent (for example, it was blocked by the browser) or has not received any response (for example, due to a timeout or in case the remote server is unreachable). HTTP error responses, such as 404 or 500, are considered successful ones from the HTTP standpoint. Such requests will not be logged as request failures but as response failures.

* `response-failure` – Each HTTP response with a status code equal to or greater than 400 is treated as a failed one.

* `console-error` – All `console.error()` calls are treated as an error.

* `navigation-error` – The navigation error may happen, when:

* There is an SSL error (for example,in the case of a self-signed certificate or an expired one).
  * The target URL is invalid.
  * The timeout is exceeded during navigation to a page, so the `load` event is not emitted (for example, due to an infinite loop in the JavaScript code).

* `page-crash` – The general page malfunction, that does not fit other categories (like running out of RAM).

| Error type           | Example                                                                                                                      |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `uncaught-exception` | `"uncaught-exception": "ckeditor-duplicated-modules"` This pattern ignores only the `ckeditor-duplicated-modules` exception. |
| `request-failure`    | `"request-failure": "missing-file.jpg"` All requests containing the `missing-file.jpg` in the URL are ignored.               |
| `response-failure`   | `"response-failure": "HTTP response status code: 401"` All requests requiring authorization are ignored.                     |
| `console-error`      | `"console-error": "Example error message"` All console errors containing “Example error message” substring are ignored.      |
| `navigation-error`   | `"navigation-error": "Navigation timeout of 15000 ms exceeded"` Links, which are not completely loaded, are ignored.         |
| `page-crash`         | `"page-crash": "Error: Page crashed!"` This general text pattern ignores all page crashes.                                   |

These patterns are simply added as keys and values in a JSON object to the `<meta>` tag on a page, where they should be active:

```html
<meta name="x-cke-crawler-ignore-patterns" content='{
    "page-crash": "Error: Page crashed!",
    "uncaught-exception": "ckeditor-duplicated-modules",
    "console-error": "Example error message"
}'>
```

The pattern (regardless of the type of error) does not have to be a string, but can also be defined as an array of strings (patterns) to ignore many different errors:

```html
<meta name="x-cke-crawler-ignore-patterns" content='{
    "console-error": [ "Error 1", "Error 2", "Error 3" ]
}'>
```

To ignore all errors, use the special wildcard value `*`:

```html
<meta name="x-cke-crawler-ignore-patterns" content='{
    "console-error": "*"
}'>
```

In addition to the possibility of defining exclusions in the `<meta>` tag, it is also possible to specify that the link cannot be visited by the crawler by adding a `data-cke-crawler-skip` attribute:

```html
<a href="path/to/page" data-cke-crawler-skip>No entry for crawler, sorry</a>
```

### Generating content styles

Content styles let you customize the appearance of editor content presented to the readers.

For a complete explanation of what content styles are, how they work, and how to configure them in your project, refer to the [Content styles](#ckeditor5/latest/getting-started/setup/css.html) guide.

Packages that provide styles use two entry points in their `theme` directory:

* `index-editor.css` imports styles used only by the editor UI and editing view.
* `index-content.css` contains styles used when displaying editor data outside the editor. Content selectors must use the `.ck-content` scope.

The package’s `src/index.ts` imports both entry points. The build generates `dist/index-editor.css`, `dist/index-content.css`, and a combined `dist/index.css` file. Run `pnpm check-css-imports` to verify that every theme stylesheet is reachable from exactly one entry point.

### Additional information for contributors

#### SVG icons

By default, CKEditor 5 supports SVG icons found in the `ckeditor5-*/theme/icons` folders. Unfortunately, most of the SVG editing software produces the output with comments, obsolete tags, and complex paths, which bloats the DOM and makes the builds heavy for no good reason.

To remove the excess data and prevent [certain issues](https://github.com/ckeditor/ckeditor5-ui/issues/245), **you should optimize all new icons before adding them to the code base**. To do that, you can use the `clean-up-svg-icons` script in the [root of the project](#ckeditor5/latest/framework/contributing/development-environment.html--setting-up-the-ckeditor-development-environment), a wrapper for the [SVGO](https://github.com/svg/svgo) tool:

```bash
cd path/to/ckeditor5

# Optimize all SVG files in the folder.
npm run clean-up-svg-icons path/to/icons/*.svg

# Optimize a single SVG file.
npm run clean-up-svg-icons path/to/icon/icon.svg
```

The script reduces the icon size up to 70%, depending on the software used to create it and the general complexity of the image.

> **Note**
>
> You may still need to tweak the source code of the SVG files manually after using the script:
>
> * Sometimes SVGO leaves empty (transparent) groups `<g>...</g>`. They should be removed from the source and running `clean-up-svg-icons` again usually does that.
> * Make sure the number of `<path>` elements is minimal. Merge paths whenever possible in the image processor before saving the file.

<a id="ckeditor5/latest/framework/contributing/package-metadata.html">source file: "ckeditor5/latest/framework/contributing/package-metadata.html"</a>

## Package metadata

The package metadata is a set of CKEditor 5-related data describing plugins that the package delivers. It allows for the automated detection of plugins and building them by an external builder.

In the case of official CKEditor 5 packages (as well as some partner ones), this data is used by the [CKEditor 5 Builder](https://ckeditor.com/ckeditor-5/builder/?redirect=docs) and allows for building the [Features’ HTML output](#ckeditor5/latest/framework/architecture/plugins.html--plugins-and-html-output) page presenting a list of all official CKEditor 5 plugins.

The package metadata should be saved in the special `ckeditor5-metadata.json` file in the root of the package published on npm.

> **Note**
>
> Only plugins that provide major functionalities should be described in the metadata file. For example, the [metadata file for the `@ckeditor/ckeditor5-mention` package](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-mention/ckeditor5-metadata.json) describes only the `Mention` plugin, which is a “glue plugin” that loads both the editing and UI parts of the mention feature. This package does not expose the `MentionEditing` and `MentionUI` plugins that cannot be used alone.

### Data format for plugin metadata

The `ckeditor5-metadata.json` file is a JSON object that holds the `plugins` array. Each element of this array should be an object containing information about a different plugin delivered by the package. Below is a list of all metadata properties that can be used to describe a plugin:

* `name` – A human-readable name of the plugin.

* `description` – A human-readable short description of the plugin.

* `docs` – An absolute or relative URL to the plugin documentation. If this URL is relative, it leads to the CKEditor 5 documentation in [https://ckeditor.com/docs/ckeditor5/latest/](#ckeditor5/latest/index.html).

* `path` – A path to the file, relative to the metadata file that exports the plugin.

* `className` – The name of the class used to create the plugin. This class should be exported from the file using the `export default` syntax.

* `requires` – An array of the plugin’s soft requirements and other non-explicit requirements. It should contain class names of plugins that should be included if this plugin is added. If the element of this array is another (nested) array containing plugins’ class names, it means that at least one plugin listed from this nested array is required, but not all of them.

* `registeredToolbars` – An array of all toolbar names registered by the plugin. These names need to represent the configuration path (for example, `table.contentToolbar` for `editorConfig.table.contentToolbar` and `table.tableToolbar` for the `editorConfig.table.tableToolbar`, which are registered by the `Table` plugin).

* `uiComponents` – An array of objects that describes UI components exported by the plugin. Each object in this array may contain:

* `name` – The name of the component the plugin exports. It should match the actual UI name registered by the plugin.
  * `type` – The component type: `Button`, `SplitButton` or `Dropdown`.
  * `iconName` – The exported icon identifier from `@ckeditor/ckeditor5-icons` (for example, `IconBold`, `IconTable`). Must match an export name from the icons package.
  * `label` – Text content for `Dropdown` components.
  * `toolbars` – An array of toolbar names that a given UI component can be added to. Some UI components may be added to multiple toolbars.

* `htmlOutput` – An array of objects that defines all possible HTML elements which can be created by a given plugin. The main property in this object is `elements`. Other properties (like `classes`, `styles`, `attributes`) only apply to items defined in the `elements` property within a given object. The wildcard character `*` is used to mark any value. The full list of all these properties includes:

* `elements` – HTML elements (a single one or an array of these) that are created or altered by the plugin. The pseudo-element `$block` indicates that a given plugin applies classes, styles or attributes (defined in appropriate properties) for all block elements.
  * `classes` – CSS class names (a single one or an array of these) that may be applied to the HTML elements defined in the `elements` property.
  * `styles` – Inline CSS styles (a single one or an array of these) that may be applied to the HTML elements defined in the `elements` property.
  * `attributes` – HTML attributes (a single one or an array of these) other than `class` and `styles` (covered separately) that might be applied to the HTML elements defined in the `elements` property.
  * `implements` – The name of an element or a pseudo-element which indicates that HTML elements defined in the `elements` property may contain classes, styles or attributes that are created by other plugins. For example, `implements` equal to `$block` means that HTML elements may contain classes, styles or attributes that are defined by another plugin, which has `elements` equal to `$block`.
  * `isAlternative` – If the plugin output depends on its configuration, this value should be set to `true` to mark outputs that are not produced by the default configuration. If this value is either missing or `false`, the output will be considered as default output.
  * `_comment` – A human-readable description to explain more complicated cases, for example: the conditions when a given element, class or style can be created.

Below is an example showing how the `Bold` plugin can be documented using this format:

```json
{
    "name": "Bold",
    "className": "Bold",
    "description": "Implements bold formatting support. It is a part of the basic text styles package.",
    "docs": "features/basic-styles.html",
    "path": "src/bold.js",
    "uiComponents": [
        {
            "type": "Button",
            "name": "bold",
            "iconName": "IconBold"
        }
    ],
    "htmlOutput": [
        {
            "elements": "strong"
        }
    ]
}
```

If you want to check how plugins are documented in other packages, visit the [CKEditor 5 packages](https://github.com/ckeditor/ckeditor5/tree/master/packages) section on GitHub and find the `ckeditor5-metadata.json` file in a package you are interested in.

<a id="ckeditor5/latest/framework/contributing/testing-environment.html">source file: "ckeditor5/latest/framework/contributing/testing-environment.html"</a>

## Testing environment

The CKEditor 5 testing environment lets you run the project’s automated (unit) and manual tests. This article explains how to run them.

Before reading this article we recommend getting familiar with the CKEditor 5 [development environment](#ckeditor5/latest/framework/contributing/development-environment.html).

### Introduction

The CKEditor 5 testing environment uses [Vitest](https://vitest.dev/) running automated tests in real browsers (the [browser mode](https://vitest.dev/guide/browser/)), while manual tests are served by a [Vite](https://vite.dev/)-based server. We created some [npm scripts](https://docs.npmjs.com/cli/v11/using-npm/scripts) which glue all these pieces and special requirements for CKEditor together.

Each CKEditor 5 package has its own tests suite (see for example the [engine’s tests](https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-engine/tests)) together with its own Vitest configuration and `test` script. Automated tests are executed directly with [pnpm](https://pnpm.io/), without any custom test runner. The custom Vitest matchers are implemented in the [`@ckeditor/ckeditor5-dev-tests`](https://www.npmjs.com/package/@ckeditor/ckeditor5-dev-tests) package, and the Vite plugins powering the manual test server are implemented in the [`@ckeditor/ckeditor5-dev-manual-server`](https://www.npmjs.com/package/@ckeditor/ckeditor5-dev-manual-server) package. Both can be reused outside of `ckeditor5`.

> **Note**
>
> Automated tests support TypeScript, and manual tests require it. Simply use the `.ts` extension.

### Running automated tests

Automated tests are executed with the packages’ own `test` scripts, run directly via pnpm. There is no dedicated test runner binary.

The root `pnpm run test` script is a thin wrapper that translates a shorthand package selection into [pnpm filters](https://pnpm.io/filtering). It accepts the following options:

* `--filter` (alias `-f`) – Comma-separated short package names selecting the packages to test. Globs are allowed, for example `-f editor-*`.
* `--coverage` (alias `-c`) – Runs the `coverage` script of the selected packages instead of `test`.
* `--attempts` – The number of attempts for each package’s test run. Failed runs are retried per package. It is meant for continuous integration environments and defaults to `1`.

All remaining arguments are passed to Vitest. Positional arguments are treated by Vitest as test file filters (they match a part of the test file path). You can also pass any other [Vitest CLI option](https://vitest.dev/guide/cli.html).

You can run the automated tests for the whole repository, a single package, a directory, or a single file:

| Scope                        | Command                                                                          |
| ---------------------------- | -------------------------------------------------------------------------------- |
| The whole repository         | `pnpm run test` (it sequentially runs the `test` script of every package)        |
| A single package             | `pnpm run test -f engine` or natively: `pnpm --filter ckeditor5-engine run test` |
| Multiple packages            | `pnpm run test -f editor-*,core`                                                 |
| A directory inside a package | `pnpm run test -f engine tests/view`                                             |
| A single file                | `pnpm run test -f basic-styles tests/bold.js`                                    |

Apart from the `test` and `coverage` scripts, each package provides the following scripts:

* `test:browser` – Runs the tests in a visible (non-headless) browser.
* `test:debug` – Runs the tests in a visible browser in the watch mode. Useful for debugging with the browser developer tools.

#### Examples

Run all tests of the [`ckeditor5-core`](https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-core/tests) package with the code coverage check:

```bash
pnpm run test -c -f core
```

Run the [engine’s `view` namespace tests](https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-engine/tests/view):

```bash
pnpm run test -f engine tests/view
```

Run and debug the `bold.js` tests in the [`ckeditor5-basic-styles`](https://github.com/ckeditor/ckeditor5/tree/master/packages/ckeditor5-basic-styles/tests) package in a visible browser:

```bash
pnpm --filter ckeditor5-basic-styles run test:debug tests/bold.js
```

#### Custom Vitest matchers

The testing environment registers some custom [Vitest matchers](https://vitest.dev/guide/extending-matchers.html). There is no need to import them, as they are registered by default inside all tests.

##### `toEqualMarkup`

Tests whether two given strings containing markup language are equal. Unlike `expect().toEqual()`, this matcher formats the markup before showing a diff. It can be used to test HTML strings and strings containing a serialized model.

This assertion will pass:

```js
expect( `<b>foo</b>` ).toEqualMarkup( `<b>foo</b>` )
```

This assertion will throw an error:

```js
expect(
    '<paragraph>foo bXXX[]r baz</paragraph>'
).toEqualMarkup(
    '<paragraph>foo bYYY[]r baz</paragraph>'
);
```

### Running manual tests

To start the manual tests server, use the `pnpm run manual` task. It starts a [Vite](https://vite.dev/) development server available at <http://localhost:8125>.

The task accepts the standard [Vite CLI options](https://vite.dev/guide/cli.html), for example `--port`.

Debug flags are controlled with the `CK_DEBUG` environment variable. The base set of debug logs (`// @if CK_DEBUG //`) is always enabled. To uncomment additional debug code, pass a comma-separated list of flags, for example `CK_DEBUG=engine pnpm run manual` to enable the `// @if CK_DEBUG_ENGINE //` lines in the code.

#### Creating a manual test

A manual test consists of 2 files:

* A `<name>.manual.html` file – a complete HTML document (with the DOCTYPE, `<head>`, and `<body>`) that you fully own. You can freely add a Content Security Policy `<meta>` tag, external scripts, `<style>`, or `<link>` tags in the `<head>`. The `.manual.html` suffix is what marks the file as a manual test.
* A `<name>.ts` file with the TypeScript part of the test (for example, the code initializing an editor). Reference it from the document with a `<script type="module">` tag.

Test instructions live inside the document in a `<ck-manual-header>` element – its children are rendered as a collapsible instructions panel. In the tests list, each test is identified by its file path relative to the `tests/manual/` directory.

> **Note**
>
> Only files with the `.manual.html` suffix are treated as manual tests. A plain `.html` file placed in a `tests/manual/` directory is treated as a static fixture (for example, content loaded into an `<iframe>`) and is never registered as a test.

An example `<name>.manual.html` file, which also serves as a template for new tests:

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Create a new link</title>
    <script type="module" src="./link.ts"></script>
</head>
<body>
    <ck-manual-header>
        <h2>Create a new link</h2>
        <ol>
            <li>Select a fragment of the regular text.</li>
            <li>Click the toolbar "Link" button.</li>
            <li>Check if the balloon panel attached to the selection appeared.</li>
            <li>Fill in the "Link URL" input in the panel.</li>
            <li>Click the "Save" button.</li>
            <li>Check if the selected text is converted into a link.</li>
        </ol>
    </ck-manual-header>

<div id="editor">...</div>
</body>
</html>
```

An example script file (`link.ts`):

```ts
import { ClassicEditor, Essentials, Paragraph } from 'ckeditor5';

ClassicEditor
    .create( {
        attachTo: document.querySelector( '#editor' ),
        licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
        plugins: [ Essentials, Paragraph ]
    } )
    .then( editor => {
        window.editor = editor;
    } )
    .catch( err => {
        console.error( err.stack );
    } );
```

> **Note**
>
> Do not forget to add all dependencies of your manual test as `devDependencies` (in `package.json`).

> **Note**
>
> The `manual/` test directories should always be located in the root of the `tests/` directories.
>
> * `packages/ckeditor5-engine/tests/manual/view/focus.ts` – correct path.
> * `packages/ckeditor5-engine/tests/view/manual/focus.ts` – incorrect path.

#### Verifying all manual tests

To verify that all manual tests can be **opened** without any errors (the crawler does not execute the manual test steps, it just visits the page), you do not need to do that manually, page by page. Instead, there is a web crawler that automatically traverses the documentation and visits all pages that have been found. The crawler opens a headless Chromium browser and logs to the console any error that has been found.

To check manual tests, run:

```bash
pnpm run manual:verify
```

It builds the manual tests, starts a local preview server, and runs the crawler against it – no separate server is needed.

Read more about the crawler in the [Verifying documentation](#ckeditor5/latest/framework/contributing/development-environment.html--verifying-documentation) guide.

### Running memory leak tests

To run the memory leak tests, use the `pnpm run test:memory` command. It builds a browser bundle, starts a local server, and runs the tests in headless Chromium.

The command accepts the following arguments:

* `--editor` – A list of editor names to test. You can pass the option multiple times. Defaults to `BalloonEditor`, `ClassicEditor`, `DecoupledEditor`, `InlineEditor`, and `MultiRootEditor`.
* `--html` – The HTML file to load from `scripts/memory/assets`. Defaults to `index.html`.
* `--no-build` – Skips generating the browser build and reuses the existing editor assets.

#### Examples

Run all memory leak tests:

```bash
pnpm run test:memory
```

Test only the classic and inline editors:

```bash
pnpm run test:memory --editor ClassicEditor --editor InlineEditor
```

Use a custom HTML file from `scripts/memory/assets`:

```bash
pnpm run test:memory --html my-test.html
```

Reuse existing assets:

```bash
pnpm run test:memory --no-build
```

#### Interpreting the results

Each editor run consists of multiple create/destroy cycles. The warmup phase creates and destroys the editor a few times to populate caches and JIT state. The actual test then repeats the same create/destroy cycle more times while sampling memory between cycles. This makes the results less sensitive to first‑run effects and helps highlight steady growth trends.

After the run completes, the summary table reports:

* **Baseline** – The memory level after warmup. It is the reference point for the rest of the run and should already include initial cache effects.
* **Growth** – The difference between the final measurement and the baseline across repeated cycles. Use this to spot steady memory increases over time rather than one‑off spikes.
* **Tail Growth** – The spread within the last few measurements. It helps verify that memory stabilized near the end; large values suggest a still-growing footprint or high noise even after multiple cycles.
* **Status** – `OK` when both Growth and Tail Growth stay below the threshold. `Exceeds threshold` or `Error` means the run should be treated as a failure.

### Test suite and CI

To ensure the highest quality, we maintain a complete test suite with a stable 100% code coverage for each of the packages. As of 2026, this means over 29,000 tests and the number is growing. Since every package is tested separately, we implement lower-level tests for libraries and higher-level tests for end-user features.

Such an extensive test suite requires a proper continuous integration service. We use [CircleCI](https://circleci.com/) as a build platform. This service ensures a seamless and fast developer experience and allows us to focus on the job.

Besides automated tests, we also maintain a smaller set of manual tests. They help us verify whether something unexpected happens that might have been missed by the automated tests.

When proposing a pull request, make sure to add test(s) that verify it. Every code change should be accompanied by a test which proves that it is needed. Such a strict approach to testing ensures that we have not only 100% of code coverage (which is quite easy to achieve and gives only illusory safety) but also a high level of coverage for cases that we failed to notice initially (and might do that again in the future).

The conventions those tests should follow – how to organize them, name them, and write assertions, spies, and fake timers – are described in the [Tests](#ckeditor5/latest/framework/contributing/code-style.html--tests) section of the code style guide.

<a id="ckeditor5/latest/framework/deep-dive/clipboard.html">source file: "ckeditor5/latest/framework/deep-dive/clipboard.html"</a>

## Clipboard

The clipboard feature (implemented by the [`Clipboard`](../../api/module_clipboard_clipboard-Clipboard.html) plugin) is responsible for the integration with the native clipboard. The native clipboard is a feature of the operating system and the browser. It is used when the user copies, cuts, pastes, or drags and drops content within the editor or from/to the “outside.”

CKEditor 5 intercepts all native events like `copy`, `cut`, or `drop` and handles them on its side. The goal is to not allow the browser to touch the content in the rich text editor. This could lead to the browser messing it up.

There are two directions of content processing:

* When the content is being pasted or dropped into the editor, it goes through the [input pipeline](#ckeditor5/latest/framework/deep-dive/clipboard.html--input-pipeline).
* When the content is being copied, cut, or dragged from the editor, it goes through the [output pipeline](#ckeditor5/latest/framework/deep-dive/clipboard.html--output-pipeline).

Both pipelines allow the features to process the content to be inserted or set to the clipboard. They also allow to override the default mechanisms at different stages of these processes.

### Input pipeline

When the user pastes or drops content into the editor, the browser fires an event. The clipboard feature intercepts this event and starts the following mechanism:

1. [`ClipboardObserver`](../../api/module_clipboard_clipboardobserver-ClipboardObserver.html) turns this event into a synthetic [`view.Document#paste`](../../api/module_engine_view_document-ViewDocument.html#event-paste) or [`view.Document#drop`](../../api/module_engine_view_document-ViewDocument.html#event-drop).
2. The content to be inserted by both actions (paste and drop) should usually be processed in the same way and both actions have a similar effect. Both events are thus turned into a single [`view.Document#clipboardInput`](../../api/module_engine_view_document-ViewDocument.html#event-clipboardInput) event for easier handling.
3. Next, the clipboard feature listens to the `view.Document#clipboardInput` event and retrieves and pre-processes the `text/html` or `text/plain` content which it finds in the [event’s `dataTransfer`](../../api/module_engine_view_datatransfer-ViewDataTransfer.html). It then fires the [`ClipboardPipeline#inputTransformation`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-inputTransformation) event with the retrieved content in the event data `content` property as a [`view.DocumentFragment`](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html).
4. Then, the clipboard feature listens to the `ClipboardPipeline#inputTransformation` event. It takes the processed content and transforms it to the [`model.DocumentFragment`](../../api/module_engine_model_documentfragment-ModelDocumentFragment.html). It then fires the [`ClipboardPipeline#contentInsertion`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-contentInsertion) event with the transformed content in the event data `content` property as a [`model.DocumentFragment`](../../api/module_engine_model_documentfragment-ModelDocumentFragment.html).
5. Finally, the clipboard feature listens to the `ClipboardPipeline#contentInsertion` event. It takes the model fragment and [inserts](../../api/module_engine_model_model-Model.html#function-insertContent) it into the editor. Then it stores the range which contains all the performed changes in the `resultRange` property of the event data.

The clipboard feature listens to the `view.Document#clipboardInput`, `ClipboardPipeline#inputTransformation`, and `ClipboardPipeline#contentInsertion` events using [low priority listeners](#ckeditor5/latest/framework/deep-dive/event-system.html--listener-priorities). This means that adding a normal listener and calling `evt.stop()` allows overriding the behavior implemented by the clipboard feature. It is a similar mechanism to the DOM’s `evt.preventDefault()` that lets you override the default browser behavior.

#### Input pipeline events overview

```
 ┌──────────────────────┐          ┌──────────────────────┐
 │     view.Document    │          │     view.Document    │
 │         paste        │          │         drop         │
 └───────────┬──────────┘          └───────────┬──────────┘
             │                                 │
             └────────────────┌────────────────┘
                              │
                    ┌─────────V────────┐
                    │   view.Document  │   Retrieves text/html from data.dataTransfer
                    │  clipboardInput  │   and processes it to view.DocumentFragment.
                    └─────────┬────────┘
                              │
                  ┌───────────V───────────┐
                  │   ClipboardPipeline   │   Converts view.DocumentFragment
                  │  inputTransformation  │   to model.DocumentFragment.
                  └───────────┬───────────┘
                              │
                   ┌──────────V──────────┐
                   │  ClipboardPipeline  │   Calls model.insertContent().
                   │   contentInsertion  │
                   └─────────────────────┘
```

#### Handling clipboard input differently

By default, the clipboard feature retrieves `text/html` or `text/plain` from the clipboard. It normalizes the data a bit (for example, cleans up the [mess with whitespaces](https://github.com/ckeditor/ckeditor5-clipboard/issues/2)). It converts it to a [view `DocumentFragment`](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html) and fires the `ClipboardPipeline#inputTransformation` event with the document fragment for further processing.

You can use the [`view.Document#clipboardInput`](../../api/module_engine_view_document-ViewDocument.html#event-clipboardInput) event to override this behavior. For example, you can use it to:

* Handle pasted or dropped files. You can retrieve these from the `dataTransfer`.

Handling file upload requires, however, a lot more than reading [`dataTransfer.files`](../../api/module_engine_view_datatransfer-ViewDataTransfer.html#member-files). For a complete code example, check the source code of plugins like [`ImageUploadEditing`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-image/src/imageupload/imageuploadediting.ts).

* Change the type of data that the clipboard feature reads from the clipboard. For instance, you may want to use `application/rtf` if it is present in the `dataTransfer` (and ignore `text/html` in that case).

```js
  editor.editing.view.document.on( 'clipboardInput', ( evt, data ) => {
      const dataTransfer = data.dataTransfer;
      const rtfContent = dataTransfer.getData( 'application/rtf' );

// If no RTF was pasted, abort and let the clipboard feature handle the input.
      if ( !rtfContent ) {
          return;
      }

// Convert an RTF raw string to a view document fragment.
      const viewContent = convertRtfStringToView( rtfContent );

// Pass the view fragment to the default clipboard input handler
      // to allow further processing of the content.
      data.content = viewContent;
  } );
  ```

#### Processing input content

The [`ClipboardPipeline#inputTransformation`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-inputTransformation) event lets you process the content which is going to be inserted into the editor.

The default action is to fire a [`ClipboardPipeline#contentInsertion`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-contentInsertion) event. This event will [insert](../../api/module_engine_model_model-Model.html#function-insertContent) the content (`data.content`, represented by a [`ViewDocumentFragment`](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html)) to the editor if the data is not empty.

At this stage, features can process the pasted content. For example, you can implement a feature that wants to transform the pasted text into a link in the following way:

```js
const writer = new ViewUpcastWriter( editor.editing.view.document );

editor.plugins.get( 'ClipboardPipeline' ).on( 'inputTransformation', ( evt, data ) => {
    if ( data.content.childCount == 1 && isUrlText( data.content.getChild( 0 ) ) ) {
        const linkUrl = data.content.getChild( 0 ).data;

data.content = writer.createDocumentFragment( [
            writer.createElement(
                'a',
                { href: linkUrl },
                [ writer.createText( linkUrl ) ]
            )
        ] );
    }
} );
```

The default action (inserting the content into the editor) is performed by a low-priority listener, so it can be overridden by a normal one. With the `lowest` priority, you can also execute actions after the content has already been inserted.

```js
editor.plugins.get( 'ClipboardPipeline' ).on( 'contentInsertion', ( evt, data ) => {
    console.log( 'Content was inserted.' );
}, { priority: 'lowest' } );
```

> **Note**
>
> Check out the [event system deep dive](#ckeditor5/latest/framework/deep-dive/event-system.html--listener-priorities) guide to learn more about event listener priorities.

#### Paste as plain text plugin example

You can use the knowledge from the earlier sections to create a complete plugin. A perfect example to follow is our [`PastePlainText`](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-clipboard/src/pasteplaintext.ts) which pastes plain text when `Shift` is pressed. If you are not familiar with creating plugins in CKEditor 5, start by reading the [Creating a simple plugin](#ckeditor5/latest/framework/tutorials/crash-course/editor.html) guide.

### Output pipeline

The output pipeline is the equivalent of the input pipeline but for the copy and cut operations. It allows to process the content that will be then put into the clipboard or to override the whole process.

#### Output pipeline events overview

```
 ┌──────────────────────┐          ┌──────────────────────┐   Retrieves the selected
 │     view.Document    │          │     view.Document    │   model.DocumentFragment
 │         copy         │          │          cut         │   and fires the `outputTransformation`
 └───────────┬──────────┘          └───────────┬──────────┘   event.
             │                                 │
             └────────────────┌────────────────┘
                              │
                ┌─────────────V────────────┐   Processes model.DocumentFragment
                │     ClipboardPipeline    │   and converts it to
                │    outputTransformation  │   view.DocumentFragment.
                └──────────────────────────┘
                              │
                ┌─────────────V────────────┐   Processes view.DocumentFragment
                │       view.Document      │   to text/html and text/plain
                │      clipboardOutput     │   and stores results in data.dataTransfer.
                └──────────────────────────┘
```

#### 1. On [`view.Document#copy`](../../api/module_engine_view_document-ViewDocument.html#event-copy) and [`view.Document#cut`](../../api/module_engine_view_document-ViewDocument.html#event-cut)

The default action is to:

1. [Get the selected content](../../api/module_engine_model_model-Model.html#function-getSelectedContent) from the editor.
2. Prevent the default action of the native `copy` or `cut` event.
3. Fire [`clipboard.ClipboardPipeline#outputTransformation`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-outputTransformation)\` with a selected content represented by a [model document fragment](../../api/module_engine_model_documentfragment-ModelDocumentFragment.html).

#### 2. On [`clipboard.ClipboardPipeline#outputTransformation`](../../api/module_clipboard_clipboardpipeline-ClipboardPipeline.html#event-outputTransformation)

The default action is to:

1. Processes `data.content` represented by a [model document fragment](../../api/module_engine_model_documentfragment-ModelDocumentFragment.html).
2. Fire [`view.Document#clipboardOutput`](../../api/module_engine_view_document-ViewDocument.html#event-clipboardOutput) with a processed `data.content` converted to a [view document fragment](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html).

#### 3. On [`view.Document#clipboardOutput`](../../api/module_engine_view_document-ViewDocument.html#event-clipboardOutput)

The default action is to put the content (`data.content`, represented by a [`ViewDocumentFragment`](../../api/module_engine_view_documentfragment-ViewDocumentFragment.html)) to the clipboard as HTML. In the case of the cut operation, the selected content is also deleted from the editor.

This action is performed by a low-priority listener, so it can be overridden by a normal one.

At this stage other features can process the copied or cut content.

<a id="ckeditor5/latest/framework/deep-dive/conversion/attributes.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/attributes.html"</a>

## Attributes and inline formatting

In CKEditor 5, inline formatting (such as bold, italic, or font size) is stored as text attributes on the model’s text nodes. This guide explains how those attributes work and how they are converted between the model and view layers. To follow it, you should first understand how [conversion](#ckeditor5/latest/framework/deep-dive/conversion/intro.html) works.

### Inline and block content

Generally speaking, there are two main types of content in the editor view and data output: inline and block.

The inline content means elements like `<strong>`, `<a>`, or `<span>`. Unlike `<p>`, `<blockquote>`, or `<div>`, the inline elements do not structure the data. Instead, they format some text in a specific (visual and semantical) way. These elements are characteristic of text. For instance, you could say that some part of the text is bold, is linked, and so on. This concept has its reflection in the model of the rich-text editor, where `<a>` or `<strong>` are not represented as elements. Instead, they are the attributes of the text.

For example – in the model, you might have a `<paragraph>` element with the “Foo bar” text, where “bar” has the `bold` attribute set to `true`. A pseudo-code of this _model_ data structure could look as follows:

```html
<paragraph>
    "Foo "			// no attributes
    "bar"			// bold=true
</paragraph>
```

> **Note**
>
> Throughout the rest of this guide, the following, shorter convention will be used to represent model text attributes for the sake of clarity:
>
> ```html
> <paragraph>Foo <$text bold="true">bar</$text></paragraph>
> ```

Note that there is no `<strong>` or any other additional element there; it is just some text with an attribute.

So, when does this text become wrapped with a `<strong>` element? This happens during the conversion to the view. It is also important to know what type of view element needs to be used. In the case of the elements that represent inline formatting, this should be an [attribute element](../../../api/module_engine_view_attributeelement-ViewAttributeElement.html).

### Conversion of multiple text attributes

A model text node may have multiple attributes (for example, be bolded and linked), and all of them are converted into their respective view elements by independent converters.

Keep in mind that in the model, attributes do not have any specific order. This is contrary to the editor view or HTML output, where inline elements are nested in one another. Fortunately, the nesting happens automatically during the conversion from the model to the view. This makes working in the model simpler, as features do not need to take care of breaking or rearranging elements in the model.

For instance, consider the following model structure:

```html
<paragraph>
    <$text bold="true" linkHref="url">Foo </$text>
    <$text linkHref="url">bar</$text>
    <$text bold="true"> baz</$text>
</paragraph>
```

During the conversion, it will be converted to the following view structure:

```html
<p>
    <a href="url"><strong>Foo </strong>bar</a><strong> baz</strong>
</p>
```

Note that the `<a>` element is converted in such a way that it always becomes the “topmost” element. This is intentional so that no element ever breaks a link, which would otherwise look as follows:

```html
<p>
    <strong><a href="url">Foo </a></strong><a href="url">bar</a><strong> baz</strong>
</p>
```

There are two links with the same `href` attribute next to each other in the generated view (editor output), which is semantically wrong. To make sure that this never happens, the view element that represents a link must have a [priority](../../../api/module_engine_view_attributeelement-ViewAttributeElement.html#member-priority) defined. Most elements, like `<strong>`, do not care about it and stick to the default priority (`10`). The [Link feature](#ckeditor5/latest/features/link.html) ensures that all `<a>` view elements have the priority set to `5`, therefore they are kept outside other elements.

### Merging attribute elements during conversion

Priority is not only important for determining the nesting order of attribute elements. It also plays a crucial role in deciding whether adjacent attribute elements can be merged during the conversion process.

Inline elements in the view, such as `<strong>` or `<em>`, are typically simple formatting elements without additional attributes. However, some features require more complex styling. For example, the [Font family feature](#ckeditor5/latest/features/font.html) adds a `fontFamily` attribute to text in the model. During downcast, this model attribute is converted to a view `<span>` element with a corresponding `style` attribute, which then appears as a `<span style="font-family: ...">` in the HTML output.

What would, then, happen if several model attributes were set on the same part of the text? Take this model example where `fontSize` is used next to `fontFamily`:

```html
<paragraph>
    <$text fontFamily="Tahoma" fontSize="big">foo</$text>
</paragraph>
```

CKEditor 5 features are implemented in a granular way, which means that the font size converter is completely independent from the font family converter. This means that the above example is converted as follows:

* `fontFamily="value"` converts to `<span style="font-family: value;">`,
* `fontSize="value"` converts to `<span class="text-value">`.

And, in theory, you could expect the following HTML as a result:

```html
<p>
    <span style="font-family: Tahoma;">
        <span class="text-big">foo</span>
    </span>
</p>
```

But this is not the most optimal output you can get from the rich-text editor. A single `<span>` element would be better:

```html
<p>
    <span style="font-family: Tahoma;" class="text-big">foo</span>
</p>
```

A single `<span>` makes more sense. And thanks to the merging mechanism built into the conversion process, this is the actual output of the conversion.

Why is this so? In the above scenario, two model attributes are converted to `<span>` elements. When the engine converts the first attribute (say, `fontFamily`), there is no `<span>` in the view yet. So the first `<span>` is added with the `style` attribute. But then, when the engine converts `fontSize`, the `<span>` is already in the view. The [downcast writer](../../../api/module_engine_view_downcastwriter-ViewDowncastWriter.html) recognizes it and checks whether these elements can be merged, following these three rules:

1. Both elements must have the same [name](../../../api/module_engine_view_element-ViewElement.html#member-name).
2. Both elements must have the same [priority](../../../api/module_engine_view_attributeelement-ViewAttributeElement.html#member-priority).
3. Neither can have an [ID](../../../api/module_engine_view_attributeelement-ViewAttributeElement.html#member-id).

If you need to keep attributes separated (for example, to prevent merging between two visually identical but semantically distinct decorations), set a unique `id`. Otherwise, leave the `id` unset and let the engine merge.

> **Note**
>
> When using the [General HTML Support (GHS)](#ckeditor5/latest/features/html/general-html-support.html) feature, be aware that the merging behavior can affect how the editor processes your HTML. For instance, adjacent `<span>` elements with no distinguishing attributes may be merged into a single element during the model-to-view conversion, as described in [this issue](https://github.com/ckeditor/ckeditor5/issues/15408). Conversely, adding an inline element (like `<a>`) inside a `<span>` may cause the `<span>` to split into multiple elements due to the nesting and priority rules. If you need to preserve the exact structure of your HTML, consider using element IDs or adjusting your content structure to work with CKEditor 5’s attribute element behavior.

### Further reading

If you want to learn more about converting model attributes, we recommend checking out the following guides:

* [Implementing a block widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html--defining-converters) – A practical tutorial showing conversion in action.
* [Implementing an inline widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-an-inline-widget.html--defining-converters) – Learn how to implement inline widgets with custom conversion.

<a id="ckeditor5/latest/framework/deep-dive/conversion/downcast.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/downcast.html"</a>

## Downcast conversion – model to view

### Introduction

The process of converting the **model** to the **view** is called a **downcast**.

The downcast process happens every time a model node or attribute needs to be converted into a view node or attribute.

The editor engine runs the conversion process and uses converters registered by the plugins.

### Registering a converter

To tell the engine how to convert a specific model element into a view element, you need to register a **downcast converter** by using the `editor.conversion.for( 'downcast' )` method, listing the elements that should be converted in the process:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'paragraph',
        view: 'p'
    } );
```

The above converter will handle the conversion of every `<paragraph>` model element into a `<p>` view element. You can see the input and output in the snippet below.

> **Note**
>
> This is just an example. In fact, paragraph support is already provided by the [paragraph plugin](../../../api/paragraph.html) so you do not really need to write your own `<paragraph>` element to `<p>` element conversion.

You just learned about the [`elementToElement()` **downcast** conversion helper method](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html--element-to-element-conversion-helper)! More helpers are documented in the following chapters.

### Downcast pipelines

The CKEditor 5 engine uses two different views: the **data view** and the **editing view**.

The **data view** is used when generating the editor output. This process is controlled by the data pipeline.

The **editing view**, on the other hand, is what you see when you open the editor. This is controlled by the editing pipeline.

The simple code example presented before registers a converter for both of these pipelines at once. It means that a `<paragraph>` model element will be converted to a `<p>` view element in both the **data view** and the **editing view** all the same.

Sometimes you may want to alter the converter logic for a specific pipeline. For example, in the editing view you may want to add some additional class to the view element. This kind of operation requires setting separate converters for both views, unlike the previous example where one, general downcast was set up.

```js
// dataDowncast for data pipeline
editor.conversion
    .for( 'dataDowncast' )
    .elementToElement( {
        model: 'paragraph',
        view: 'p'
    } );

// editingDowncast for editing pipeline
editor.conversion
    .for( 'editingDowncast' )
    .elementToElement( {
        model: 'paragraph',
        view: {
            name: 'p',
            classes: 'paragraph-in-editing-view'
        }
    } );
```

### Converting text attributes

As you should already know from the [chapter about the model](#ckeditor5/latest/framework/architecture/editing-engine.html--model), an **attribute** may be applied to a model text node.

Such text node attributes may be converted into view elements.

To do so, you can register a converter by using the [`attributeToElement()` conversion helper](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html--attribute-to-element-conversion-helper):

```js
editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'bold',
        view: 'strong'
    } );
```

The above converter will handle the conversion of every `bold` model text node attribute to a `<strong>` view element, as shown in the snippet below.

> **Note**
>
> Again, this is just an example for the sake of simplicity. Bold support is actually provided by the [basic styles](#ckeditor5/latest/features/basic-styles.html) plugin so you do not have to write your own bold attribute to strong element conversion.

### Converting element to element

Similar to the previous example, you can convert a `<heading>` model element into an `<h1>` view element with the use of the [`elementToElement()` conversion helper](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html--element-to-element-conversion-helper). A code to achieve it would look like this:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'heading',
        view: 'h1'
    } );
```

Which is equivalent to:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'heading',
        view: ( modelElement, { writer } ) => {
            return writer.createContainerElement(
                'h1'
            );
        }
    } );
```

You have previously learned that the `view` property can be a simple string or an object. The example above shows it is also possible to define a custom callback function to return the created element instead. The effect for this kind of conversion can be observed in the snippet below:

The `<heading>` element makes the most sense if you can set the heading level in the view.

In the previous chapter you have learned that you can apply attributes to text nodes. It is also possible to add attributes to elements, like in this example:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: {
            name: 'heading',
            attributes: [ 'level' ]
        },
        view: ( modelElement, { writer } ) => {
            return writer.createContainerElement(
                'h' + modelElement.getAttribute( 'level' )
            );
        }
    } );
```

From now on, every time a level attribute updates, the whole `<heading>` element will be converted to the `<h[level]>` element (for example `<h1>`, `<h2>`, etc).

You can check this in action by using the example below. Use the dropdown to change heading level in the model and see how view elements are updated by the converter:

> **Note**
>
> This, again, is just an example. Heading support is actually provided by the [headings feature](#ckeditor5/latest/features/headings.html) so you do not have to write your own `<heading level="1">` to `<h1>` element conversion.

### Converting element to structure

Sometimes you may want to convert a **single model element** into a more complex view structure consisting of a **single view element with children**.

You can use the [`elementToStructure()` conversion helper](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html--element-to-structure-conversion-helper) for this purpose:

```js
editor.conversion
    .for( 'downcast' ).elementToStructure( {
        model: 'myElement',
        view: ( modelElement, { writer } ) => {
            return writer.createContainerElement( 'div', { class: 'wrapper' }, [
                writer.createContainerElement( 'div', { class: 'inner-wrapper' }, [
                    writer.createSlot()
                ] )
            ] );
        }
    } );
```

The above converter will convert all `<myElement>` model elements to `<div class="wrapper"><div class="inner-wrapper"><p>...</p></div></div>` structures, as shown below:

> **Note**
>
> Using your own custom model element requires defining it in the [schema](#ckeditor5/latest/framework/deep-dive/schema.html) first.

> **Note**
>
> For editor users, the best way to interact with complex structures is to act as independent entities and stay intact, for instance, when copied, pasted, and edited. CKEditor 5 allows that through the [widget API](../../../api/module_widget_utils.html#function-toWidget). If you want to learn how to use it on top of `elementToStructure()`, be sure to check out the [Implementing a block widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html) tutorial.

### Downcasting overlapping markers

Multiple markers can share or overlap the same position in the model - for example, a delete marker and an insert marker can meet at the same boundary when text is replaced. The downcast dispatcher converts markers one at a time, so the conversion result would be non-deterministic if markers were processed in their [insertion order](../../../api/module_engine_model_markercollection-MarkerCollection.html). To prevent this, the engine always sorts markers into a stable **reverse DOM order** before downcasting, using [`compareMarkersForDowncast`](../../../api/module_engine_conversion_comparemarkers.html#function-compareMarkersForDowncast).

#### Why reverse DOM order matters?

Consider replacing the word “old” with “new” - this creates two adjacent markers (a delete range and an insert range) that share a boundary point. With `markerToElement`, each boundary becomes a self-closing tag, so the processing order controls where those tags land:

```html
Sorted (reverse DOM order):  <DEL-START/>old<DEL-END/><INS-START/>new<INS-END/>
Insertion order (legacy):    <DEL-START/>old<INS-START/><DEL-END/>new<INS-END/>
```

The sorted output is correct and stable. The insertion-order output is wrong: `<DEL-END/>` ends up inside the insert range.

#### Sort rules

The sort is applied to every pair of markers using the following cases (positions shown as `0123456789`, sorted result listed top-to-bottom):

1. Non-overlapping ranges - sorted by position, last range first:

```
   a: [--]               →   c, b, a
   b:     [--]
   c:        [--]
   ```

2. Adjacent ranges (end === start) - treated as non-overlapping:

```
   first:  [---]         →   third, second, first
   second:    [---]
   third:        [---]
   ```

3. Nested ranges (same start, different ends) - inner first, outer last:

```
   shorter: [-]          →   shorter, longer
   longer:  [---]
   ```

4. Partially overlapping ranges - sorted by start position, later start first:

```
   earlier: [---]        →   later, earlier
   later:     [---]
   ```

5. Identical ranges - fall back to reverse name comparison:

```
   alpha:   [---]        →   charlie, bravo, alpha
   bravo:   [---]
   charlie: [---]
   ```

Name comparison is **only a tie-breaker for identical ranges** (case 5 above). For all other cases - including non-overlapping ranges, adjacent ranges, and collapsed markers at the same position - the sort is based on range positions, and name order plays no role.

> **Important**
>
> This is especially important for features that use collapsed markers with random UID-based names (such as comments or HTML comments). The boundary walker in `markerToElement` intentionally does **not** sort collapsed markers at the same position by name, because `compareMarkersForDowncast` treats two collapsed markers at the same position as non-overlapping and preserves insertion order. Sorting by name in that case would make the output non-deterministic between runs.

Plugin developers **must not** rely on name-based ordering for anything other than co-located markers with identical, non-collapsed ranges.

This deterministic sort shipped in CKEditor 5 v48.1.0 and affects any feature that relies on markers, including comments, suggestions, mentions, find and replace, and restricted editing - see the [v48 update guide](#ckeditor5/latest/updating/guides/update-to-48.html) for release notes.

### Further reading

If you want to learn more about downcast helpers mentioned in this guide, we have [rounded them up](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html) for you with complete descriptions and examples. We also recommend you to check out the [upcast conversion](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html) guide and learn how to convert raw data on the editor input into a live model state.

<a id="ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html"</a>

## Downcast helpers – model to view conversion

This article lists all editor helpers available in the [downcast conversion](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html).

### Element to element conversion helper

Converting a model element to a view element is the most common case of conversion. It is used to create view elements like `<p>` or `<h1>`, that we call “container elements.”

When using the `elementToElement()` helper, a **single model element** will be converted to a **single view element**. The children of this model element need to have their own converters defined and the engine will recursively convert them and insert into the created view element.

#### Basic element to element conversion

If you want to convert a model element to a simple view element without any additional attributes, simply provide their names through the converter, as shown in this example:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'paragraphSeparator',
        view: 'hr'
} );
```

#### Using view element definition

Sometimes you may need to output a view element that has certain attributes, like a class name. To achieve this, you can provide an [element definition](../../../../api/module_engine_view_elementdefinition-ViewElementDefinition.html) in the `view` property:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'fancyParagraph',
        view: {
            name: 'p',
            classes: 'fancy'
        }
    } );
```

Check out the [`ViewElementObjectDefinition` documentation](../../../../api/module_engine_view_elementdefinition-ViewElementObjectDefinition.html) for more details.

#### Creating a view element using a callback

An alternative way to write a converter from the previous section using a callback would look as follows:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'fancyParagraph',
        view: ( modelElement, { writer } ) => {
            return writer.createContainerElement(
                'p', { class: 'fancy' }
            );
        }
    } );
```

Here, the second parameter of the view callback is the [DowncastConversionApi](../../../../api/module_engine_conversion_downcastdispatcher-DowncastConversionApi.html) object. It contains many properties and methods that can be useful when writing a more complex converters.

The callback should return a single container element. This element should not contain any children except UI elements. If you want to create a richer structure, use the `elementToStructure()` method.

#### Handling model elements with attributes

If the view element does not only depend on the model element itself but also on its attributes, you need to specify these attributes in the `model` property.

> **Note**
>
> If you forget to specify these attributes, the converter will still work for the insertion of the model element part but it will not handle any changes of the attribute value.

#### Changing converter priority

In case there are other converters with overlapping `model` patterns already present, you can prioritize your converter to override these. To do that, use the `converterPriority` property:

```js
editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'userComment',
        view: 'div'
    } );

editor.conversion
    .for( 'downcast' )
    .elementToElement( {
        model: 'userComment',
        view: 'article',
        converterPriority: 'high'
    } );
```

In the example above, the first converter has no explicitly set priority hence it assumes default priority, which is `normal`. The second one overrides it by setting the priority to `high`. Using both of these converters at once will result in the `<userComment>` element being converted to an `<article>` element.

This solution may also be handy if you want your converter to act as a fallback when other converters for a given element are not present (for example, a plugin has not been loaded). It can be easily achieved by setting the `converterProperty` to `low`.

### Element to structure conversion helper

Convert a single model element to multiple view elements (a structure of view elements).

#### Handling empty model elements

To convert a single model element `horizontalLine` to the following structure:

```html
<div class="horizontal-line">
    <hr />
</div>
```

you can use a converter similar to this one:

```js
editor.conversion
    .for( 'downcast' )
    .elementToStructure( {
        model: 'horizontalLine',
        view: ( modelElement, { writer } ) => {
            return writer.createContainerElement( 'div', { class: 'horizontal-line' }, [
                writer.createEmptyElement( 'hr' )
            ] );
        }
} );
```

Note that in this example we create two elements, which is not possible by using the previously mentioned `elementToElement()` helper.

> **Note**
>
> For editor users, the best way to interact with complex structures is to act as independent entities and stay intact, for instance, when copied, pasted, and edited. CKEditor 5 allows that through the [widget API](../../../../api/module_widget_utils.html#function-toWidget). If you want to learn how to use it on top of `elementToStructure()`, be sure to check out the [Implementing a block widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html) tutorial.

#### Handling model element’s children

The example above uses an empty model element. If your model element may contain children, you need to specify where in the view these children should be placed. To do that, use the `writer.createSlot()` helper.

```js
editor.conversion
    .for( 'downcast' )
    .elementToStructure( {
        model: 'wrappedParagraph',
        view: ( modelElement, conversionApi ) => {
            const { writer } = conversionApi;
            const paragraphViewElement = writer.createContainerElement( 'p', {}, [
                writer.createSlot()
            ] );

return writer.createContainerElement( 'div', { class: 'wrapper' }, [
                paragraphViewElement
            ] );
        }
    } );
```

> **Note**
>
> For editor users, the best way to interact with complex structures is to act as independent entities and stay intact, for instance, when copied, pasted, and edited. CKEditor 5 allows that through the [widget API](../../../../api/module_widget_utils.html#function-toWidget). If you want to learn how to use it on top of `elementToStructure()`, be sure to check out the [Implementing a block widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html) tutorial.

### Attribute to element conversion helper

The attribute to element conversion is used to create formatting view elements like `<b>` or `<span style="font-family: ...">` (that we call attribute elements). In this case, we do not convert a model element but a text node’s attribute. It is important to note that text formatting, such as bold or font size, should be represented in the model as text node attributes.

> **Note**
>
> In general, the model does not implement a concept of “inline elements” (in the sense in which they are defined by CSS). The only scenarios in which inline elements can be used, are self-contained objects such as soft breaks (`<br>`) or inline images.

#### Basic text attribute to model conversion

```js
editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'bold',
        view: 'strong'
    } );
```

A model text node `"CKEditor 5"` with a `bold` attribute will become a `<strong>"CKEditor 5"</strong>` in the view.

#### Using view element definition

You might want to output a view element that has more attributes, like a class name. To achieve that, you can provide an [element definition](../../../../api/module_engine_view_elementdefinition-ViewElementDefinition.html) in the `view` property:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'invert',
        view: {
            name: 'span',
            classes: [ 'font-light', 'bg-dark' ]
        }
    } );
```

Check out the [`ViewElementObjectDefinition` documentation](../../../../api/module_engine_view_elementdefinition-ViewElementObjectDefinition.html) for more details.

#### Creating a view element using a callback

You can also generate the view element by a callback. This method is useful when the view element depends on the value of the model attribute.

```js
editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'bold',
        view: ( modelAttributeValue, conversionApi ) => {
            const { writer } = conversionApi;

return writer.createAttributeElement( 'span', {
                style: 'font-weight:' + modelAttributeValue
            } );
        }
    } );
```

The second parameter of the view callback is the [DowncastConversionApi](../../../../api/module_engine_conversion_downcastdispatcher-DowncastConversionApi.html) object. It contains many properties and methods that can be useful when writing more complex converters.

#### Changing converter priority

In case there are other converters already present, you can prioritize your converter to override the existing ones. To do that, use the `converterPriority` property:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'bold',
        view: 'strong'
    } );

editor.conversion
    .for( 'downcast' )
    .attributeToElement( {
        model: 'bold',
        view: 'b',
        converterPriority: 'high'
    } );
```

In the example above, the first converter has no explicitly set priority hence it assumes default priority, which is `normal`. The second one overrides it by setting the priority to `high`. Using both of these converters at once will result in the `bold` attribute being converted to a `<b>` element.

### Attribute to attribute conversion helper

The `attributeToAttribute()` helper allows registering a converter that handles a specific attribute and converts it to an attribute of a view element.

Usually, when registering converters for elements (for example, by using `elementToElement()` or `elementToStructure()`), you will want to handle their attributes while handling the element itself.

The `attributeToAttribute()` helper comes in handy when for some reason you cannot cover a specific attribute inside the `elementToElement()` helper. For instance, when you are extending someone else’s plugin.

> **Note**
>
> This type of converter helper only works if there is already an element converter provided. Trying to convert to an attribute while there is no receiving view element will cause an error.

#### Basic attribute to attribute conversion

This conversion results in adding an attribute to a view node, basing on an attribute from a model node. For example, `<imageInline src='foo.jpg'></imageInline>` is converted to `<img src='foo.jpg'></img>`.

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: 'source',
        view: 'src'
    } );
```

#### Converting specific model element and attribute

The converter in the example above will convert **all** the `source` model attributes in the document. You can limit its scope by providing the model element name. You achieve it with the following code:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: {
            name: 'imageInline',
            key: 'source'
        },
        view: 'src'
    } );
```

This updated converter will only convert the `source` model attributes present on the `imageInline` model element.

#### Creating a custom view element from a selected list of model values

Once you provide the array in the `model.values` property, the `view` property is expected to be an object with keys matching these values. This is best explained using the example below:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: {
            name: 'styled',
            values: [ 'dark', 'light' ]
        },
        view: {
            dark: {
                key: 'class',
                value: [ 'styled', 'styled-dark' ]
            },
            light: {
                key: 'class',
                value: [ 'styled', 'styled-light' ]
            }
        }
    } );
```

#### Creating a view attribute with a custom value based on the model value

The value of the view attribute can be modified in the converter. Below is a simple mapper that sets the class attribute based on the model attribute value:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: 'styled',
        view: modelAttributeValue => ( {
            key: 'class',
            value: 'styled-' + modelAttributeValue
        } )
    } );
```

It is worth noting that providing a style property in this manner requires the returned `value` to be an object:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: 'lineHeight',
        view: modelAttributeValue => ( {
            key: 'style',
            value: {
                'line-height': modelAttributeValue,
                'border-bottom': '1px dotted #ba2'
            }
        } )
    } );
```

#### Changing converter priority

You can override the existing converters by specifying higher priority, like in the example below:

```js
editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: 'source',
        view: 'href'
    } );

editor.conversion
    .for( 'downcast' )
    .attributeToAttribute( {
        model: 'source',
        view: 'src',
        converterPriority: 'high'
    } );
```

First converter has the default priority, `normal`. The second converter will be called earlier because of its higher priority, thus the `source` model attribute will get converted to `src` view attribute instead of `href`.

### Further reading

Check out the [dedicated guide](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html) with a full list of complementary [upcast conversion helpers](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html).

<a id="ckeditor5/latest/framework/deep-dive/conversion/helpers/intro.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/helpers/intro.html"</a>

## Introduction to conversion helpers

Conversion helpers are functions that let you define how custom HTML markup is converted between the model and the view, without writing low-level converters.

The editor supports a vast amount of the most commonly used HTML elements via [existing editor features](#ckeditor5/latest/features/index.html) out-of-the-box. If your aim is to easily enable common HTML features that are not explicitly supported by the dedicated CKEditor 5 features, use the [General HTML Support feature](#ckeditor5/latest/features/html/general-html-support.html).

There are, however, cases where you might want to provide a rich editing experience for a custom HTML markup. The conversion helpers are the way to achieve that. Read the following guides to learn how to use them.

### Helpers by category

* **[Downcast helpers – model to view conversion](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html)**

* **[Upcast helpers – view to model conversion](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html)**

<a id="ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html"</a>

## Upcast helpers – view to model conversion

This article lists all editor helpers available in the [upcast conversion](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html).

### Element to element conversion helper

Converting a view element to a model element is the most common case of conversion. It is used to handle view elements like `<p>` or `<h1>` which need to be converted to model elements.

With the use of the `elementToElement()` helper, a **single view element** will be converted to a **single model element**. The children of this view element need to have their own converters defined and the engine will recursively convert them and insert into the created model element.

#### Basic element to element conversion

The simplest case of an element to element conversion, where a view element becomes a model element can be achieved by simply providing their names within the converter:

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: 'p',
        model: 'paragraph'
    } );
```

The example above creates a model element `<paragraph>` from every `<p>` view element.

#### Using view element definition

You can limit the view elements that qualify for the conversion by specifying their attributes, like a class name. To achieve it, provide the desired element definition in the `view` property like in the example below:

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: {
            name: 'p',
            classes: 'fancy'
        },
        model: 'fancyParagraph'
    } );
```

Check out the [`ViewElementObjectDefinition` documentation](../../../../api/module_engine_view_elementdefinition-ViewElementObjectDefinition.html) for more details.

#### Creating a model element using a callback

A model element resulting from the conversion can be created manually using a callback provided as a `model` property.

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: {
            name: 'p',
            classes: 'heading'
        },
        model: ( viewElement, { writer } ) => {
            return writer.createElement( 'heading' );
        }
    } );
```

In the example above, the model element is created only from the `<p class="heading">` view element. All other `<p>` elements without the `heading` class name will be filtered out and will not be converted.

The second parameter of the model callback is the [UpcastConversionApi](../../../../api/module_engine_conversion_upcastdispatcher-UpcastConversionApi.html) object, that contains many properties and methods useful when writing more complex converters.

#### Handling view elements with attributes

If the model element depends not only on the view element itself but also on its attributes, you need to specify these attributes in the `view` property.

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: {
            name: 'p',
            attributes: [ 'data-level' ]
        },
        model: ( viewElement, { writer } ) => {
            return writer.createElement( 'heading', { level: viewElement.getAttribute( 'data-level' ) } );
        }
    } );
```

> **Note**
>
> If you forget to specify these attributes, another converter, for example, from the [General HTML Support feature](#ckeditor5/latest/features/html/general-html-support.html), may also handle these attributes resulting in duplicating them in the model.

#### Changing converter priority

In case there are more converters with overlapping `view` patterns already present, you can prioritize your converter to override them. To do so, use the `converterPriority` property:

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: 'div',
        model: 'mainContent',
    } );

editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: 'div',
        model: 'sideContent',
        converterPriority: 'high'
    } );
```

In the above example, the first converter has the default priority, `normal` (no need to set it explicitly). The second one overrides it, having its priority set to `high`. Using both of these converters at once will result in the `<div>` view element being converted to `sideContent`.

Another practical application of this solution is to have your converter act as a fallback when other converters for a given element are not present (for example, a plugin has not been loaded). It can be easily achieved by setting the `converterProperty` to `low`.

### Element to attribute conversion helper

The element to attribute conversion is used to handle formatting view elements like `<b>` or `<span style="font-family: ...">` that need to be converted to text attributes. It is important to note that text formatting such as bold or font size should be represented in the model as text nodes attributes.

> **Note**
>
> In general, the model does not implement a concept of “inline elements” (in the sense in which they are defined by CSS). The only scenarios in which inline elements can be used are self-contained objects such as soft breaks (`<br>`) or inline images.

#### Basic element to attribute conversion

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: 'strong',
        model: 'bold'
    } );
```

In the example above, the view `<strong>CKEditor 5</strong>` will become the `CKEditor 5` model text node with a `bold` attribute set to `true`.

#### Converting attribute in a specific view element

You might want to only convert view elements with a specific class name or other attribute. To achieve it, you can provide [element definition](../../../../api/module_engine_view_elementdefinition-ViewElementDefinition.html)) in the `view` property.

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: {
            name: 'span',
            classes: 'bold'
        },
        model: 'bold'
    } );
```

Check out the [`ViewElementObjectDefinition` documentation](../../../../api/module_engine_view_elementdefinition-ViewElementObjectDefinition.html) for more details.

#### Setting a predefined value to model attribute

You can specify the value a model attribute will take. To achieve it, provide the name of the resulting model attribute as a `key` and its desired value as a `value` in `model` property object:

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: {
            name: 'span',
            classes: [ 'styled', 'styled-dark' ]
        },
        model: {
            key: 'styled',
            value: 'dark'
        }
    } );
```

The code above will convert `<span class="styled styled-dark">CKEditor5</span>` into a model text node `CKEditor5` with the `styled` attribute set to `dark`.

#### Handling attribute values via a callback

In a situation when the value of an attribute needs additional processing (like mapping, filtering, etc.), you can define the `model.value` as a callback.

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: {
            name: 'span',
            styles: {
                'font-size': /[\s\S]+/
            }
        },
        model: {
            key: 'fontSize',
            value: ( viewElement, conversionApi ) => {
                const fontSize = viewElement.getStyle( 'font-size' );
                const value = fontSize.substr( 0, fontSize.length - 2 );

if ( value <= 10 ) {
                    return 'small';
                } else if ( value > 12 ) {
                    return 'big';
                }

return null;
            }
        }
    } );
```

In the above example we turn the numeric `font-size` inline style into either a `small` or `big` model attribute depending on the defined criteria.

#### Changing converter priority

You can override the existing converters by specifying higher priority, like in the example below:

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: 'strong',
        model: 'bold'
    } );

editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: 'strong',
        model: 'important',
        converterPriority: 'high'
    } );
```

In this example, the first converter has the default priority, `normal`. The second one overrides it, having its priority set to `high`. Using both of these converters at once will result in the `<strong>` view element being converted to an `important` model attribute.

### Attribute to attribute conversion helper

The `attributeToAttribute()` helper allows registering a converter that handles a specific attribute and converts it to an attribute of a model element.

Usually, when registering converters for elements (for example, by using `elementToElement()`), you will want to handle their attributes while handling the element itself.

The `attributeToAttribute()` helper comes in handy when, for some reason, you cannot cover a specific attribute inside `elementToElement()`. This may happen, for instance, when you are extending someone else’s plugin.

> **Note**
>
> This type of converter helper only works if there is already an element converter provided. Trying to convert to an attribute while there is no receiving model element will cause an error.

#### Basic attribute to attribute conversion

This conversion results in adding an attribute to a model element, based on an attribute from a view element. For example, the `src` attribute in `<img src="foo.jpg">` will be converted to `source` in `<imageInline source="foo.jpg"></imageInline>`.

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: 'src',
        model: 'source'
    } );
```

Another way of constructing this converter is to provide a `view.key` property. You can see this executed in the example below:

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: {
            key: 'src'
        },
        model: 'source'
    } );
```

Both of these converters will produce the exact same results.

#### Converting specific view element’s attribute

You can limit the element holding the attribute as well as the value of that attributes. Such a converter will be executed only in case of a full match.

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: {
            name: 'p',
            key: 'class',
            value: 'styled-dark'
        },
        model: {
            key: 'styled',
            value: 'dark'
        }
    } );
```

In the example above only the `styled-dark` class of a `<p>` element will be converted to a model attribute `styled` with a predefined value `dark`.

#### Converting view attributes that match a more complex pattern

The pattern provided in a `view` property can be much more elaborate. Besides a string, you can also provide a regexp or a function that takes the attribute value and returns `true` or `false`.

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: {
            key: 'data-style',
            value: /\S+/
        },
        model: 'styled'
    } );
```

In the example above we are utilizing a regular expression to match only a selected `data-style` attribute that has no whitespace characters in its value. Only attributes that match this expression will have their value assigned to a `styled` model attribute.

#### Processing attributes via callback

If the value of an attribute needs additional processing (like mapping, filtering, etc.) you can define the `model.value` as a callback.

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: {
            key: 'class',
            value: /styled-[\S]+/
        },
        model: {
            key: 'styled'
            value: viewElement => {
                const regexp = /styled-([\S]+)/;
                const match = viewElement.getAttribute( 'class' ).match( regexp );

return match[ 1 ];
            }
        }
    } );
```

The converter in the example above will extract the style name from each `class` attribute that starts with `styled-` and will assign it to a model attribute `styled`.

#### Changing converter priority

You can override the existing converters by specifying higher priority, like in the example below:

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: 'src',
        model: 'source'
    } );

editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: 'src',
        model: 'sourceAddress',
        converterPriority: 'high'
    } );
```

First converter has the default `normal` priority. The second converter will be called earlier because of its higher priority, thus the `src` view attribute will get converted to a `sourceAddress` model attribute (instead of `source`).

### Further reading

Check out a [dedicated guide](#ckeditor5/latest/framework/deep-dive/conversion/helpers/downcast.html) with a full list of complementary [downcast conversion helpers](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html).

<a id="ckeditor5/latest/framework/deep-dive/conversion/intro.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/intro.html"</a>

## Introduction to conversion

### What is the conversion?

The [editing engine](#ckeditor5/latest/framework/architecture/editing-engine.html) of CKEditor 5 works on two separate layers – [model](#ckeditor5/latest/framework/architecture/editing-engine.html--model) and [view](#ckeditor5/latest/framework/architecture/editing-engine.html--view). The process of transforming one into the other is called conversion.

#### Upcast conversion

When you load data into the editor, the view is created out of the markup. Then, with the help of the upcast converters, the model is created. Once that is done, the model becomes the editor state. The whole process is called upcast conversion.

#### Downcast conversion

All changes, such as typing or pasting from the clipboard, are applied directly to the model. To update the editing view, e.i. the layer being displayed to the user, the engine transforms these changes in the model to the view. The same process is executed when data needs to be generated (for example, when you copy editor content or use `editor.getData()`). These processes are called editing and downcast conversions.

You can think about upcast and downcast as processes working in opposite directions, ones that are symmetrical to each other.

### Further reading

In the following guides, you will learn how to create the right converter for each case when creating your CKEditor 5 plugin.

* **[Model to view (downcast)](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html)**

The model has to be transformed into the view. Learn how to achieve that by creating downcast converters.

* **[View to model (upcast)](#ckeditor5/latest/framework/deep-dive/conversion/upcast.html)**

Raw data coming into the editor has to be transformed into the model. Learn how to achieve that by creating upcast converters.

* **[Conversion helpers](#ckeditor5/latest/framework/deep-dive/conversion/helpers/intro.html)**

There are plenty of ways to transform data between model and view. To help you do this as efficiently as possible, we provided many functions that speed up this process. This chapter will help you choose the right helper for the job.

* **[Attributes and inline formatting](#ckeditor5/latest/framework/deep-dive/conversion/attributes.html)**

Understand how text attributes map to inline elements, how nesting and merging work, and what to watch for when integrating formatting features.

<a id="ckeditor5/latest/framework/deep-dive/conversion/upcast.html">source file: "ckeditor5/latest/framework/deep-dive/conversion/upcast.html"</a>

## Upcast conversion – view to model

### Introduction

The process of converting the **view** to the **model** is called an **upcast**.

The upcast process conversion happens every time any data is being loaded into the editor.

Incoming data becomes the view which is then converted into the model via registered converters.

> **Note**
>
> If you just want to quickly enable some common HTML tags that are not explicitly supported by the dedicated CKEditor 5 features, you can use the [General HTML Support](#ckeditor5/latest/features/html/general-html-support.html) feature instead of writing your own custom upcast converters.

### Registering a converter

To instruct the engine how to convert a specific view element into a model element, you need to register an **upcast converter** by using the `editor.conversion.for( 'upcast' )` method:

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: 'p',
        model: 'paragraph'
    } );
```

The above converter will handle the conversion of every `<p>` view element to a `<paragraph>` model element.

> **Note**
>
> You have just learnt about the [`elementToElement()` **upcast** conversion helper method](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html--element-to-element-conversion-helper)! More helpers are documented in the following chapters.

### Upcast pipeline

Contrary to the downcast where you deal with both the data and editing pipelines, the upcast process only happens in the data pipeline and is called **data upcast**.

The editing view may be only changed via changing the model first, hence editing pipeline needs only the downcast process.

The previous code example registers a converter for both pipelines at once. It means that a `<paragraph>` model element will be converted to a `<p>` view element in both the **data view** and the **editing view**.

### Converting to text attribute

View elements representing inline text formatting (such as `<strong>` or `<i>`) need to be converted to an attribute on a model text node.

To register such a converter, use the [`elementToAttribute()` method](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html--element-to-attribute-conversion-helper):

```js
editor.conversion
    .for( 'upcast' )
    .elementToAttribute( {
        view: 'strong',
        model: 'bold'
    } );
```

A text wrapped with the `<strong>` tag will be converted to a model text node with a `bold` attribute applied to it, as shown:

If you need to “copy” an attribute from a view element to a model element, use the [`attributeToAttribute()` method](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html--attribute-to-attribute-conversion-helper).

The model element must have its own converter registered, otherwise there is nothing the attribute can be copied to.

```js
editor.conversion
    .for( 'upcast' )
    .attributeToAttribute( {
        view: 'src',
        model: 'source'
    } );
```

Assuming that some other feature registered the `<img>` to `<image>` model element upcast converter in the editor, you can extend this feature to allow the `src` attribute. This attribute will be converted into a `source` attribute on a model element, the way it is shown in the following snippet:

> **Note**
>
> This is just an example. Actually, the image elements and source attributes support is provided by the [images feature](#ckeditor5/latest/features/images/images-overview.html) so you do not have to write your own `<image source="xxx">` to `<img src="xxx">` element conversion.

### Converting to element

Converting a view element to a corresponding model element can be achieved by registering the converter using the [`elementToElement()` method](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html--element-to-element-conversion-helper):

```js
editor.conversion
    .for( 'upcast' )
    .elementToElement( {
        view: {
            name: 'div',
            classes: [ 'example' ]
        },
        model: 'example'
    } );
```

This converter will handle the conversion of every `<div class="example">` view element into an `<example>` model element.

> **Note**
>
> Using your own custom model element requires defining it in the [schema](#ckeditor5/latest/framework/deep-dive/schema.html) first.

### Converting structures

As you have learnt in the [previous chapter](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html), a single model element can be downcast into a structure of multiple view elements.

The opposite process will have to detect that structure (for example, the main element) and convert it into a simple model element.

There is no `structureToElement()` helper available for the upcast conversion. To register an upcast converter for the entire structure and create a single model element, you must use the event-based API. The following example shows how to achieve it:

```js
editor.conversion.for( 'upcast' ).add( dispatcher => {
    // Look for every view <div> element.
    dispatcher.on( 'element:div', ( evt, data, conversionApi ) => {
        // Get all the necessary items from the conversion API object.
        const {
            consumable,
            writer,
            safeInsert,
            convertChildren,
            updateConversionResult
        } = conversionApi;

// Get view item from data object.
        const { viewItem } = data;

// Define elements consumables.
        const wrapper = { name: true, classes: 'wrapper' };
        const innerWrapper = { name: true, classes: 'inner-wrapper' };

// Tests if the view element can be consumed.
        if ( !consumable.test( viewItem, wrapper ) ) {
            return;
        }

// Check if there is only one child.
        if ( viewItem.childCount !== 1 ) {
            return;
        }

// Get the first child element.
        const firstChildItem = viewItem.getChild( 0 );

// Check if the first element is a <div>.
        if ( !firstChildItem.is( 'element', 'div' ) ) {
            return;
        }

// Tests if the first child element can be consumed.
        if ( !consumable.test( firstChildItem, innerWrapper ) ) {
            return;
        }

// Create model element.
        const modelElement = writer.createElement( 'myElement' );

// Insert element on a current cursor location.
        if ( !safeInsert( modelElement, data.modelCursor ) ) {
            return;
        }

// Consume the main outer wrapper element.
        consumable.consume( viewItem, wrapper );
        // Consume the inner wrapper element.
        consumable.consume( firstChildItem, innerWrapper );

// Handle children conversion inside inner wrapper element.
        convertChildren( firstChildItem, modelElement );

// Necessary function call to help setting model range and cursor
        // for some specific cases when elements being split.
        updateConversionResult( modelElement, data );
    } );
} );
```

This converter will detect all `<div class="wrapper"><div class="inner-wrapper"><p>...</p></div></div>` structures (by scanning for the outer `<div>`s and turning those into a single `<myElement>` model element). The effect should return as follows:

> **Note**
>
> Using your own custom model element requires defining it in the [schema](#ckeditor5/latest/framework/deep-dive/schema.html) first.

### Further reading

If you want to learn more about upcast helpers mentioned in this guide, we have [rounded them up](#ckeditor5/latest/framework/deep-dive/conversion/helpers/upcast.html) for you with complete descriptions and examples. We also recommend you to check out the [downcast conversion](#ckeditor5/latest/framework/deep-dive/conversion/downcast.html) guide and learn how to convert the editor model state into data output and editing view.

<a id="ckeditor5/latest/framework/deep-dive/event-system.html">source file: "ckeditor5/latest/framework/deep-dive/event-system.html"</a>

## Event system

[Emitters](../../api/module_utils_emittermixin-Emitter.html) are objects that can fire events. They also provide means to listen to other emitters’ events.

Emitters are heavily used throughout the entire editor architecture. They are the building blocks for mechanisms such as the [observables](#ckeditor5/latest/framework/deep-dive/observables.html), [engine’s view observers](#ckeditor5/latest/framework/architecture/editing-engine.html--observers), and [conversion](#ckeditor5/latest/framework/architecture/editing-engine.html--conversion).

Any class can become an event emitter. All you need to do is mix the [`Emitter`](../../api/module_utils_emittermixin-Emitter.html) into it:

**NPM**

```js
import { EmitterMixin, mix } from 'ckeditor5';

class AnyClass {
	// Class's code.
	// ...
}

mix( AnyClass, EmitterMixin );
```

**CDN**

```js
const { EmitterMixin, mix } = CKEDITOR;

class AnyClass {
	// Class's code.
	// ...
}

mix( AnyClass, EmitterMixin );
```

### Listening to events

Adding a callback to an event is simple. You can listen directly on the emitter object and use an anonymous function:

```js
emitter.on( 'eventName', ( eventInfo, ...args ) => { /* ... */ } );
```

However, a function object is needed if you want to be able to remove the event listener:

```js
emitter.off( 'eventName', handler );
```

There is also another way to add an event listener – by using [`listenTo()`](../../api/module_utils_emittermixin-Emitter.html#function-listenTo:BASE_EMITTER). This way one emitter can listen to events on another emitter:

```js
foo.listenTo( bar, 'eventName', ( eventInfo, ...args ) => { /* ... */ } );
```

Now you can easily detach the `foo` from `bar` simply by [`stopListening()`](../../api/module_utils_emittermixin-Emitter.html#function-stopListening:BASE_STOP).

```js
// Stop listening to a specific handler.
foo.stopListening( bar, 'eventName', handler );

// Stop listening to a specific event.
foo.stopListening( bar, 'eventName' );

// Stop listening to all events fired by a specific emitter.
foo.stopListening( bar );

// Stop listening to all events fired by all bound emitters.
foo.stopListening();
```

> **Note**
>
> The [`on()`](../../api/module_utils_emittermixin-Emitter.html#function-on) and [`off()`](../../api/module_utils_emittermixin-Emitter.html#function-off) methods are shorthands for [`listenTo( this, /* ... */ )`](../../api/module_utils_emittermixin-Emitter.html#function-listenTo:BASE_EMITTER) and [`stopListening( this, /* ... */ )`](../../api/module_utils_emittermixin-Emitter.html#function-stopListening:BASE_STOP) (the emitter is bound to itself).

#### Listener priorities

By default, all listeners are bound on the [`normal`](../../api/module_utils_priorities-PriorityString.html) priority, but you can specify the priority when registering a listener:

```js
this.on( 'eventName', () => { /* ... */ }, { priority: 'high' } );
this.listenTo( emitter, 'eventName', () => { /* ... */ }, { priority: 'high' } );
```

There are 5 named priorities:

* `highest`
* `high`
* `normal`
* `low`
* `lowest`

Listeners are triggered in the order of these priorities (first `highest`, then `high`, etc.). For multiple listeners attached on the same priority, they are fired in the order of the registration.

**Note**: If any listener [stops](../../api/module_utils_eventinfo-EventInfo.html#member-stop) the event, no other listeners including those on lower priorities will be called.

It is possible to use relative priorities [`priorities.get( 'high' ) + 10`](../../api/module_utils_priorities-PrioritiesType.html#function-get) but this is strongly discouraged.

#### Stopping events and returned value

The first argument passed to an event handler is always an instance of the [`EventInfo`](../../api/module_utils_eventinfo-EventInfo.html). There you can check the event [`name`](../../api/module_utils_eventinfo-EventInfo.html#member-name), the [`source` emitter](../../api/module_utils_eventinfo-EventInfo.html#member-source) of the event, and you can [`stop()`](../../api/module_utils_eventinfo-EventInfo.html#member-stop) the event from further processing.

```js
emitter.on( 'eventName', ( eventInfo, data ) => {
    console.log( 'foo' );
    eventInfo.stop();
} );

emitter.on( 'eventName', ( eventInfo, data ) => {
    console.log( 'bar' ); // This won't be called.
} );

emitter.fire( 'eventName' ); // Logs "foo" only.
```

Listeners can set the [`return`](../../api/module_utils_eventinfo-EventInfo.html#member-return) value. This value will be returned by [`fire()`](../../api/module_utils_emittermixin-Emitter.html#function-fire) after all callbacks are processed.

```js
emitter.on( 'eventName', ( eventInfo, data ) => {
    eventInfo.return = 123;
} );

emitter.fire( 'eventName' ); // -> 123
```

#### Listening on namespaced events

The event system supports namespaced events to give you the possibility to build a structure of callbacks. You can achieve namespacing by using `:` in the event name:

```js
this.fire( 'foo:bar:baz', data );
```

Then the listeners can be bound to a specific event or the whole namespace:

```js
this.on( 'foo', () => { /* ... */ } );
this.on( 'foo:bar', () => { /* ... */ } );
this.on( 'foo:bar:baz', () => { /* ... */ } );
```

This way you can have more general events, listening to a broader event (`'foo'` in this case), or more detailed callbacks listening to specified events (`'foo:bar'` or `'foo:bar:baz'`).

This mechanism is used for instance in the conversion, where thanks to events named `'insert:<elementName>'` you can listen to the insertion of a specific element (like `'insert:p'`) or all elements insertion (`'insert'`).

**Note**: Listeners registered on the same priority will be fired in the order of the registration (no matter if listening to a whole namespace or to a specific event).

### Firing events

Once you mix the [`Emitter`](../../api/module_utils_emittermixin-Emitter.html) into your class, you can fire events the following way:

```js
this.fire( 'eventName', argA, argB, /* ... */ );
```

All passed arguments will be available in all listeners that are added to the event.

**Note**: Most base classes (like [`Command`](../../api/module_core_command-Command.html) or [`Plugin`](../../api/module_core_plugin-Plugin.html)) are [emitters](../../api/module_utils_emittermixin-Emitter.html) already and fire their own events.

#### Stopped events

It is sometimes useful to know if an event was stopped by any of the listeners. There is an alternative way of firing an event just for that:

**NPM**

```js
import { EventInfo } from 'ckeditor5';

// Prepare the event info...
const eventInfo = new EventInfo( this, 'eventName' );

// ...and fire the event.
this.fire( eventInfo, argA, argB, /* ... */ );

// Here you can check if the event was stopped.
if ( eventInfo.stop.called ) {
	// The event was stopped.
}
```

**CDN**

```js
const { EventInfo } = CKEDITOR;

// Prepare the event info...
const eventInfo = new EventInfo( this, 'eventName' );

// ...and fire the event.
this.fire( eventInfo, argA, argB, /* ... */ );

// Here you can check if the event was stopped.
if ( eventInfo.stop.called ) {
	// The event was stopped.
}
```

Note that [`EventInfo`](../../api/module_utils_eventinfo-EventInfo.html) expects the source object in the first parameter as the origin of the event.

#### Event return value

If any handler set the [`eventInfo.return`](../../api/module_utils_eventinfo-EventInfo.html#member-return) field, this value will be returned by [`fire()`](../../api/module_utils_emittermixin-Emitter.html#function-fire) after all callbacks are processed.

```js
emitter.on( 'eventName', ( eventInfo, ...args ) => {
    eventInfo.return = 123;
} );

const result = emitter.fire( 'eventName', argA, argB, /* ... */ );

console.log( result ); // -> 123
```

### Delegating events

The [`Emitter`](../../api/module_utils_emittermixin-Emitter.html) interface also provides the [event delegation](../../api/module_utils_emittermixin-Emitter.html#function-delegate) mechanism, so that selected events are fired by another [`Emitter`](../../api/module_utils_emittermixin-Emitter.html).

#### Setting events delegation

Delegate specific events to another emitter:

```js
emitterA.delegate( 'foo' ).to( emitterB );
emitterA.delegate( 'foo', 'bar' ).to( emitterC );
```

You can delegate events with a different name:

```js
emitterA.delegate( 'foo' ).to( emitterB, 'bar' );
emitterA.delegate( 'foo' ).to( emitterB, name => `delegated:${ name }` );
```

It is also possible to delegate all the events:

```js
emitterA.delegate( '*' ).to( emitterB );
```

**Note**: Delegated events are fired from the target emitter no matter if they were stopped in any handler on the source emitter.

#### Stopping delegation

You can stop delegation by calling the [`stopDelegating()`](../../api/module_utils_emittermixin-Emitter.html#function-stopDelegating) method. It can be used at different levels:

```js
// Stop delegating all events.
emitterA.stopDelegating();

// Stop delegating a specific event to all emitters.
emitterA.stopDelegating( 'foo' );

// Stop delegating a specific event to a specific emitter.
emitterA.stopDelegating( 'foo', emitterB );
```

#### Delegated event info

The delegated events provide the [`path`](../../api/module_utils_eventinfo-EventInfo.html#member-path) of emitters that this event met along the delegation path.

```js
emitterA.delegate( 'foo' ).to( emitterB, 'bar' );
emitterB.delegate( 'bar' ).to( emitterC, 'baz' );

emitterA.on( 'foo', eventInfo => console.log( 'event', eventInfo.name, 'emitted by A; source:', eventInfo.source, 'path:', eventInfo.path ) );
emitterB.on( 'bar', eventInfo => console.log( 'event', eventInfo.name, 'emitted by B; source:', eventInfo.source, 'path:', eventInfo.path ) );
emitterC.on( 'baz', eventInfo => console.log( 'event', eventInfo.name, 'emitted by C; source:', eventInfo.source, 'path:', eventInfo.path ) );

emitterA.fire( 'foo' );

// Outputs:
//   event "foo" emitted by A; source: emitterA; path: [ emitterA ]
//   event "bar" emitted by B; source: emitterA; path: [ emitterA, emitterB ]
//   event "baz" emitted by C; source: emitterA; path: [ emitterA, emitterB, emitterC ]
```

### View events bubbling

The [`view.Document`](../../api/module_engine_view_document-ViewDocument.html) is not only an [Observable](../../api/module_utils_observablemixin-Observable.html) and an [emitter](../../api/module_utils_emittermixin-Emitter.html) but it also implements the special [`BubblingEmitter`](../../api/module_engine_view_observer_bubblingemittermixin-BubblingEmitter.html) interface (implemented by [`BubblingEmitterMixin`](../../api/module_engine_view_observer_bubblingemittermixin.html#function-BubblingEmitterMixin)). It provides a mechanism for bubbling events over the virtual DOM tree.

It is different from the bubbling that you know from the DOM tree event bubbling. You do not register listeners on specific instances of the elements in the view document tree. Instead, you can register handlers for specific contexts. A context is either a name of an element, or one of the virtual contexts (`'$capture'`, `'$text'`, `'$root'`, `'$document'`), or a callback to match desired nodes.

#### Listening to bubbling events

Listeners registered in the context of the view element names:

```js
this.listenTo( view.document, 'enter', ( evt, data ) => {
    // Listener's code.
    // ...
}, { context: 'blockquote' } );

this.listenTo( view.document, 'enter', ( evt, data ) => {
    // Listener's code.
    // ...
}, { context: 'li' } );
```

Listeners registered in the virtual contexts:

```js
this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
    // Listener's code.
    // ...
}, { context: '$text', priority: 'high' } );

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
    // Listener's code.
    // ...
}, { context: '$root' } );

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
    // Listener's code.
    // ...
}, { context: '$capture' } );
```

Listeners registered in the context of a custom callback function:

**NPM**

```js
import { isWidget } from 'ckeditor5';

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
	// Listener's code.
	// ...
}, { context: isWidget } );

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
	// Listener's code.
	// ...
}, { context: isWidget, priority: 'high' } );
```

**CDN**

```js
const { isWidget } = CKEDITOR;

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
	// Listener's code.
	// ...
}, { context: isWidget } );

this.listenTo( view.document, 'arrowKey', ( evt, data ) => {
	// Listener's code.
	// ...
}, { context: isWidget, priority: 'high' } );
```

**Note**: Without specifying the `context`, events are bound to the `'$document'` context.

#### Bubbling events flow

Bubbling always starts from the virtual `'$capture'` context. All listeners attached to this context are triggered first (and in the order of their priorities).

Then, the real bubbling starts from the selection position (either its anchor or focus – depending on what is deeper).

If text nodes are allowed at the selection position, then the first context is `'$text'`. Then the event bubbles through all elements up to the `'$root'` and finally `'$document'`.

In all contexts listeners can be registered at desired priorities. If a listener stops an event, this event is not fired for the remaining contexts.

#### Examples

Assuming the given content and selection:

```html
<blockquote>
    <p>
        Foo[]bar
    </p>
</blockquote>
```

Events will be fired for the following contexts:

1. `'$capture'`
2. `'$text'`
3. `'p'`
4. `'blockquote'`
5. `'$root'`
6. `'$document'`

Assuming the given content and selection (on a widget):

```html
<blockquote>
    <p>
        Foo
        [<img />]	// enhanced with toWidget()
        bar
    </p>
</blockquote>
```

Events will be fired for the following contexts:

1. `'$capture'`
2. `'img'`
3. _widget_ (assuming a custom matcher was used)
4. `'p'`
5. `'blockquote'`
6. `'$root'`
7. `'$document'`

An even more complex example:

```html
<blockquote>
    <figure class="table">	// enhanced with toWidget()
        <table>
            <tr>
                <td>
                    <p>
                        foo[]bar
                    </p>
                </td>
            </tr>
        </table>
    </figure>
</blockquote>
```

Events that will be fired:

1. `'$capture'`
2. `'$text'`
3. `'p'`
4. `'td'`
5. `'tr'`
6. `'table'`
7. `'figure'`
8. _widget_ (assuming a custom matcher was used)
9. `'blockquote'`
10. `'$root'`
11. `'$document'`

#### `BubblingEventInfo`

In some events the first parameter is not the standard `EventInfo`, but [`BubblingEventInfo`](../../api/module_engine_view_observer_bubblingeventinfo-BubblingEventInfo.html). This is an extension that provides the current [`eventPhase`](../../api/module_engine_view_observer_bubblingeventinfo-BubblingEventInfo.html#member-eventPhase) and [`currentTarget`](../../api/module_engine_view_observer_bubblingeventinfo-BubblingEventInfo.html#member-currentTarget).

Currently, this information is available for the following events:

* [`enter`](../../api/module_engine_view_document-ViewDocument.html#event-enter),
* [`delete`](../../api/module_engine_view_document-ViewDocument.html#event-delete),
* [`arrowKey`](../../api/module_engine_view_document-ViewDocument.html#event-arrowKey).

Hence the events from the above example would be extended with the following `eventPhase` data:

1. `'$capture'` - _capturing_
2. `'$text'` - _at target_
3. `'p'` - _bubbling_
4. `'td'` - _bubbling_
5. `'tr'` - _bubbling_
6. `'table'` - _bubbling_
7. `'figure'` - _bubbling_
8. _widget_ - _bubbling_
9. `'blockquote'` - _bubbling_
10. `'$root'` - _bubbling_
11. `'$document'` - _bubbling_

And for the example with the widget selected:

```html
<blockquote>
    <p>
        Foo
        [<img />]	 // Enhanced with toWidget().
        bar
    </p>
</blockquote>
```

Events that will be fired:

1. `'$capture'` - _capturing_
2. `'img'` - _at target_
3. _widget_ - _at target_ (assuming a custom matcher was used)
4. `'p'` - _bubbling_
5. `'blockquote'` - _bubbling_
6. `'$root'` - _bubbling_
7. `'$document'` - _bubbling_

<a id="ckeditor5/latest/framework/deep-dive/observables.html">source file: "ckeditor5/latest/framework/deep-dive/observables.html"</a>

## Observables

[Observables](../../api/module_utils_observablemixin-Observable.html) are objects which have properties that can be observed. That means when the value of such property changes, an event is fired by the observable and the change can be reflected in other pieces of the code that listen to that event.

Observables are common building blocks of the [CKEditor 5 Framework](#ckeditor5/latest/framework/index.html). They are particularly popular in the UI, the [`View`](../../api/module_ui_view-View.html) class and its subclasses benefiting from the observable interface the most: it is the [templates bound to the observables](#ckeditor5/latest/framework/architecture/ui-library.html--interaction) what makes the user interface dynamic and interactive. Some of the basic classes like [`Editor`](../../api/module_core_editor_editor-Editor.html) or [`Command`](../../api/module_core_command-Command.html) are observables too.

Any class can become observable; all you need to do is mix the [`Observable`](../../api/module_utils_observablemixin-Observable.html) into it:

**NPM**

```js
import { ObservableMixin, mix } from 'ckeditor5';

class AnyClass {
	// Any class definition.
	// ...
}

mix( AnyClass, ObservableMixin );
```

**CDN**

```js
const { ObservableMixin, mix } = CKEDITOR;

class AnyClass {
	// Any class definition.
	// ...
}

mix( AnyClass, ObservableMixin );
```

Observables are useful when it comes to managing the state of the application, which can be dynamic and, more often than not, centralized and shared between components of the application. One observable can also propagate its state (or its part) to another using [property bindings](#ckeditor5/latest/framework/deep-dive/observables.html--property-bindings).

Observables can also [decorate their methods](#ckeditor5/latest/framework/deep-dive/observables.html--decorating-object-methods) which makes it possible to control their execution using event listeners, giving external code some control over their behavior.

> **Note**
>
> Since the observables are just another layer on top of the event [emitters](../../api/module_utils_emittermixin-Emitter.html), check out the [event system deep dive guide](#ckeditor5/latest/framework/deep-dive/event-system.html) to learn more about the advanced usage of events with some additional examples.

### Making properties observable

Having mixed the [`Observable`](../../api/module_utils_observablemixin-Observable.html) into your class, you can define observable properties. To do that, use the [`set()` method](../../api/module_utils_observablemixin-Observable.html#function-set:KEY_VALUE).

Let’s create a simple UI view (component) named `Button` with a couple of properties and see what they look like:

```js
class Button extends View {
    constructor() {
        super();

// This property is not observable.
        // Not all properties must be observable, it's always up to you!
        this.type = 'button';

const bind = this.bindTemplate;

// this.label is observable but undefined.
        this.set( 'label' );

// this.isOn is observable and false.
        this.set( 'isOn', false );

// this.isEnabled is observable and true.
        this.set( 'isEnabled', true );

// More observable's properties.
        // ...
    }
}
```

Note that because `Button` extends the [`View`](../../api/module_ui_view-View.html) class (which is already observable), you do not need to mix the `ObservableMixin`.

> **Note**
>
> The `set()` method can accept an object of key/value pairs to shorten the code. Knowing that, making properties observable can be as simple as:
>
> ```js
> this.set( {
>     label: undefined,
>     isOn: false,
>     isEnabled: true
> } );
> ```

Finally, let’s create a new view and see how it communicates with the world.

Each time the `label` property changes, the view fires the `change:label` event containing information about its state in the past and the new value. The `change:isEnabled` and `change:isOn` events will be fired for changes of `isEnabled` and `isOn`, respectively.

```js
const view = new Button();

view.on( 'change:label', ( evt, propertyName, newValue, oldValue ) => {
    console.log(
        `#${ propertyName } has changed from "${ oldValue }" to "${ newValue }"`
    );
} )

view.label = 'Hello world!'; // -> #label has changed from "undefined" to "Hello world!"
view.label = 'Bold'; // -> #label has changed from "Hello world!" to "Bold"

view.type = 'submit'; // Changing a regular property fires no event.
```

The events fired by the view are used to update the DOM and make the component dynamic. Let’s give our view some template and bind it to the observable properties we created.

> **Note**
>
> You can learn more about the UI of the editor and template system in the dedicated [guide](#ckeditor5/latest/framework/architecture/ui-library.html--templates).

```js
class Button extends View {
    constructor() {
        super();

// Previously defined properties.
        // ...

// This template will have the following symbolic representation in DOM:
        //
        // 	<button class="[ck-disabled] ck-[on|off]" type="button">
        // 		{{ this.label }}
        // 	</button>
        //
        this.setTemplate( {
            tag: 'button',
            attributes: {
                class: [
                    // The 'ck-on' and 'ck-off' classes toggle according to the #isOn property.
                    bind.to( 'isOn', value => value ? 'ck-on' : 'ck-off' ),

// The 'ck-enabled' class appears when the #isEnabled property is false.
                    bind.if( 'isEnabled', 'ck-disabled', value => !value )
                ],
                type: this.type
            },
            children: [
                {
                    // The text of the button is bound to the #label property.
                    text: bind.to( 'label' )
                }
            ]
        } );
    }
}
```

Because `label`, `isOn`, and `isEnabled` are observables, any change will be immediately reflected in DOM:

```js
const button = new Button();

// Render the button to create its #element.
button.render();

button.label = 'Bold';     // <button class="ck-off" type="button">Bold</button>
button.isOn = true;        // <button class="ck-on" type="button">Bold</button>
button.label = 'B';        // <button class="ck-on" type="button">B</button>
button.isOff = false;      // <button class="ck-off" type="button">B</button>
button.isEnabled = false;  // <button class="ck-off ck-disabled" type="button">B</button>
```

### Property bindings

One observable can also propagate its state (or part of it) to another observable to simplify the code, for example, to avoid many `change:property` event listeners. To start binding object properties, make sure both objects (classes) mix the [`Observable`](../../api/module_utils_observablemixin-Observable.html), then use the [`bind()`](../../api/module_utils_observablemixin-Observable.html#function-bind:SINGLE_BIND) method to create the binding.

#### Simple bindings

Use the bold button instance from the previous section and bind it to the bold command. That will let the button use certain command properties and automate the user interface in just a couple of lines.

The bold command is an actual command of the editor (registered by the [`BoldEditing`](../../api/module_basic-styles_bold_boldediting-BoldEditing.html)) and offers two observable properties: `value` and `isEnabled`. To get the command, use `editor.commands.get( 'bold' )`.

Note that both `Button` and [`Command`](../../api/module_core_command-Command.html) classes are [observable](../../api/module_utils_observablemixin-Observable.html), which is why you can bind their properties.

```js
const button = new Button();
const command = editor.commands.get( 'bold' );
```

Any “decent” button must update its look when the command becomes disabled. A simple property binding doing that could look as follows:

```js
button.bind( 'isEnabled' ).to( command );
```

After that:

* `button.isEnabled` **instantly equals** `command.isEnabled`,
* whenever `command.isEnabled` changes, `button.isEnabled` will immediately reflect its value,
* because the template of the button has its class bound to `button.isEnabled`, the DOM element of the button will also be updated.

Note that `command.isEnabled` **must** be defined using the `set()` method for the binding to be dynamic. In this case we are lucky because [`isEnabled`](../../api/module_core_command-Command.html#member-isEnabled) is a standard observable property of every command in the editor. But keep in mind that when you create your own observable class, using `set()` method is the only way to define observable properties.

##### Renaming properties

Now let’s dive into the `bind( /* ... */ ).to( /* ... */ )` syntax for a minute. As a matter of fact, the last example corresponds to the following code:

```js
const button = new Button();
const command = editor.commands.get( 'bold' );

button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```

You probably noticed the `to( /* ... */ )` interface which helps specify the name of the property (or just “rename” the property in the binding).

Both `Button` and `Command` class share the same `isEnabled` property, which allowed us to shorten the code. But if we decided to bind the `Button#isOn` to the `Command#value`, the code would be as follows:

```js
button.bind( 'isOn' ).to( command, 'value' );
```

The property has been “renamed” in the binding and from now on, whenever `command.value` changes, the value of `button.isOn` will reflect it.

##### Processing a property value

Another use case is processing the bound property value, for instance, when a button should be disabled only if certain conditions are met. Passing a callback as the third parameter allows implementing a custom logic.

In the example below, the `isEnabled` property will be set to `true` only when `command.value` equals `'heading1'`.

```js
const command = editor.commands.get( 'heading' );
button.bind( 'isOn' ).to( command, 'value', value => value === 'heading1' );
```

#### Binding multiple properties

It is possible to bind more that one property at a time to simplify the code:

```js
const button = new Button();
const command = editor.commands.get( 'bold' );

button.bind( 'isOn', 'isEnabled' ).to( command, 'value', 'isEnabled' );
```

which is the same as:

```js
button.bind( 'isOn' ).to( command, 'value' );
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```

In the above binding, the value of `button.isEnabled` will reflect `command.isEnabled` and the value of `button.isOn` will reflect `command.value`.

Note that the `value` property of the command has also been “renamed” in the binding like in the [previous example](#ckeditor5/latest/framework/deep-dive/observables.html--renaming-properties).

#### Binding with multiple observables

The binding can include more than one observable, combining multiple properties in a custom callback function. Let’s create a button that gets enabled only when the `command` is enabled and the [editing document](../../api/module_engine_view_document-ViewDocument.html) (also an `Observable`) is focused:

```js
const button = new Button();
const command = editor.commands.get( 'bold' );
const editingDocument = editor.editing.view.document;

button.bind( 'isEnabled' ).to( command, 'isEnabled', editingDocument, 'isFocused',
    ( isCommandEnabled, isDocumentFocused ) => isCommandEnabled && isDocumentFocused );
```

The binding makes the value of `button.isEnabled` depend both on `command.isEnabled` and `editingDocument.isFocused` as specified by the function: both must be `true` for the button to become enabled.

#### Binding with an array of observables

It is possible to bind the same property to an array of observables. Let’s bind our button to multiple commands so that each and every one must be enabled for the button to become enabled:

```js
const button = new Button();
const commands =  [ commandA, commandB, commandC ];

button.bind( 'isEnabled' ).toMany( commands, 'isEnabled', ( isAEnabled, isBEnabled, isCEnabled ) => {
    return isAEnabled && isBEnabled && isCEnabled;
} );
```

The binding can be simplified using the spread operator (`...`) and the `Array.every()` method:

```js
const commands =  [ commandA, commandB, commandC ];

button.bind( 'isEnabled' ).toMany( commands, 'isEnabled', ( ...areEnabled ) => {
    return areEnabled.every( isCommandEnabled => isCommandEnabled );
} );
```

This kind of binding can be useful, for example, when a button opens a dropdown containing some other commands’ buttons and it should be disabled when none of the commands is enabled.

#### Releasing the bindings

If you do not want your object’s properties to be bound any longer, you can use the [`unbind()`](../../api/module_utils_observablemixin-Observable.html#function-unbind) method.

You can specify the names of the properties to selectively unbind them

```js
const button = new Button();
const command = editor.commands.get( 'bold' );

button.bind( 'isOn', 'isEnabled' ).to( command, 'value', 'isEnabled' );

// More bindings.
// ...

// From now on, button#isEnabled is no longer bound to the command.
button.unbind( 'isEnabled' );
```

or you can dismiss all bindings by calling the method without arguments

```js
const button = new Button();
const command = editor.commands.get( 'bold' );

button.bind( 'isOn', 'isEnabled' ).to( command, 'value', 'isEnabled' );

// More bindings.
// ...

// Both #isEnabled and #isOn properties are independent back again.
// They will retain the last values determined by the bindings, though.
button.unbind();
```

### Decorating object methods

Decorating object methods transforms them into event–driven ones without changing their original behavior.

When a method is decorated, an event of the same name is created and fired each time the method is executed. By listening to the event it is possible to cancel the execution, change the arguments or the value returned by the method. This offers an additional flexibility, for example, giving a third–party code some way to interact with core classes that decorate their methods.

Decorating is possible using the [`decorate()`](../../api/module_utils_observablemixin-Observable.html#function-decorate) method. Decorate a `focus` method of a `Button` class you created in the [previous sections](#ckeditor5/latest/framework/deep-dive/observables.html--making-properties-observable) and see what if offers:

```js
class Button extends View {
    constructor() {
        // Setting the template and bindings.
        // ...

this.decorate( 'focus' );
    }

/**
    * Focuses the button.
    *
    * @param {Boolean} force When `true`, the button will be focused again, even if already
    * focused in DOM.
    * @returns {Boolean} `true` when the DOM element was focused in DOM, `false` otherwise.
    */
    focus( force ) {
        console.log( `Focusing button, force argument="${ force }"` );

// Unless forced, the button will only focus when not already focused.
        if ( force || document.activeElement != this.element ) {
            this.element.focus();

return true;
        }

return false;
    }
}
```

#### Cancelling the execution

Because the `focus()` method is now event–driven, it can be controlled externally. For example, the focusing could be stopped for certain arguments. Note the `high` listener [priority](../../api/module_utils_priorities-PriorityString.html) used to intercept the default action:

```js
const button = new Button();

// Render the button to create its #element.
button.render();

// The logic controlling the behavior of the button.
button.on( 'focus', ( evt, [ isForced ] ) => {
    // Disallow forcing the focus of this button.
    if ( isForced === true ) {
        evt.stop();
    }
}, { priority: 'high' } );

button.focus(); // -> 'Focusing button, force argument="undefined"'
button.focus( true ); // Nothing is logged, the execution has been stopped.
```

#### Changing the returned value

It is possible to control the returned value of a decorated method using an event listener. The returned value is passed in the event data as a `return` property:

```js
const button = new Button();

// Render the button to create its #element.
button.render();

// The logic controlling the behavior of the button.
button.on( 'focus', ( evt, [ isForced ] ) => {
    // Pretend the button wasn't focused if the focus was forced.
    if ( isForced === true ) {
        evt.return = false;
    }
} );

console.log( button.focus() ); // -> true
console.log( button.focus( true ) ); // -> false
```

#### Changing arguments on the fly

Just like the returned value, the arguments passed to the method can be changed in the event listener. Note the `high` listener [priority](../../api/module_utils_priorities-PriorityString.html) of the used to intercept the default action:

```js
const button = new Button();

// Render the button to create its #element.
button.render();

// The logic controlling the behavior of the button.
button.on( 'focus', ( evt, args ) => {
    // Always force the focus.
    args[ 0 ] = true;
}, { priority: 'high' } );

button.focus(); // -> 'Focusing button, force="true"'
button.focus( true ); // -> 'Focusing button, force="true"'
```

<a id="ckeditor5/latest/framework/deep-dive/schema.html">source file: "ckeditor5/latest/framework/deep-dive/schema.html"</a>

## Schema

The editor’s schema is available in the [`editor.model.schema`](../../api/module_engine_model_model-Model.html#member-schema) property. It defines allowed model structures (how model elements can be nested), allowed attributes (of both elements and text nodes), and other characteristics (inline vs. block, atomicity in regards of external actions). This information is later used by editing features and the editing engine to decide how to process the model, where to enable features, etc.

Schema rules can be defined by using the [`Schema#register()`](../../api/module_engine_model_schema-ModelSchema.html#function-register) or the [`Schema#extend()`](../../api/module_engine_model_schema-ModelSchema.html#function-extend) methods. The former can be used only once for a given item name which ensures that only a single editing feature can introduce this item. Similarly, `extend()` can only be used for defined items.

Elements and attributes are checked by features separately by using the [`Schema#checkChild()`](../../api/module_engine_model_schema-ModelSchema.html#function-checkChild) and the [`Schema#checkAttribute()`](../../api/module_engine_model_schema-ModelSchema.html#function-checkAttribute) methods.

This article assumes that you have already read the [“Schema”](#ckeditor5/latest/framework/architecture/editing-engine.html--schema) section of the [introduction to the editing engine architecture](#ckeditor5/latest/framework/architecture/editing-engine.html).

### Defining allowed structures

When a feature introduces a model element, it should register it in the schema. Besides defining that such an element may exist in the model, the feature also needs to define where this element can be placed. This information is provided by the [`allowIn`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-allowIn) property of the [`ModelSchemaItemDefinition`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html):

```js
schema.register( 'myElement', {
    allowIn: '$root'
} );
```

This lets the schema know that `<myElement>` can be a child of `<$root>`. The `$root` element is one of the generic nodes defined by the editing framework. By default, the editor names the main root element a `<$root>`, so the above definition allows `<myElement>` in the main editor element.

In other words, this would be correct:

```xml
<$root>
    <myElement></myElement>
</$root>
```

While this would be incorrect:

```xml
<$root>
    <foo>
        <myElement></myElement>
    </foo>
</$root>
```

To declare which nodes are allowed inside the registered element, the [`allowChildren`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-allowChildren) property could be used:

```js
schema.register( 'myElement', {
    allowIn: '$root',
    allowChildren: '$text'
} );
```

To allow the following structure:

```xml
<$root>
    <myElement>
        foobar
    </myElement>
</$root>
```

Both the `allowIn` and `allowChildren` properties can also be inherited from other `SchemaItemDefinition` items.

> **Note**
>
> You can read more about the format of the item definition in the [`ModelSchemaItemDefinition`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html) API guide.

### Disallowing structures

The schema, in addition to allowing certain structures, can also be used to ensure some structures are explicitly disallowed. This can be achieved with the use of disallow rules.

Typically, you will use [`disallowChildren`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-disallowChildren) property for that. It can be used to define which nodes are disallowed inside given element:

```js
schema.register( 'myElement', {
    inheritAllFrom: '$block',
    disallowChildren: 'imageInline'
} );
```

In the example above, a new custom element should behave like any block element (paragraph, heading, etc.) but it should not be possible to insert inline images inside it.

#### Precedence over allow rules

In general, all `disallow` rules have higher priority than their `allow` counterparts. When we also take inheritance into the picture, the hierarchy of rules looks like this (from the highest priority):

1. `disallowChildren` / `disallowIn` from the element’s own definition.
2. `allowChildren` / `allowIn` from the element’s own definition.
3. `disallowChildren` / `disallowIn` from the inherited element’s definition.
4. `allowChildren` / `allowIn` from the inherited element’s definition.

#### Disallow rules examples

While disallowing is easy to understand for simple cases, things might start to get unclear when more complex rules are involved. Below are some examples explaining how disallowing works when rules inheriting is involved.

```js
schema.register( 'baseChild' );
schema.register( 'baseParent', { allowChildren: [ 'baseChild' ] } );

schema.register( 'extendedChild', { inheritAllFrom: 'baseChild' } );
schema.register( 'extendedParent', { inheritAllFrom: 'baseParent', disallowChildren: [ 'baseChild' ] } );
```

In this case, `extendedChild` will be allowed in `baseParent` (thanks to inheriting from `baseChild`) and in `extendedParent` (as it inherits `baseParent`).

However, `baseChild` will be allowed only in `baseParent`. Although `extendedParent` inherits all rules from `baseParent`, it specifically disallows `baseChild` as part of its definition.

Below is a different example, where instead `baseChild` is extended with `disallowIn` rule:

```js
schema.register( 'baseParent' );
schema.register( 'baseChild', { allowIn: 'baseParent' } );

schema.register( 'extendedParent', { inheritAllFrom: 'baseParent' } );
schema.register( 'extendedChild', { inheritAllFrom: 'baseChild' } );
schema.extend( 'baseChild', { disallowIn: 'extendedParent' } );
```

This changes how schema rules are resolved. `baseChild` will still be disallowed in `extendedParent` as before. But now, `extendedChild` will be disallowed in `extendedParent` as well. That is because it will inherit this rule from `baseChild`, and there is no other rule that would allow `extendedChild` in `extendedParent`.

Of course, you can mix `allowIn` with `disallowChildren` as well as `allowChildren` with `disallowIn`.

Finally, a situation may come up, when you want to inherit from an item which is already disallowed, but the new element should be re-allowed again. In this case, the definitions should look like this:

```js
schema.register( 'baseParent', { inheritAllFrom: 'paragraph', disallowChildren: [ 'imageInline' ] } );
schema.register( 'extendedParent', { inheritAllFrom: 'baseParent', allowChildren: [ 'imageInline' ] } );
```

Here, `imageInline` is allowed in paragraph, but will not be allowed in `baseParent`. However, `extendedParent` will again re-allow it, as own definitions are more important than inherited definitions.

### Defining additional semantics

In addition to setting allowed structures, the schema can also define additional traits of model elements. By using the `is*` properties, a feature author may declare how a certain element should be treated by other features and by the engine.

Here is a table listing various model elements and their properties registered in the schema:

| Schema entry        | Properties in the [definition](#ckeditor5/latest/framework/deep-dive/schema.html--defining-allowed-structures) |                                                                                |                                                                                  |                                                                                  |                                                                                          |                                                                                    |
| ------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
|                     | [`isBlock`](#ckeditor5/latest/framework/deep-dive/schema.html--block-elements)                                 | [`isLimit`](#ckeditor5/latest/framework/deep-dive/schema.html--limit-elements) | [`isObject`](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) | [`isInline`](#ckeditor5/latest/framework/deep-dive/schema.html--inline-elements) | [`isSelectable`](#ckeditor5/latest/framework/deep-dive/schema.html--selectable-elements) | [`isContent`](#ckeditor5/latest/framework/deep-dive/schema.html--content-elements) |
| `$block`            | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$container`        | ❌                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$blockObject`      | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `$inlineObject`     | ❌                                                                                                              | ✅                                                                              | ✅                                                                                | ✅                                                                                | ✅                                                                                        | ✅                                                                                  |
| `$clipboardHolder`  | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$documentFragment` | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$marker`           | ❌                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$root`             | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$inlineRoot`       | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `$text`             | ❌                                                                                                              | ❌                                                                              | ❌                                                                                | ✅                                                                                | ❌                                                                                        | ✅                                                                                  |
| `blockQuote`        | ❌                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `bookmark`          | ❌                                                                                                              | ✅                                                                              | ✅                                                                                | ✅                                                                                | ✅                                                                                        | ✅                                                                                  |
| `caption`           | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `codeBlock`         | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `heading1`          | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `heading2`          | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `heading3`          | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `horizontalLine`    | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `imageBlock`        | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `imageInline`       | ❌                                                                                                              | ✅                                                                              | ✅                                                                                | ✅                                                                                | ✅                                                                                        | ✅                                                                                  |
| `listItem`          | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `media`             | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `mergeField`        | ❌                                                                                                              | ✅                                                                              | ✅                                                                                | ✅                                                                                | ✅                                                                                        | ✅                                                                                  |
| `mergeFieldBlock`   | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `pageBreak`         | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `paragraph`         | ✅                                                                                                              | ❌                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `rawHtml`           | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `softBreak`         | ❌                                                                                                              | ❌                                                                              | ❌                                                                                | ✅                                                                                | ❌                                                                                        | ❌                                                                                  |
| `table`             | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |
| `tableRow`          | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `tableCell`         | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ✅                                                                                        | ❌                                                                                  |
| `tableColumn`       | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `tableColumnGroup`  | ❌                                                                                                              | ✅                                                                              | ❌                                                                                | ❌                                                                                | ❌                                                                                        | ❌                                                                                  |
| `tableOfContents`   | ✅                                                                                                              | ✅                                                                              | ✅                                                                                | ❌                                                                                | ✅                                                                                        | ✅                                                                                  |

> **Note**
>
> Object elements, including `$blockObject`, `$inlineObject`, `bookmark`, `horizontalLine`, `imageBlock`, `imageInline`, `media`, `mergeField`, `mergeFieldBlock`, `pageBreak`, `rawHtml`, `table`, `tableOfContents`, inherit the following properties:
>
> * The value of `isLimit` is `true` for those elements because all [objects](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) are automatically [limit elements](#ckeditor5/latest/framework/deep-dive/schema.html--limit-elements).
> * The value of `isSelectable` is `true` for those elements because all [objects](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) are automatically [selectable elements](#ckeditor5/latest/framework/deep-dive/schema.html--selectable-elements).
> * The value of `isContent` is `true` for those elements because all [objects](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) are automatically [content elements](#ckeditor5/latest/framework/deep-dive/schema.html--content-elements).

#### Limit elements

Consider a feature like an image caption. The caption text area should construct a boundary to some internal actions:

* A selection that starts inside should not end outside.
* Pressing `Backspace` or `Delete` should not delete the area. Pressing `Enter` should not split the area.

It should also act as a boundary for external actions. This is mostly enforced by a selection post-fixer that ensures that a selection that starts outside, should not end inside. It means that most actions will either apply to the “outside” of such an element or to the content inside it.

Taken these characteristics, the image caption should be defined as a limit element by using the [`isLimit`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isLimit) property.

```js
schema.register( 'myCaption', {
    isLimit: true
} );
```

The engine and various features then check it via [`Schema#isLimit()`](../../api/module_engine_model_schema-ModelSchema.html#function-isLimit) and can act accordingly.

> **Note**
>
> “Limit element” does not mean “editable element.” The concept of “editable element” is reserved for the view and expressed by the [`ViewEditableElement` class](../../api/module_engine_view_editableelement-ViewEditableElement.html).

#### Object elements

For an image caption like in the example above it does not make much sense to select the caption box, then copy or drag it somewhere else.

A caption without the image it describes makes little sense. The image, however, is more self-sufficient. Most likely users should be able to select the entire image (with all its internals), then copy or move it around. The [`isObject`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isObject) property should be used to mark such behavior.

```js
schema.register( 'myImage', {
    isObject: true
} );
```

The [`Schema#isObject()`](../../api/module_engine_model_schema-ModelSchema.html#function-isObject) can later be used to check this property.

> **Note**
>
> There are also the `$blockObject` and the `$inlineObject` generic items which have the `isObject` property set to `true`. Most object-type items will inherit from `$blockObject` or `$inlineObject` (through `inheritAllFrom`).

> **Note**
>
> Every object is automatically also:
>
> * A [limit element](#ckeditor5/latest/framework/deep-dive/schema.html--limit-elements) – For every element with `isObject` set to `true`, [`Schema#isLimit( element )`](../../api/module_engine_model_schema-ModelSchema.html#function-isLimit) will always return `true`.
> * A [selectable element](#ckeditor5/latest/framework/deep-dive/schema.html--selectable-elements) – For every element with `isObject` set to `true`, [`Schema#isSelectable( element )`](../../api/module_engine_model_schema-ModelSchema.html#function-isSelectable) will always return `true`.
> * A [content element](#ckeditor5/latest/framework/deep-dive/schema.html--content-elements) – For every element with `isObject` set to `true`, [`Schema#isContent( element )`](../../api/module_engine_model_schema-ModelSchema.html#function-isContent) will always return `true`.

#### Block elements

Generally speaking, content is usually made out of blocks like paragraphs, list items, images, headings, etc. All these elements should be marked as blocks by using [`isBlock`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isBlock).

Schema items with the `isBlock` property set are (among others) affecting the [`Selection#getSelectedBlocks()`](../../api/module_engine_model_documentselection-ModelDocumentSelection.html#function-getSelectedBlocks) behavior and by that allow setting block level attributes like `alignment` to appropriate elements.

It is important to remember that a block should not allow another block inside. Container elements like `<blockQuote>`, which can contain other block elements, should not be marked as blocks.

> **Note**
>
> There are also the `$block` and the `$blockObject` generic items which have the `isBlock` property set to `true`. Most block-type items will inherit from `$block` or `$blockObject` (through `inheritAllFrom`).
>
> Note that every item that inherits from `$block` has `isBlock` set, but not every item with `isBlock` set has to be a `$block`.

#### Inline elements

In the editor, all HTML formatting elements such as `<strong>` or `<code>` are represented by text attributes. Therefore, inline model elements are not supposed to be used for these scenarios. To learn more about how text attributes work and how they are converted to inline elements in the view, see the [Attributes and inline formatting](#ckeditor5/latest/framework/deep-dive/conversion/attributes.html) guide.

Currently, the [`isInline`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isInline) property is used for the `$text` token (so, text nodes) and elements such as `<softBreak>`, `<imageInline>` or placeholder elements such as described in the [Implementing an inline widget](#ckeditor5/latest/framework/tutorials/widgets/implementing-an-inline-widget.html) tutorial.

The support for inline elements in CKEditor 5 is so far limited to self-contained elements. Because of this, all elements marked with `isInline` should also be marked with `isObject`.

> **Note**
>
> There is also the `$inlineObject` generic item which has the `isInline` property set to `true`. Most inline object type items will inherit from `$inlineObject` (through `inheritAllFrom`).

#### Selectable elements

Elements that users can select as a whole (with all their internals) and then, for instance, copy them or apply formatting, are marked with the [`isSelectable`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isSelectable) property in the schema:

```js
schema.register( 'mySelectable', {
    isSelectable: true
} );
```

The [`Schema#isSelectable()`](../../api/module_engine_model_schema-ModelSchema.html#function-isSelectable) method can later be used to check this property.

> **Note**
>
> All [object elements](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) are selectable by default. There are other selectable elements registered in the editor, though. For instance, there is also the `tableCell` model element (rendered as a `<td>` in the editing view) that is selectable while **not** registered as an object. The [table selection](#ckeditor5/latest/features/tables/tables.html--table-selection) plugin takes advantage of this fact and allows users to create rectangular selections made of multiple table cells.

#### Content elements

You can tell content model elements from other elements by looking at their representation in the editor data (you can use [`editor.getData()`](../../api/module_editor-classic_classiceditor-ClassicEditor.html#function-getData) or [`Model#hasContent()`](../../api/module_engine_model_model-Model.html#function-hasContent) to check this out).

Elements such as images or media will **always** find their way into the editor data and this is what makes them content elements. They are marked with the [`isContent`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html#member-isContent) property in the schema:

```js
schema.register( 'myImage', {
    isContent: true
} );
```

The [`Schema#isContent()`](../../api/module_engine_model_schema-ModelSchema.html#function-isContent) method can later be used to check this property.

At the same time, elements like paragraphs, list items, or headings **are not** content elements because they are skipped in the editor output when they are empty. From the data perspective, they are transparent unless they contain other content elements (an empty paragraph is as good as no paragraph).

> **Note**
>
> [Object elements](#ckeditor5/latest/framework/deep-dive/schema.html--object-elements) and [`$text`](#ckeditor5/latest/framework/deep-dive/schema.html--generic-items) are content by default.

### Generic items

There are several generic items (classes of elements) available: `$root`, `$inlineRoot`, `$container`, `$block`, `$blockObject`, `$inlineObject`, and `$text`. They are defined as follows:

```js
schema.register( '$root', {
    isLimit: true
} );

schema.register( '$inlineRoot', {
    allowContentOf: '$block',
    allowAttributesOf: '$root',
    isLimit: true
} );

schema.register( '$container', {
    allowIn: [ '$root', '$container' ]
} );

schema.register( '$block', {
    allowIn: [ '$root', '$container' ],
    isBlock: true
} );

schema.register( '$blockObject', {
    allowWhere: '$block',
    isBlock: true,
    isObject: true
} );

schema.register( '$inlineObject', {
    allowWhere: '$text',
    allowAttributesOf: '$text',
    isInline: true,
    isObject: true
} );

schema.register( '$text', {
    allowIn: '$block',
    isInline: true,
    isContent: true
} );
```

These definitions can then be reused by features to create their own definitions in a more extensible way.

The `$inlineRoot` element is an alternative to `$root` for roots that should only contain inline content (text and inline objects) rather than block content. It inherits attributes from `$root` so that features that set attributes on the root (for example, to track document-level metadata) work the same way regardless of root type. You can use it via the [`config.root.modelElement`](../../api/module_core_editor_editorconfig-RootConfig.html#member-modelElement) option.

For example, the [`Paragraph`](../../api/module_paragraph_paragraph-Paragraph.html) feature will define its item as:

```js
schema.register( 'paragraph', {
    inheritAllFrom: '$block'
} );
```

Which translates to:

```js
schema.register( 'paragraph', {
    allowWhere: '$block',
    allowContentOf: '$block',
    allowAttributesOf: '$block',
    inheritTypesFrom: '$block'
} );
```

And this can be read as:

* The `<paragraph>` element will be allowed in elements in which `<$block>` is allowed (like in `<$root>`).
* The `<paragraph>` element will allow all nodes that are allowed in `<$block>` (like `$text`).
* The `<paragraph>` element will allow all attributes allowed in `<$block>`.
* The `<paragraph>` element will inherit all `is*` properties of `<$block>` (like `isBlock`).

Thanks to the fact that the `<paragraph>` definition is inherited from `<$block>` other features can use the `<$block>` type to indirectly extend the `<paragraph>` definition. For example, the [`BlockQuote`](../../api/module_block-quote_blockquote-BlockQuote.html) feature does this:

```js
schema.register( 'blockQuote', {
    inheritAllFrom: '$container'
} );
```

Because `<$block>` is allowed in `<$container>` (see `schema.register( '$block' ...)`), despite the fact that the block quote and paragraph features know nothing about each other, paragraphs will be allowed in block quotes: the schema rules allow chaining.

Taking this even further, if anyone registers a `<section>` element (with the `allowContentOf: '$root'` rule), because `<$container>` is also allowed in `<$root>` (see `schema.register( '$container' ...)`) the `<section>` elements will allow block quotes out–of–the–box.

> **Note**
>
> You can read more about the format of the item definition in [`ModelSchemaItemDefinition`](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html).

#### Relations between generic items

Relations between generic items (which one can be used where) can be visualized by the following abstract structure:

```xml
<$root>
    <$block>                
        <$text/>
        <$inlineObject/>    
    </$block>
    <$blockObject/>            
    <$container>            
        <$container/>
        <$block/>
        <$blockObject/>
    </$container>
</$root>

<$inlineRoot>                
    <$text/>
    <$inlineObject/>
</$inlineRoot>
```

The above rules will be met for instance by such a model content:

```xml
<$root>
    <heading1>                
        <$text/>            
    </heading1>
    <paragraph>                
        <$text/>            
        <softBreak/>        
        <$text/>            
        <imageInline/>        
    </paragraph>
    <imageBlock>            
        <caption>            
            <$text/>        
        </caption>
    </imageBlock>
    <blockQuote>                    
        <paragraph/>                
        <table>                        
            <tableRow>                
                <tableCell>            
                    <paragraph>        
                        <$text/>    
                    </paragraph>
                </tableCell>
            </tableRow>
        </table>
    </blockQuote>
</$root>
```

Which, in turn, has these [semantics](#ckeditor5/latest/framework/deep-dive/schema.html--defining-additional-semantics):

```xml
<$root>                        
    <heading1>                
        <$text/>            
    </heading1>
    <paragraph>                
        <$text/>            
        <softBreak/>        
        <$text/>            
        <imageInline/>        
    </paragraph>
    <imageBlock>            
        <caption>            
            <$text/>        
        </caption>
    </imageBlock>
    <blockQuote>
        <paragraph/>                
        <table>                        
            <tableRow>                
                <tableCell>            
                    <paragraph>        
                        <$text/>    
                    </paragraph>
                </tableCell>
            </tableRow>
        </table>
    </blockQuote>
</$root>
```

#### Custom root elements

The generic `$root` / `$container` / `$block` chain described above is keyed on the element name `$root`. By default, a root is created as `<$root>`, so every rule of the form `allowIn: '$root'` or `allowAttributesOf: '$root'` applies to it automatically.

You can change the element name used for a root via the [`config.root.modelElement`](../../api/module_core_editor_editorconfig-RootConfig.html#member-modelElement) (or `config.roots.<rootName>.modelElement` for the [multi-root editor](../../api/module_editor-multi-root_multirooteditor-MultiRootEditor.html)) option. When you do, the created root is `<myRoot>` instead of `<$root>`, and **it does not automatically inherit the `$root` chain**. Features that define their elements as `allowIn: '$root'`, `allowContentOf: '$root'`, or `allowAttributesOf: '$root'` will not apply to the custom root unless you opt in.

Declare the custom root in the schema and pick which parts of the `$root` chain you want:

```js
// Inherit everything $root provides - allowed children, attributes, and is* flags.
schema.register( 'myRoot', {
    inheritAllFrom: '$root',
    allowChildren: [ '$container', '$block' ]
} );

// Or opt in selectively - e.g. only inherit attributes (the `$inlineRoot` pattern).
schema.register( 'myInlineRoot', {
    allowContentOf: '$block',
    allowAttributesOf: '$root',
    isLimit: true
} );
```

Key rules to remember for custom roots:

* **Block / container content.** If the root should accept the generic block chain, declare `allowChildren: [ '$container', '$block' ]` (or `inheritAllFrom: '$root'`). Otherwise `$block`-based elements like `<paragraph>` and `$container`-based elements like `<blockQuote>` will not be allowed inside it.
* **Root attributes.** Attributes registered via [`editor.registerRootAttribute()`](../../api/module_core_editor_editor-Editor.html#function-registerRootAttribute) are attached only to the `$root` schema element. Custom roots must opt into this chain via `allowAttributesOf: '$root'` to receive them.
* **Data conversion context.** When calling [`editor.data.parse()`](../../api/module_engine_controller_datacontroller-DataController.html#function-parse) or [`editor.data.toModel()`](../../api/module_engine_controller_datacontroller-DataController.html#function-toModel) against a custom root, pass the target root element (or its configured model element name) as the `context` argument. The default `'$root'` only matches the generic root and can produce wrong conversion results.

The engine ships with one ready-made custom root definition - `$inlineRoot` - for roots that should only contain inline content. You can use it out of the box via `config.root.modelElement: '$inlineRoot'` without adding your own schema registration.

### Defining advanced rules using callbacks

The base [declarative `SchemaItemDefinition` API](../../api/module_engine_model_schema-ModelSchemaItemDefinition.html) is by its nature limited, and some custom rules might not be possible to be implemented this way.

For this reason, it is also possible to define schema checks by providing callbacks. This gives you flexibility to implement any logic that you need.

These callbacks can be set both for child checks (model structure checks) and attribute checks.

Note that the callbacks take precedence over the rules defined through the declarative API and can overwrite these rules.

#### Child checks (structure checks)

Using [`Schema#addChildCheck()`](../../api/module_engine_model_schema-ModelSchema.html#function-addChildCheck) you can provide function callbacks to implement specific advanced rules for checking the model structure.

You can provide callbacks that are fired only when a specific child is checked, or generic callbacks fired for all checks performed by the schema.

Below is an example of a specific callback, that disallows inline images inside code blocks:

```js
schema.addChildCheck( context => {
    if ( context.endsWith( 'codeBlock' ) ) {
        return false;
    }
}, 'imageInline' );
```

The second parameter (`'imageInline'`) specifies that the callback will be used only if `imageInline` is being checked.

You can also use a callback to force given item to be allowed. For example, allow special `$marker` item to be allowed everywhere:

```js
schema.addChildCheck( () => true, '$marker' );
```

Note that a callback may return `true`, `false`, or no value (`undefined`). If `true` or `false` is returned, the decision was made and further callbacks or declarative rules will not be checked. The item will be allowed or disallowed. If no value is returned, further checks will decide whether the item is allowed or not.

In some cases, you may need to define a generic listener that will be fired on every schema check.

For instance, to disallow all block objects (for example tables) inside a block quotes, you can define following callback:

```js
schema.addChildCheck( ( context, childDefinition ) => {
    if ( context.endsWith( 'blockQuote' ) && childDefinition.isBlock && childDefinition.isObject ) {
        return false;
    }
} );
```

The above will trigger on every `checkChild()` call giving you more flexibility. However, please keep in mind that using multiple generic callbacks might negatively impact the editor performance.

#### Attribute checks

Similarly, you can define callbacks to check whether given attribute is or is not allowed on given item.

This time, you will use [`Schema#addAttributeCheck()`](../../api/module_engine_model_schema-ModelSchema.html#function-addAttributeCheck) to provide the callback.

For example, allow custom attribute `headingMarker` on all headings:

```js
schema.addAttributeCheck( ( context, attributeName ) => {
    const isHeading = context.last.name.startsWith( 'heading' );

if ( isHeading ) {
        return true;
    }
}, 'headingMarker' );
```

Generic callbacks are available too. For example, disallow formatting attributes (like bold or italic) on text inside all headings:

```js
schema.addAttributeCheck( ( context, attributeName ) => {
    const parent = context.getItem( context.length - 2 );
    const insideHeading = parent && parent.name.startsWith( 'heading' );

if ( insideHeading && context.endsWith( '$text' ) && schema.getAttributeProperties( attributeName ).isFormatting ) {
        return false;
    }
} );
```

All notes related to child check callbacks apply to attribute callbacks as well.

### Implementing additional constraints

Schema’s capabilities are limited to simple (and atomic) [`Schema#checkChild()`](../../api/module_engine_model_schema-ModelSchema.html#function-checkChild) and [`Schema#checkAttribute()`](../../api/module_engine_model_schema-ModelSchema.html#function-checkAttribute) checks on purpose. One may imagine that the schema should support defining more complex rules such as “element `<x>` must be always followed by `<y>`.” While it is feasible to create an API that would enable feeding the schema with such definitions, it is unfortunately unrealistic to then expect that every editing feature will consider these rules when processing the model. It is also unrealistic to expect that it will be done automatically by the schema and the editing engine themselves.

For instance, let’s get back to the “element `<x>` must be always followed by `<y>`” rule and this initial content:

```xml
<$root>
    <x>foo</x>
    <y>bar[bom</y>
    <z>bom]bar</z>
</$root>
```

Now imagine that the user presses the “Block quote” button. Normally it would wrap the two selected blocks (`<y>` and `<z>`) with a `<blockQuote>` element:

```xml
<$root>
    <x>foo</x>
    <blockQuote>
        <y>bar[bom</y>
        <z>bom]bar</z>
    </blockQuote>
</$root>
```

However, it turns out that this creates an incorrect structure – `<x>` is not followed by `<y>` anymore.

What should happen instead? There are at least 4 possible solutions: the block quote feature should not be applicable in such a context, someone should create a new `<y>` right after `<x>`, `<x>` should be moved inside `<blockQuote>` together with `<y>` or vice versa.

While this is a relatively simple scenario (unlike most real-time collaborative editing scenarios), it turns out that it is already hard to say what should happen and who should react to fix this content.

Therefore, if your editor needs to implement such rules, you should do that through [model’s post-fixers](../../api/module_engine_model_document-ModelDocument.html#function-registerPostFixer) fixing incorrect content or actively prevent such situations (for example, by disabling certain features). It means that these constraints will be defined specifically for your scenario by your code which makes their implementation much easier.

To sum up, the answer to who and how should implement additional constraints is: your features or your editor through the CKEditor 5 API.

### Who checks the schema?

The CKEditor 5 API exposes many ways to work on (change) the model. It can be done [through the writer](#ckeditor5/latest/framework/architecture/editing-engine.html--changing-the-model), via methods like [`Model#insertContent()`](../../api/module_engine_model_model-Model.html#function-insertContent), via commands, and so on.

#### Low-level APIs

The lowest-level API is the writer (to be precise, there are also raw operations below, but they are used for special cases only). It allows applying atomic changes to the content like inserting, removing, moving or splitting nodes, setting and removing an attribute, etc. It is important to know that the **writer does not prevent from applying changes that violate rules defined in the schema**.

The reason for this is that when you implement a command or any other feature you may need to perform multiple operations to do all the necessary changes. The state in the meantime (between these atomic operations) may be incorrect. The writer must allow that.

For instance, you need to move `<foo>` from `<$root>` to `<bar>` and (at the same time) rename it to `<oof>`. But the schema defines that `<oof>` is not allowed in `<$root>` and `<foo>` is disallowed in `<bar>`. If the writer checked the schema, it would complain regardless of the order of `rename` and `move` operations.

You can argue that the engine could handle this by checking the schema at the end of a [`Model#change()` block](../../api/module_engine_model_model-Model.html#function-change) (it works like a transaction – the state needs to be correct at the end of it). This approach, however, was not adopted, as there are the following problems:

* How to fix the content after a transaction is committed? It is impossible to implement a reasonable heuristic that would not break the content from the user’s perspective.
* The model can become invalid during real-time collaborative changes. Operational Transformation, while implemented by us in a rich form (with 11 types of operations instead of the base 3), ensures conflict resolution and eventual consistency, but not the model’s validity.

Therefore, we chose to handle such situations on a case-by-case basis, using more expressive and flexible [model’s post-fixers](../../api/module_engine_model_document-ModelDocument.html#function-registerPostFixer). Additionally, we moved the responsibility of checking the schema to features. They can make a lot better decisions before making changes. You can read more about this in the [“Implementing additional constraints”](#ckeditor5/latest/framework/deep-dive/schema.html--implementing-additional-constraints) section above.

#### High-level APIs

What about other, higher-level methods? **We recommend that all APIs built on top of the writer should check the schema.**

For instance, the [`Model#insertContent()`](../../api/module_engine_model_model-Model.html#function-insertContent) method will make sure that inserted nodes are allowed in the place of their insertion. It may also attempt to split the insertion container (if allowed by the schema) if that will make the element to insert allowed, and so on.

Similarly, commands – if implemented correctly – [get disabled](../../api/module_core_command-Command.html#member-isEnabled) if they should not be executed in the current place.

Finally, the schema plays a crucial role during the conversion from the view to the model (also called “upcasting”). During this process converters decide whether they can convert specific view elements or attributes to the given positions in the model. Thanks to that if you tried to load incorrect data to the editor or when you paste content copied from another website, the structure and attributes of the data get adjusted to the current schema rules.

> **Note**
>
> Some features may miss schema checks. If you happen to find such a scenario, do not hesitate to [report it to us](https://github.com/ckeditor/ckeditor5/issues).

<a id="ckeditor5/latest/framework/deep-dive/ui/custom-editor-creator.html">source file: "ckeditor5/latest/framework/deep-dive/ui/custom-editor-creator.html"</a>

## Implementing a custom editor creator

The flexible architecture of CKEditor 5 allows creating custom editors. Not only the [theme styling can be changed](#ckeditor5/latest/examples/framework/theme-customization.html) or the [UI redesigned](#ckeditor5/latest/examples/framework/custom-ui.html) but also the entire editor initialization process can be modified allowing to create new editor types. Thanks to that, apart from the standard editors (like [classic](#ckeditor5/latest/examples/builds/classic-editor.html), [inline](#ckeditor5/latest/examples/builds/inline-editor.html), [balloon](#ckeditor5/latest/examples/builds/balloon-editor.html) or [document](#ckeditor5/latest/examples/builds/document-editor.html)), custom types like a [**multi-root editor**](#ckeditor5/latest/examples/builds/multi-root-editor.html) can be created.

This guide goes through the process of implementing a custom, multi-root editor. You can check out the [demo of the multi-root editor](#ckeditor5/latest/examples/builds/multi-root-editor.html) too.

### Editor class

The `*Editor` class is the main class of each editor type. It initializes the whole editor and its UI parts. The custom creator class should extend the [base `Editor` class](../../../api/module_core_editor_editor-Editor.html). For a multi-root editor, it may look like below:

**NPM**

```js
import { Editor, getDataFromElement, setDataInElement } from 'ckeditor5';

/**
 * The multi-root editor implementation. It provides inline editables and a single toolbar.
 *
 * Unlike other editors, the toolbar is not rendered automatically and needs to be attached to the DOM manually.
 *
 * This type of an editor is dedicated to integrations which require a customized UI with an open
 * structure, allowing developers to specify the exact location of the interface.
 *
 * @implements module:core/editor/editorwithui~EditorWithUI
 * @extends module:core/editor/editor~Editor
 */
class MultirootEditor extends Editor {
	/**
	* Creates an instance of the multi-root editor.
	*
	* **Note:** Do not use the constructor to create editor instances. Use the static `MultirootEditor.create()` method instead.
	*
	* @protected
	* @param {module:core/editor/editorconfig~EditorConfig} config The editor configuration.
	*/
	constructor( config ) {
		super( config );

// Populate missing initial data for roots from source elements while preserving
		// any root configuration passed by the integration (for example placeholders).
		const roots = this.config.get( 'roots' ) || {};

for ( const rootName of Object.keys( sourceElements ) ) {
			roots[ rootName ] = roots[ rootName ] || {};

if ( roots[ rootName ].initialData === undefined ) {
				roots[ rootName ].initialData = getDataFromElement( roots[ rootName ].element );
			}
		}

this.config.set( 'roots', roots );

// Create root and UIView element for each editable container.
		for ( const rootName of Object.keys( sourceElements ) ) {
			this.model.document.createRoot( '$root', rootName );
		}

this.ui = new MultirootEditorUI( this, new MultirootEditorUIView( this.locale, this.editing.view, sourceElements ) );
	}

/**
	* @inheritDoc
	*/
	destroy() {
		// Cache the data and editable DOM elements, then destroy.
		// It's safe to assume that the model->view conversion will not work after super.destroy(),
		// same as `ui.getEditableElement()` method will not return editables.
		const data = {};
		const editables = {};
		const editablesNames = Array.from( this.ui.getEditableElementsNames() );

for ( const rootName of editablesNames ) {
			data[ rootName ] = this.getData( { rootName } );
			editables[ rootName ] = this.ui.getEditableElement( rootName );
		}

this.ui.destroy();

return super.destroy()
			.then( () => {
				for ( const rootName of editablesNames ) {
					setDataInElement( editables[ rootName ], data[ rootName ] );
				}
			} );
	}

/**
	* Creates a multi-root editor instance.
	*
	* @param {module:core/editor/editorconfig~EditorConfig} config The editor configuration.
	* @returns {Promise} A promise resolved once the editor is ready. The promise returns the created multi-root editor instance.
	*/
	static create( config ) {
		return new Promise( resolve => {
			const editor = new this( config );

resolve(
				editor.initPlugins()
					.then( () => editor.ui.init() )
					.then( () => editor.data.init( Object.fromEntries(
						Object.entries( editor.config.get( 'roots' ) ).map( ( [ rootName, rootConfig ] ) => [ rootName, rootConfig.initialData ?? '' ] )
					) ) )
					.then( () => editor.fire( 'ready' ) )
					.then( () => editor )
			);
		} );
	}
}
```

**CDN**

```js
const { Editor, getDataFromElement, setDataInElement } = CKEDITOR;

for ( const rootName of Object.keys( sourceElements ) ) {
			roots[ rootName ] = roots[ rootName ] || {};

if ( roots[ rootName ].initialData === undefined ) {
				roots[ rootName ].initialData = getDataFromElement( roots[ rootName ].element );
			}
		}

this.config.set( 'roots', roots );

// Create root and UIView element for each editable container.
		for ( const rootName of Object.keys( sourceElements ) ) {
			this.model.document.createRoot( '$root', rootName );
		}

this.ui = new MultirootEditorUI( this, new MultirootEditorUIView( this.locale, this.editing.view, sourceElements ) );
	}

for ( const rootName of editablesNames ) {
			data[ rootName ] = this.getData( { rootName } );
			editables[ rootName ] = this.ui.getEditableElement( rootName );
		}

this.ui.destroy();

return super.destroy()
			.then( () => {
				for ( const rootName of editablesNames ) {
					setDataInElement( editables[ rootName ], data[ rootName ] );
				}
			} );
	}

### EditorUI class

The `*EditorUI` class is the main UI class that initializes UI components (the main view and the toolbar) and sets up mechanisms like [focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class) or placeholder management. The custom `*EditorUI` class should extend the [base `EditorUI` class](../../../api/module_ui_editorui_editorui-EditorUI.html) like below:

**NPM**

```js
import { EditorUI, enableViewPlaceholder } from 'ckeditor5';

/**
 * The multi-root editor UI class.
 *
 * @extends module:ui/editorui/editorui~EditorUI
 */
class MultirootEditorUI extends EditorUI {
	/**
	* Creates an instance of the multi-root editor UI class.
	*
	* @param {module:core/editor/editor~Editor} editor The editor instance.
	* @param {module:ui/editorui/editoruiview~EditorUIView} view The view of the UI.
	*/
	constructor( editor, view ) {
		super( editor );

/**
		* The main (top–most) view of the editor UI.
		*
		* @readonly
		* @member {module:ui/editorui/editoruiview~EditorUIView} #view
		*/
		this.view = view;
	}

/**
	* Initializes the UI.
	*/
	init() {
		const view = this.view;
		const editor = this.editor;
		const editingView = editor.editing.view;

let lastFocusedEditableElement;

view.render();

// Keep track of the last focused editable element. Knowing which one was focused
		// is useful when the focus moves from editable to other UI components like balloons
		// (especially inputs) but the editable remains the "focus context" (e.g. link balloon
		// attached to a link in an editable). In this case, the editable should preserve visual
		// focus styles.
		this.focusTracker.on( 'change:focusedElement', ( evt, name, focusedElement ) => {
			for ( const editable of this.view.editables ) {
				if ( editable.element === focusedElement ) {
					lastFocusedEditableElement = editable.element;
				}
			}
		} );

// If the focus tracker loses focus, stop tracking the last focused editable element.
		// Wherever the focus is restored, it will no longer be in the context of that editable
		// because the focus "came from the outside", as opposed to the focus moving from one element
		// to another within the editor UI.
		this.focusTracker.on( 'change:isFocused', ( evt, name, isFocused ) => {
			if ( !isFocused ) {
				lastFocusedEditableElement = null;
			}
		} );

for ( const editable of this.view.editables ) {
			// The editable UI element in DOM is available for sure only after the editor UI view has been rendered.
			// But it can be available earlier if a DOM element has been passed to MultirootEditor.create().
			const editableElement = editable.element;

// Register each editable UI view in the editor.
			this.setEditableElement( editable.name, editableElement );

// Let the editable UI element respond to the changes in the global editor focus
			// tracker. It has been added to the same tracker a few lines above but, in reality, there are
			// many focusable areas in the editor, like balloons, toolbars or dropdowns and as long
			// as they have focus, the editable should act like it is focused too (although technically
			// it isn't), e.g. by setting the proper CSS class, visually announcing focus to the user.
			// Doing otherwise will result in editable focus styles disappearing, once e.g. the
			// toolbar gets focused.
			editable.bind( 'isFocused' ).to( this.focusTracker, 'isFocused', this.focusTracker, 'focusedElement',
				( isFocused, focusedElement ) => {
					// When the focus tracker is blurred, it means the focus moved out of the editor UI.
					// No editable will maintain focus then.
					if ( !isFocused ) {
						return false;
					}

// If the focus tracker says the editor UI is focused and currently focused element
					// is the editable, then the editable should be visually marked as focused too.
					if ( focusedElement === editableElement ) {
						return true;
					}
					// If the focus tracker says the editor UI is focused but the focused element is
					// not an editable, it is possible that the editable is still (context–)focused.
					// For instance, the focused element could be an input inside of a balloon attached
					// to the content in the editable. In such case, the editable should remain _visually_
					// focused even though technically the focus is somewhere else. The focus moved from
					// the editable to the input but the focus context remained the same.
					else {
						return lastFocusedEditableElement === editableElement;
					}
				} );

// Bind the editable UI element to the editing view, making it an end– and entry–point
			// of the editor's engine. This is where the engine meets the UI.
			editingView.attachDomRoot( editableElement, editable.name );
		}

this._initPlaceholder();
		this._initToolbar();
		this.fire( 'ready' );
	}

/**
	* @inheritDoc
	*/
	destroy() {
		super.destroy();

const view = this.view;
		const editingView = this.editor.editing.view;

for ( const editable of this.view.editables ) {
			editingView.detachDomRoot( editable.name );
		}

view.destroy();
	}

/**
	* Initializes the editor main toolbar and its panel.
	*
	* @private
	*/
	_initToolbar() {
		const editor = this.editor;
		const view = this.view;
		const toolbar = view.toolbar;

toolbar.fillFromConfig( editor.config.get( 'toolbar' ), this.componentFactory );

// Register the toolbar so it becomes available for Alt+F10 and Esc navigation.
		this.addToolbar( view.toolbar );
	}

/**
	* Enable the placeholder text on the editing root, if any was configured.
	*
	* @private
	*/
	_initPlaceholder() {
		const editor = this.editor;
		const editingView = editor.editing.view;

for ( const editable of this.view.editables ) {
			const editingRoot = editingView.document.getRoot( editable.name );
			const sourceElement = this.getEditableElement( editable.name );

const placeholderText = editor.config.get( 'roots' )[ editable.name ]?.placeholder ||
				sourceElement && sourceElement.tagName.toLowerCase() === 'textarea' && sourceElement.getAttribute( 'placeholder' );

if ( placeholderText ) {
				editingRoot.placeholder = placeholderText;

enableViewPlaceholder( {
					view: editingView,
					element: editingRoot,
					isDirectHost: false,
					keepOnFocus: true
				} );
			}
		}
	}
}
```

**CDN**

```js
const { EditorUI, enableViewPlaceholder } = CKEDITOR;

/**
		* The main (top–most) view of the editor UI.
		*
		* @readonly
		* @member {module:ui/editorui/editoruiview~EditorUIView} #view
		*/
		this.view = view;
	}

/**
	* Initializes the UI.
	*/
	init() {
		const view = this.view;
		const editor = this.editor;
		const editingView = editor.editing.view;

let lastFocusedEditableElement;

view.render();

// Register each editable UI view in the editor.
			this.setEditableElement( editable.name, editableElement );

this._initPlaceholder();
		this._initToolbar();
		this.fire( 'ready' );
	}

/**
	* @inheritDoc
	*/
	destroy() {
		super.destroy();

const view = this.view;
		const editingView = this.editor.editing.view;

for ( const editable of this.view.editables ) {
			editingView.detachDomRoot( editable.name );
		}

view.destroy();
	}

/**
	* Initializes the editor main toolbar and its panel.
	*
	* @private
	*/
	_initToolbar() {
		const editor = this.editor;
		const view = this.view;
		const toolbar = view.toolbar;

toolbar.fillFromConfig( editor.config.get( 'toolbar' ), this.componentFactory );

// Register the toolbar so it becomes available for Alt+F10 and Esc navigation.
		this.addToolbar( view.toolbar );
	}

/**
	* Enable the placeholder text on the editing root, if any was configured.
	*
	* @private
	*/
	_initPlaceholder() {
		const editor = this.editor;
		const editingView = editor.editing.view;

for ( const editable of this.view.editables ) {
			const editingRoot = editingView.document.getRoot( editable.name );
			const sourceElement = this.getEditableElement( editable.name );

if ( placeholderText ) {
				editingRoot.placeholder = placeholderText;

enableViewPlaceholder( {
					view: editingView,
					element: editingRoot,
					isDirectHost: false,
					keepOnFocus: true
				} );
			}
		}
	}
}
```

### EditorUIView class

Finally, the `*EditorUIView` class is responsible for registering and handling all editable elements and for creating the editor toolbar. The custom `*EditorUIView` class should extend the [base `EditorUIView` class](../../../api/module_ui_editorui_editoruiview-EditorUIView.html):

**NPM**

```js
import { EditorUIView, InlineEditableUIView, Template, ToolbarView } from 'ckeditor5';

/**
 * The multi-root editor UI view. It is a virtual view providing an inline editable, but without
 * any specific arrangement of the components in the DOM.
 *
 * @extends module:ui/editorui/editoruiview~EditorUIView
 */
class MultirootEditorUIView extends EditorUIView {
	/**
	* Creates an instance of the multi-root editor UI view.
	*
	* @param {module:utils/locale~Locale} locale The locale instance.
	* @param {module:engine/view/view~EditingView} editingView The editing view instance this view is related to.
	* @param {Object.<String,HTMLElement>} editableElements The list of editable elements, containing name and html element
	* for each editable.
	*/
	constructor( locale, editingView, editableElements ) {
		super( locale );

/**
		* The main toolbar of the multi-root editor UI.
		*
		* @readonly
		* @member {module:ui/toolbar/toolbarview~ToolbarView}
		*/
		this.toolbar = new ToolbarView( locale );

/**
		* The editables of the multi-root editor UI.
		*
		* @readonly
		* @member {Array.<module:ui/editableui/inline/inlineeditableuiview~InlineEditableUIView>}
		*/
		this.editables = [];

// Create InlineEditableUIView instance for each editable.
		for ( const editableName of Object.keys( editableElements ) ) {
			const editable = new InlineEditableUIView( locale, editingView, editableElements[ editableName ] );

editable.name = editableName;
			this.editables.push( editable );
		}

// This toolbar may be placed anywhere in the page so things like font size need to be reset in it.
		// Because of the above, make sure the toolbar supports rounded corners.
		// Also, make sure the toolbar has the proper dir attribute because its ancestor may not have one
		// and some toolbar item styles depend on this attribute.
		Template.extend( this.toolbar.template, {
			attributes: {
				class: [
					'ck-reset_all',
					'ck-rounded-corners'
				],
				dir: locale.uiLanguageDirection
			}
		} );
	}

/**
	* @inheritDoc
	*/
	render() {
		super.render();

this.registerChild( this.editables );
		this.registerChild( [ this.toolbar ] );
	}
}
```

**CDN**

```js
const { EditorUIView, InlineEditableUIView, Template, ToolbarView } = CKEDITOR;

/**
		* The main toolbar of the multi-root editor UI.
		*
		* @readonly
		* @member {module:ui/toolbar/toolbarview~ToolbarView}
		*/
		this.toolbar = new ToolbarView( locale );

/**
		* The editables of the multi-root editor UI.
		*
		* @readonly
		* @member {Array.<module:ui/editableui/inline/inlineeditableuiview~InlineEditableUIView>}
		*/
		this.editables = [];

editable.name = editableName;
			this.editables.push( editable );
		}

/**
	* @inheritDoc
	*/
	render() {
		super.render();

this.registerChild( this.editables );
		this.registerChild( [ this.toolbar ] );
	}
}
```

### Initializing custom editor instance

Now with the multi-root editor creator ready, you can create a fully usable editor instance.

With HTML like:

```html
<div id="toolbar"></div>

<header id="header">
    <h2>Gone traveling</h2>
    <h3>Monthly travel news and inspiration</h3>
</header>

<div id="content">
    <h3>Destination of the Month</h3>

<h4>Valletta</h4>

<figure class="image image-style-align-right">
        <img alt="Picture of a sunlit facade of a Maltan building." src="../../../assets/img/malta.jpg">
        <figcaption>It's siesta time in Valletta.</figcaption>
    </figure>

<p>The capital city of <a href="https://en.wikipedia.org/wiki/Malta" target="_blank" rel="external">Malta</a> is the top destination this summer. It’s home to a cutting-edge contemporary architecture, baroque masterpieces, delicious local cuisine, and at least 8 months of sun. It’s also a top destination for filmmakers, so you can take a tour through locations familiar to you from Game of Thrones, Gladiator, Troy and many more.</p>
</div>

<div class="demo-row">
    <div class="demo-row__half">
        <div id="footer-left">
            <h3>The three greatest things you learn from traveling</h3>
            <p><a href="#">Find out more</a></p>
        </div>
    </div>

<div class="demo-row__half">
        <div id="footer-right">
            <h3>Walking the capitals of Europe: Warsaw</h3>
            <p><a href="#">Find out more</a></p>
        </div>
    </div>
</div>
```

You can initialize the editor with the code below:

```js
MultirootEditor
    .create( {
        licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
        plugins: [ Essentials, Paragraph, Heading, Bold, Italic, List, Link, BlockQuote, Image, ImageCaption,
            ImageStyle, ImageToolbar, ImageUpload, Table, TableToolbar, MediaEmbed ],
        toolbar: [ 'heading', '|', 'bold', 'italic', 'link', 'bulletedList', 'numberedList', 'uploadImage', 'blockQuote',
            'insertTable', 'mediaEmbed', 'undo', 'redo' ],
        image: {
            toolbar: [ 'toggleImageCaption', 'imageTextAlternative', '|', 'imageStyle:inline', 'imageStyle:wrapText', 'imageStyle:breakText' ],
        },
        table: {
            contentToolbar: [
                'tableColumn',
                'tableRow',
                'mergeTableCells'
            ]
        },
        roots: {
            header: {
                element: document.querySelector( '#header' ),
                placeholder: 'Header text goes here'
            },
            content: {
                element: document.querySelector( '#content' ),
                placeholder: 'Type content here'
            },
            footerleft: {
                element: document.querySelector( '#footer-left' ),
                placeholder: 'Left footer content'
            },
            footerright: {
                element: document.querySelector( '#footer-right' ),
                placeholder: 'Right footer content'
            }
        },
    } )
    .then( newEditor => {
        document.querySelector( '#toolbar' ).appendChild( newEditor.ui.view.toolbar.element );

window.editor = newEditor;
    } )
    .catch( err => {
        console.error( err.stack );
    } );
```

This will create the exact same editor as the one used on the [multi-root editor editor example page](#ckeditor5/latest/examples/builds/multi-root-editor.html).

<a id="ckeditor5/latest/framework/deep-dive/ui/document-editor.html">source file: "ckeditor5/latest/framework/deep-dive/ui/document-editor.html"</a>

## Document editor

This tutorial builds a document editor with a customized, paper-like UI on top of the [`DecoupledEditor`](../../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html) class, which lets you place the editor’s UI elements anywhere in your application. See the [document editor example](#ckeditor5/latest/examples/builds/document-editor.html) for the end result.

### The editor

Document editor can be created using the existing data container in the DOM. It can also accept a raw data string and create the editable by itself. To get the output data, use the [`getData()`](../../../api/module_core_editor_editor-Editor.html#function-getData) method.

> **Note**
>
> See the [`DecoupledEditor.create()`](../../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html#static-function-create) method to learn about different approaches to the initialization of the editor.

**NPM**

```js
import { DecoupledEditor } from 'ckeditor5';

DecoupledEditor.create( {
	root: {
		element: document.querySelector( '.document-editor__editable' )
	},
	cloudServices: {
		// A configuration of CKEditor Cloud Services.
		// ...
	}
} )
.then( editor => {
	const toolbarContainer = document.querySelector( '.document-editor__toolbar' );

toolbarContainer.appendChild( editor.ui.view.toolbar.element );

window.editor = editor;
} )
.catch( err => {
	console.error( err );
} );
```

**CDN**

```js
const { DecoupledEditor } = CKEDITOR;

toolbarContainer.appendChild( editor.ui.view.toolbar.element );

window.editor = editor;
} )
.catch( err => {
	console.error( err );
} );
```

You may have noticed that you have to make sure the editor UI is injected into your application after it fires the [`EditorUI#ready`](../../../api/module_ui_editorui_editorui-EditorUI.html#event-ready) event. The toolbar element can be found under `editor.ui.view.toolbar.element`.

### The user interface

The code you have just created will run the editor but the user interface is still missing. Start off with a basic HTML structure to host the editor components (the toolbar and the editable).

#### HTML

The following structure has two containers that correspond to the configuration you have just used. The editor will inject the toolbar and the editable into respective containers as it starts.

```html
<div class="document-editor">
    <div class="document-editor__toolbar"></div>
    <div class="document-editor__editable-container">
        <div class="document-editor__editable">
            <p>The initial editor data.</p>
        </div>
    </div>
</div>
```

The `<div class="document-editor">...</<div>` element is the outermost container of the document editor and, although not mandatory, it is recommended to use it to keep things together.

> **Warning**
>
> Make sure the HTML structure is available in the DOM when the editor is created. To do so, put the editor bootstrap code somewhere later in HTML or use the [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event to defer your JavaScript execution until the DOM is ready.

#### Styles

Styles are what the document editor needs to materialize. Begin with the styles of the main container:

```css
.document-editor {
    border: 1px solid var(--ck-color-base-border);
    border-radius: var(--ck-border-radius);

/* Set vertical boundaries for the document editor. */
    max-height: 700px;

/* This element is a flex container for easier rendering. */
    display: flex;
    flex-flow: column nowrap;
}
```

Then, make the toolbar look like it floats over the “page”:

```css
.document-editor__toolbar {
    /* Make sure the toolbar container is always above the editable. */
    z-index: 1;

/* Create the illusion of the toolbar floating over the editable. */
    box-shadow: 0 0 5px hsla( 0,0%,0%,.2 );

/* Use the CKEditor CSS variables to keep the UI consistent. */
    border-bottom: 1px solid var(--ck-color-toolbar-border);
}

/* Adjust the look of the toolbar inside the container. */
.document-editor__toolbar .ck-toolbar {
    border: 0;
    border-radius: 0;
}
```

The editable should look like a sheet of paper, centered in its scrollable container:

```css
/* Make the editable container look like the inside of a native word processor application. */
.document-editor__editable-container {
    padding: calc( 2 * var(--ck-spacing-large) );
    background: var(--ck-color-base-foreground);

/* Make it possible to scroll the "page" of the edited content. */
    overflow-y: scroll;
}

.document-editor__editable-container .ck-editor__editable {
    /* Set the dimensions of the "page". */
    width: 15.8cm;
    min-height: 21cm;

/* Keep the "page" off the boundaries of the container. */
    padding: 1cm 2cm 2cm;

border: 1px hsl( 0,0%,82.7% ) solid;
    border-radius: var(--ck-border-radius);
    background: white;

/* The "page" should cast a slight shadow (3D illusion). */
    box-shadow: 0 0 5px hsla( 0,0%,0%,.1 );

/* Center the "page". */
    margin: 0 auto;
}
```

All you need to do now is style the actual content of the editor. Start with defining some basic font styles:

```css
/* Set the default font for the "page" of the content. */
.document-editor .ck-content,
.document-editor .ck-heading-dropdown .ck-list .ck-button__label {
    font: 16px/1.6 "Helvetica Neue", Helvetica, Arial, sans-serif;
}
```

Then focus on headings and paragraphs. Note that what the users see in the headings dropdown should correspond to the actual edited content for the best user experience.

> **Note**
>
> It is recommended to use the `.ck-content` CSS class to visually style the content of the editor (headings, paragraphs, lists, etc.).

```css
/* Adjust the headings dropdown to host some larger heading styles. */
.document-editor .ck-heading-dropdown .ck-list .ck-button__label {
    line-height: calc( 1.7 * var(--ck-line-height-base) * var(--ck-font-size-base) );
    min-width: 6em;
}

/* Scale down all heading previews because they are way too big to be presented in the UI.
Preserve the relative scale, though. */
.document-editor .ck-heading-dropdown .ck-list .ck-button:not(.ck-heading_paragraph) .ck-button__label {
    transform: scale(0.8);
    transform-origin: left;
}

/* Set the styles for "Heading 1". */
.document-editor .ck-content h2,
.document-editor .ck-heading-dropdown .ck-heading_heading1 .ck-button__label {
    font-size: 2.18em;
    font-weight: normal;
}

.document-editor .ck-content h2 {
    line-height: 1.37em;
    padding-top: .342em;
    margin-bottom: .142em;
}

/* Set the styles for "Heading 2". */
.document-editor .ck-content h3,
.document-editor .ck-heading-dropdown .ck-heading_heading2 .ck-button__label {
    font-size: 1.75em;
    font-weight: normal;
    color: hsl( 203, 100%, 50% );
}

.document-editor .ck-heading-dropdown .ck-heading_heading2.ck-on .ck-button__label {
    color: var(--ck-color-list-button-on-text);
}

/* Set the styles for "Heading 2". */
.document-editor .ck-content h3 {
    line-height: 1.86em;
    padding-top: .171em;
    margin-bottom: .357em;
}

/* Set the styles for "Heading 3". */
.document-editor .ck-content h4,
.document-editor .ck-heading-dropdown .ck-heading_heading3 .ck-button__label {
    font-size: 1.31em;
    font-weight: bold;
}

.document-editor .ck-content h4 {
    line-height: 1.24em;
    padding-top: .286em;
    margin-bottom: .952em;
}

/* Set the styles for "Paragraph". */
.document-editor .ck-content p {
    font-size: 1em;
    line-height: 1.63em;
    padding-top: .5em;
    margin-bottom: 1.13em;
}
```

A finishing touch that makes the block quotes more sophisticated and the styling is complete.

```css
/* Make the block quoted text serif with some additional spacing. */
.document-editor .ck-content blockquote {
    font-family: Georgia, serif;
    margin-left: calc( 2 * var(--ck-spacing-large) );
    margin-right: calc( 2 * var(--ck-spacing-large) );
}
```

### Summary

The document editor is ready to use. Still, you may want to configure some features like [highlight](../../../api/module_highlight_highlightconfig-HighlightConfig.html), [font size](../../../api/module_font_fontconfig-FontSizeConfig.html) or [font family](../../../api/module_font_fontconfig-FontFamilyConfig.html) for the best editing experience.

Thanks to the [`DecoupledEditor`](../../../api/module_editor-decoupled_decouplededitor-DecoupledEditor.html) used as a foundation, you can experiment and create custom user interface layouts quickly while preserving the feature set, accessibility support (for example, [keyboard navigation](#ckeditor5/latest/features/accessibility.html--keyboard-shortcuts) in the toolbar), and more.

<a id="ckeditor5/latest/framework/deep-dive/ui/external-ui.html">source file: "ckeditor5/latest/framework/deep-dive/ui/external-ui.html"</a>

## Third-party UI

You can run CKEditor 5 with a completely separate, third-party user interface built on top of its base editor classes.

In this guide, a [classic-like](#ckeditor5/latest/getting-started/setup/editor-types.html--classic-editor) editor will be bound to a completely separate, existing UI created in [Bootstrap](http://getbootstrap.com/), providing the basic structure and toolbar items necessary to start editing.

### Readying the editor side

The editor types, such as the [classic](#ckeditor5/latest/getting-started/setup/editor-types.html--classic-editor) or [inline editor](#ckeditor5/latest/getting-started/setup/editor-types.html--inline-editor), have a dedicated default user interface and a theme. However, only a limited subset of features is required to create an editor instance bound to a Bootstrap UI. You need to import them first:

**NPM**

```js
// Basic classes to create an editor.
import {
	Editor,
	ComponentFactory,
	EditorUI,
	EditorUIView,
	InlineEditableUIView,
	ElementReplacer,
	FocusTracker,
	// Interfaces to extend the basic Editor API.
	ElementApiMixin,
	// Helper function for adding interfaces to the Editor class.
	mix,
	// Helper function that gets the data from an HTML element that the Editor is attached to.
	getDataFromElement,
	// Helper function that binds the editor with an HTMLForm element.
	attachToForm,
	// Basic features that every editor should enable.
	Clipboard,
	Enter,
	Paragraph,
	Typing,
	UndoEditing,
	// Basic features associated with the edited content.
	BoldEditing,
	ItalicEditing,
	UnderlineEditing,
	HeadingEditing,
	CKEditorError
} from 'ckeditor5';
```

**CDN**

```js
// Basic classes to create an editor.
const {
	Editor,
	ComponentFactory,
	EditorUI,
	EditorUIView,
	InlineEditableUIView,
	ElementReplacer,
	FocusTracker,
	// Interfaces to extend the basic Editor API.
	ElementApiMixin,
	// Helper function for adding interfaces to the Editor class.
	mix,
	// Helper function that gets the data from an HTML element that the Editor is attached to.
	getDataFromElement,
	// Helper function that binds the editor with an HTMLForm element.
	attachToForm,
	// Basic features that every editor should enable.
	Clipboard,
	Enter,
	Paragraph,
	Typing,
	UndoEditing,
	// Basic features associated with the edited content.
	BoldEditing,
	ItalicEditing,
	UnderlineEditing,
	HeadingEditing,
	CKEditorError
} = CKEDITOR;
```

> **Note**
>
> Note that instead of [`Bold`](../../../api/module_basic-styles_bold-Bold.html), which loads the default bold UI and bold editing feature, just the [`BoldEditing`](../../../api/module_basic-styles_bold_boldediting-BoldEditing.html) is imported. It provides the [engine](https://www.npmjs.com/package/@ckeditor/ckeditor5-engine) features associated with editing any bold text but does not come with the actual UI.
>
> Respectively, `ItalicEditing`, `UnderlineEditing`, `HeadingEditing`, and `UndoEditing` are also imported.

After importing the basic editor components, you can define the custom `BootstrapEditor` class that extends the [`Editor`](../../../api/module_core_editor_editor-Editor.html):

```js
// Extending the Editor class, which brings the base editor API.
export default class BootstrapEditor extends ElementApiMixin( Editor ) {
    constructor( config ) {
        super( config );

const sourceElement = config.root?.element;

if ( !sourceElement ) {
            // This example expects the editable host in `config.root.element` (see EditorConfig).
            throw new CKEditorError( 'bootstrap-editor-missing-root-element', null );
        }

// Remember the element the editor is created with.
        this.sourceElement = sourceElement;

// Create the ("main") root element of the model tree.
        this.model.document.createRoot();

// The UI layer of the editor.
        this.ui = new BootstrapEditorUI( this );

// When editor#element is a textarea inside a form element,
        // the content of this textarea will be updated on form submit.
        attachToForm( this );
    }

destroy() {
        // When destroyed, the editor sets the output of editor#getData() into editor#element...
        this.updateSourceElement();

// ...and destroys the UI.
        this.ui.destroy();

return super.destroy();
    }

static create( config ) {
        return new Promise( resolve => {
            const editor = new this( config );

const replacementElement = editor.sourceElement;

resolve(
                editor.initPlugins()
                    // Initialize the UI first. See the BootstrapEditorUI class to learn more.
                    .then( () => editor.ui.init( replacementElement ) )
                    // Fill the editable with the initial data.
                    .then( () => editor.data.init( getDataFromElement( replacementElement ) ) )
                    // Fire the `editor#ready` event that announce the editor is complete and ready to use.
                    .then( () => editor.fire( 'ready' ) )
                    .then( () => editor )
            );
        } );
    }
}
```

### Creating the Bootstrap UI

Although the editor is ready to use, it is just a bare editable area – that is not of much use to the users. You need to give it an actual interface with the toolbar and buttons.

> **Note**
>
> Refer to the Bootstrap [Getting started](https://getbootstrap.com/docs/4.0/getting-started/introduction/) guide to learn how to include Bootstrap in your web page.

With the Bootstrap framework loaded in the web page, you can define the actual UI of the editor in HTML:

```html

<div class="ck-editor">
    
    <div class="btn-toolbar" role="toolbar" aria-label="Editor toolbar">
        
        <div class="btn-group mr-2" role="group" aria-label="Headings">
            <div class="dropdown" id="heading">
             <button class="btn btn-primary btn-sm dropdown-toggle" type="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"><span>Headings</span></button>
             <div class="dropdown-menu" aria-labelledby="heading-button"></div>
            </div>
        </div>

<div class="btn-group mr-2" role="group" aria-label="Basic styles">
            <button type="button" class="btn btn-primary btn-sm" id="bold">B</button>
            <button type="button" class="btn btn-primary btn-sm" id="italic">I</button>
            <button type="button" class="btn btn-primary btn-sm" id="underline">U</button>
        </div>

<div class="btn-group mr-2" role="group" aria-label="Undo">
            <button type="button" class="btn btn-primary btn-sm" id="undo">←</button>
            <button type="button" class="btn btn-primary btn-sm" id="redo">→</button>
        </div>
    </div>

<div id="editor">
        <p>Hello world!</p>
    </div>
</div>
```

Although Bootstrap provides most of the CSS, it does not come with styles dedicated for [WYSIWYG](https://en.wikipedia.org/wiki/WYSIWYG) text editors and some tweaking is needed:

```css
/* Give the editor some space and limits using a border. */
.ck-editor {
    margin: 1em 0;
    border: 1px solid hsla(0, 0%, 0%, 0.1);
    border-radius: 4px;
}

/* Adding internal spacing, border and background to the toolbar.  */
.ck-editor .btn-toolbar {
    padding: .5rem;
    background: hsl(240, 14%, 97%);
    border-bottom: 1px solid hsla(0, 0%, 0%, 0.1);
}

/* Tweaking the editable area for better readability. */
.ck-editor .ck-editor__editable {
    padding: 2em 2em 1em;
    overflow: auto;
}

/* When in read–only mode, the editable should fade out. */
.ck-editor .ck-editor__editable.ck-read-only {
    background: hsl(0, 0%, 98%);
    color: hsl(0, 0%, 47%);
}

/* Make sure the headings dropdown button does not change its size
as different headings are selected. */
.ck-editor .dropdown-toggle span {
    display: inline-block;
    width: 100px;
    text-align: left;
    overflow: hidden;
    text-overflow: ellipsis;
    vertical-align: bottom;
}

/* Make the headings dropdown items visually distinctive. */
.ck-editor .heading-item_heading1 { font-size: 1.5em; }
.ck-editor .heading-item_heading2 { font-size: 1.3em; }
.ck-editor .heading-item_heading3 { font-size: 1.1em; }

.ck-editor [class*="heading-item_"] {
    line-height: 22px;
    padding: 10px;
}

.ck-editor [class*="heading-item_heading"] {
  font-weight: bold;
}

/* Give the basic styles buttons the icon–like look and feel. */
.ck-editor #bold { font-weight: bold; }
.ck-editor #italic { font-style: italic; }
.ck-editor #underline { text-decoration: underline; }
```

### Binding the UI with the editor

At this stage, you should bind the editor created at the beginning of this guide with the Bootstrap UI defined in HTML. All the UI logic will be wrapped into a separate class matching the `EditorUI` [interface](../../../api/module_ui_editorui_editorui-EditorUI.html). You may have noticed this line in the constructor of the `BootstrapEditor`:

```js
this.ui = new BootstrapEditorUI( this );
```

Define the `BootstrapEditorUI` and then have a closer look at the content of the class:

```js
// The class organizing the UI of the editor, binding it with existing Bootstrap elements in the DOM.
class BootstrapEditorUI extends EditorUI {
    constructor( editor ) {
        super( editor );

// A helper to easily replace the editor#element with editor.editable#element.
        this._elementReplacer = new ElementReplacer();

// The global UI view of the editor. It aggregates various Bootstrap DOM elements.
        const view = this._view = new EditorUIView( editor.locale );

// This is the main editor element in the DOM.
        view.element = $( '.ck-editor' );

// This is the editable view in the DOM. It will replace the data container in the DOM.
        view.editable = new InlineEditableUIView( editor.locale, editor.editing.view );

// References to the dropdown elements for further usage. See #_setupBootstrapHeadingDropdown.
        view.dropdownMenu = view.element.find( '.dropdown-menu' );
        view.dropdownToggle = view.element.find( '.dropdown-toggle' );

// References to the toolbar buttons for further usage. See #_setupBootstrapToolbarButtons.
        view.toolbarButtons = {};

[ 'bold', 'italic', 'underline', 'undo', 'redo' ].forEach( name => {
            // Retrieve the jQuery object corresponding with the button in the DOM.
            view.toolbarButtons[ name ] = view.element.find( `#${ name }` );
        } );
    }

// All EditorUI subclasses should expose their view instance
    // so other UI classes can access it if necessary.
    get view() {
        return this._view;
    }

init( replacementElement ) {
        const editor = this.editor;
        const view = this.view;
        const editingView = editor.editing.view;

// Make sure the EditorUIView is rendered. This will, for instance, create a place for UI elements
        // like floating panels detached from the main editor UI in DOM.
        this._view.render();

// Create an editing root in the editing layer. It will correspond with the
        // document root created in the constructor().
        const editingRoot = editingView.document.getRoot();

// The editable UI and editing root should share the same name.
        view.editable.name = editingRoot.rootName;

// Render the editable component in the DOM first.
        view.editable.render();

const editableElement = view.editable.element;

// Register editable element so it is available via getEditableElement() method.
        this.setEditableElement( view.editable.name, editableElement );

// Let the editable UI element respond to the changes in the global editor focus tracker
        // and let the focus tracker know about the editable element.
        this.focusTracker.add( editableElement );
        view.editable.bind( 'isFocused' ).to( this.focusTracker );

// Bind the editable UI element to the editing view, making it an end– and entry–point
        // of the editor's engine. This is where the engine meets the UI.
        editingView.attachDomRoot( editableElement );

// Setup the existing, external Bootstrap UI so it works with the rest of the editor.
        this._setupBootstrapToolbarButtons();
        this._setupBootstrapHeadingDropdown();

// Replace the editor#element with editor.editable#element.
        this._elementReplacer.replace( replacementElement, editableElement );

// Tell the world that the UI of the editor is ready to use.
        this.fire( 'ready' );
    }

destroy() {
        super.destroy();

// Restore the original editor#element.
        this._elementReplacer.restore();

// Destroy the view.
        this._view.editable.destroy();
        this._view.destroy();
    }

// This method activates Bold, Italic, Underline, Undo and Redo buttons in the toolbar.
    _setupBootstrapToolbarButtons() {
        // Implementation details are in the following snippets.
        // ...
    }

// This method activates the headings dropdown in the toolbar.
    _setupBootstrapHeadingDropdown() {
        // Implementation details are in the following snippets.
        // ...
    }
}
```

Almost every feature in the editor defines some command, for example, [`HeadingCommand`](../../../api/module_heading_headingcommand-HeadingCommand.html) or [`UndoCommand`](../../../api/module_undo_undocommand-UndoCommand.html). Commands can be executed:

```js
editor.execute( 'undo' );
```

They also come with default observable properties like `value` and `isEnabled`. These are the entry points when it comes to creating a custom user interface because their values represent the actual state of the editor. You can follow them in simple event listeners:

```js
const command = editor.commands.get( 'undo' );

command.on( 'change:isEnabled', ( evt, name, isEnabled ) => {
    if ( isEnabled ) {
        console.log( 'Whoa, you can undo some stuff now.' );
    } else {
        console.log( 'There is nothing to undo in the editor.' );
    }
} );
```

> **Note**
>
> To learn more about editor commands, check out the [`Command`](../../../api/module_core_command-Command.html) API. You can also `console.log` the [`editor.commands`](../../../api/module_core_editor_editor-Editor.html#member-commands) collection of a live editor to learn which commands it offers.

Knowing that, fill out the missing methods of the `BootstrapEditorUI`.

#### Binding the buttons to editor commands

`_setupBootstrapToolbarButtons()` is a method that binds Bootstrap toolbar buttons to the editor features (commands). It activates the corresponding editor commands upon clicking and makes the buttons listen to the state of the commands to update their CSS classes:

```js
// This method activates Bold, Italic, Underline, Undo and Redo buttons in the toolbar.
_setupBootstrapToolbarButtons() {
    const editor = this.editor;

for ( const name in this.view.toolbarButtons ) {
        // Retrieve the editor command corresponding with the ID of the button in the DOM.
        const command = editor.commands.get( name );
        const button = this.view.toolbarButtons[ name ];

// Clicking the buttons should execute the editor command...
        button.click( () => editor.execute( name ) );

// ...but it should not steal the focus so the editing is uninterrupted.
        button.mousedown( evt => evt.preventDefault() );

const onValueChange = () => {
            button.toggleClass( 'active', command.value );
        };

const onIsEnabledChange = () => {
            button.attr( 'disabled', () => !command.isEnabled );
        };

// Commands can become disabled, e.g. when the editor is read-only.
        // Make sure the buttons reflect this state change.
        command.on( 'change:isEnabled', onIsEnabledChange );
        onIsEnabledChange();

// Bold, Italic and Underline commands have a value that changes
        // when the selection starts in an element the command creates.
        // The button should indicate that e.g. you are editing text which is already bold.
        if ( !new Set( [ 'undo', 'redo' ] ).has( name ) ) {
            command.on( 'change:value', onValueChange );
            onValueChange();
        }
    }
}
```

#### Binding the dropdown to the heading commands

The dropdown in the toolbar is a more complex case.

First, it must be populated with heading options for the users to select from. Then, clicking each option must execute a related heading command in the editor. Finally, the dropdown button and the dropdown menu items must reflect the state of the editor, for example, when the selection lands in a heading, a proper menu item should become active and the button should show the name of the heading level.

```js
// This method activates the headings dropdown in the toolbar.
_setupBootstrapHeadingDropdown() {
    const editor = this.editor;
    const dropdownMenu = this.view.dropdownMenu;
    const dropdownToggle = this.view.dropdownToggle;

// Retrieve the editor commands for heading and paragraph.
    const headingCommand = editor.commands.get( 'heading' );
    const paragraphCommand = editor.commands.get( 'paragraph' );

// Create a dropdown menu entry for each heading configuration option.
    editor.config.get( 'heading.options' ).map( option => {
        // Check if options is a paragraph or a heading as their commands differ slightly.
        const isParagraph = option.model === 'paragraph';

// Create the menu item DOM element.
        const menuItem = $(
            `<a href="#" class="dropdown-item heading-item_${ option.model }">` +
                `${ option.title }` +
            '</a>'
        );

// Upon click, the dropdown menu item should execute the command and focus
        // the editing view to keep the editing process uninterrupted.
        menuItem.click( () => {
            const commandName = isParagraph ? 'paragraph' : 'heading';
            const commandValue = isParagraph ? undefined : { value: option.model };

editor.execute( commandName, commandValue );
            editor.editing.view.focus();
        } );

dropdownMenu.append( menuItem );

const command = isParagraph ? paragraphCommand : headingCommand;

// Make sure the dropdown and its items reflect the state of the
        // currently active command.
        const onValueChange = isParagraph ? onValueChangeParagraph : onValueChangeHeading;
        command.on( 'change:value', onValueChange );
        onValueChange();

// Heading commands can become disabled, e.g. when the editor is read-only.
        // Make sure the UI reflects this state change.
        command.on( 'change:isEnabled', onIsEnabledChange );

onIsEnabledChange();

function onValueChangeHeading() {
            const isActive = !isParagraph && command.value === option.model;

if ( isActive ) {
                dropdownToggle.children( ':first' ).text( option.title );
            }

menuItem.toggleClass( 'active', isActive );
        }

function onValueChangeParagraph() {
            if ( command.value ) {
                dropdownToggle.children( ':first' ).text( option.title );
            }

menuItem.toggleClass( 'active', command.value );
        }

function onIsEnabledChange() {
            dropdownToggle.attr( 'disabled', () => !command.isEnabled );
        }
    } );
}
```

### Running the editor

When the editor classes and the user interface are ready, it is time to run the editor. Just make sure all the plugins are loaded and the source element is set in [`config.root.element`](../../../api/module_core_editor_editorconfig-EditorConfig.html#member-root):

```js
BootstrapEditor.create( {
    root: {
        element: $( '#editor' ).get( 0 )
    },
    plugins: [
        Clipboard, Enter, Typing, Paragraph,
        BoldEditing, ItalicEditing, UnderlineEditing, HeadingEditing, UndoEditing
    ]
} )
.then( editor => {
    window.editor = editor;
} )
.catch( err => {
    console.error( err.stack );
} );
```

<a id="ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html">source file: "ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html"</a>

## Deep dive into focus tracking

**Focus is where all the keyboard interactions (events) take place.** It is an essential concept for any piece of a web page operated with a keyboard, be it a physical keyboard of your laptop or a software keyboard of your smartphone. And CKEditor 5 being a rich text editor is no exception here.

### What is focus and why it matters for CKEditor?

#### What is focus?

Every time you click a text field or an editor, it automatically prepares to accept your text. It is no longer just a static container for letters but something you can interact with using your keyboard. And you know it because you can see the familiar blinking caret somewhere inside of it. This subtle action called a **focus change** takes place hundreds of times every day as you navigate web pages, type your search queries, chat with your friends and fill in checkout forms when online shopping.

Focusing text fields feels so natural we usually do not give it much thought. But without this simple action, there would be no way to type text. Where would it go if there was no focused field? Focus informs the software about your intentions and it is synonymous with the **context**.

#### Focus in CKEditor

CKEditor is more than a simple text field. Yes, it has the main space where you type your text but other places also allow you to type, for instance, a link URL field or a form with plenty of inputs allowing you to configure the look of a table.

And when many places accept focus, there must be some systems out there to discover and manage it. These systems work, for instance, so you will not find yourself in a situation where CKEditor 5 loses focus (or gets **blurred**) and you cannot type your text. Or they make sure you can see and use the editor toolbar as long as you keep editing. These are just a few examples of why focus management systems are necessary. Now it should also be clear that they are essential for the editing experience.

In the following chapters of this guide, we will explain how these systems work, what makes CKEditor “focusable”, and how to develop new editor features so they fit into the existing focus management systems and patterns:

* [**The first section**](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-in-the-editor-engine) explains how the editor [engine](#ckeditor5/latest/framework/architecture/editing-engine.html) manages focus and what tools exist there to help you out when developing new features.
* In [**the second section**](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-in-the-editor-ui), we will show you how the [user interface](#ckeditor5/latest/framework/architecture/ui-library.html) of the editor tracks focus and how various UI components take advantage of that, for instance, to provide accessibility.
* In [**the last part**](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-state-analysis), we will use the knowledge from previous sections in a real–life scenario and analyze how all these tools and systems work together.

### Focus in the editor engine

> **Note**
>
> Keep in mind that information in this chapter concerns the editor **engine layer only**. To learn about focus in the user interface, check out the [next section](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-in-the-editor-ui) of this guide.

The main editable area of CKEditor 5 WYSIWYG editor can be focused thanks to the [`contenteditable`](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Editable_content) DOM attribute. This attribute tells the web browser that a web page element can be edited like any other text field, which also means it must be able to receive focus.

Each root of the editing view has the `contenteditable` attribute. The editing view uses the [`FocusObserver`](../../../api/module_engine_view_observer_focusobserver-FocusObserver.html) (learn more about [view observers](#ckeditor5/latest/framework/architecture/editing-engine.html--observers)) to track focus in editable elements by listening to native DOM `focus` and `blur` events coming from them.

> **Note**
>
> Already confused? Take a look at the [editing engine guide](#ckeditor5/latest/framework/architecture/editing-engine.html--observers) that explains what the editing view, editable elements, and other building blocks of CKEditor 5 are.

#### Checking if the view document is focused

You can check if the view document is focused using its [observable](#ckeditor5/latest/framework/deep-dive/observables.html) [`isFocused`](../../../api/module_engine_view_document-ViewDocument.html#member-isFocused) property. Create an editor instance and execute the following code:

```js
console.log( editor.editing.view.document.isFocused );
```

If you run this snippet from the web browser’s developer console, it should return `false` unless you managed to keep the editor focused (for example, by running a debugger and freezing the DOM). This happens because the editor loses focus the moment you switch to developer tools to execute the snippet.

How do you know `isFocused` actually works? Since it is observable, you can see how it changes live:

```js
editor.editing.view.document.on( 'change:isFocused', ( evt, data, isFocused ) => {
    console.log( `View document is focused: ${ isFocused }.` );
} );
```

Click the editable area of the editor and then click somewhere else – the `isFocused` property will change its value when you do that. The same will also happen if you run an editor with [**multiple editing roots**](#ckeditor5/latest/examples/builds/multi-root-editor.html) and navigate across them.

To spice things up even more, you should also know `isFocused` will change when you focus any [**nested editable**](#ckeditor5/latest/framework/tutorials/widgets/implementing-a-block-widget.html) in the content (take, for example, a [caption of an image](#ckeditor5/latest/features/images/images-captions.html)). Sounds weird, right? This is because every nested editable in the content has the `contenteditable` attribute, too, and for the web browser moving your caret inside it means the main editable element is blurred and the nested one is focused.

#### How to focus the editor?

The simplest way to focus the editor is to call the [`editor.focus()`](../../../api/module_core_editor_editor-Editor.html#function-focus) method.

However, you may wish to explicitly focus the editable area of CKEditor 5 when a certain action is executed (for example, a button is clicked). To do that, use the [`focus()`](../../../api/module_engine_view_view-EditingView.html#function-focus) method of the editing view:

```js
editor.editing.view.focus();
```

This snippet focuses the editable that has the selection. If the editor has not been focused yet, this will focus the first editable. If an editor has many editing roots and the user was editing content, focus will be brought back where the user left off.

> **Note**
>
> Focusing the editor does not change its selection. If you want to focus the editor and move the caret to a specific position, you should call `editor.editing.view.focus()` first and then use the [`setSelection()`](../../../api/module_engine_model_writer-ModelWriter.html#function-setSelection:NODE_OFFSET) method of the [model writer](#ckeditor5/latest/framework/architecture/editing-engine.html--model) to change the selection.

### Focus in the editor UI

If you read the [previous section](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-in-the-editor-engine) of this guide you should know that there is already a layer responsible for tracking focus implemented in the [editor engine](#ckeditor5/latest/framework/architecture/editing-engine.html). But because the [editor framework is modular](#ckeditor5/latest/framework/architecture/intro.html), this layer is only concerned by the focus in editable roots of the editor and it knows nothing of the user interface. This granularity makes it possible, for instance, to create a fully–functioning editor without the UI.

As for the user interface of CKEditor 5, it is a composition of multiple components [organized as a tree](#ckeditor5/latest/framework/architecture/ui-library.html--view-collections-and-the-ui-tree). This tree determines not only the logical structure of the UI (a toolbar has a dropdown, a dropdown has a button, a button has an icon, etc.) but also its behavior, and that includes tracking and maintaining focus as the user navigates and interacts with various pieces of the interface.

> **Note**
>
> Feeling overwhelmed? Take a look at the [UI library guide](#ckeditor5/latest/framework/architecture/ui-library.html) and learn some basics about how the UI of CKEditor 5 works and what its main building blocks are.

To sum up, there are two main reasons why focus is being tracked separately on the UI level:

* **To make sure the editor (as a whole) never loses focus unless the user wants it to.**\
  For instance, take a look at the [inline editor](#ckeditor5/latest/examples/builds/inline-editor.html). As long as the user edits text in the main editable area or configures its properties in any pop-up, dropdown, or panel, the main editor toolbar must remain visible (because the focus is somewhere in the UI). Only when the user finishes editing and moves somewhere else on a web page, the toolbar can disappear.
* **To make the UI accessible to users who navigate it using screen readers and other assistive technologies.**\
  These users not only write text using the keyboard but also use it to navigate across toolbar buttons, panels, dropdowns, etc. The UI of the editor must constantly keep track of which component is currently focused, for example, to allow navigation using `Tab`, `Esc` and arrow keys.

#### Tools and architecture

Focus management lives next to the [user interface element tree](#ckeditor5/latest/framework/architecture/ui-library.html--view-collections-and-the-ui-tree) and its architecture is also based on components that respond to user actions within its boundaries and their children. Take a look at a common keyboard navigation scenario in a [classic editor](#ckeditor5/latest/examples/builds/classic-editor.html) instance:

Here are the focus layers that play a role in the navigation and a brief overview of what happens at each layer:

1. The root of the focus tree is the [`ClassicEditorUI`](../../../api/module_editor-classic_classiceditorui-ClassicEditorUI.html) class. It creates a [global focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--a-note-about-the-global-focus-tracker) for the entire editor (you can access it via [`editor.ui.focusTracker`](../../../api/module_ui_editorui_editorui-EditorUI.html#member-focusTracker)).

2. When editing text, you can hit the `Alt`+`F10` keystroke to focus the main editor toolbar, which is the second focus layer.

* The [`ToolbarView`](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html) component brings a focus tracker that keeps an eye on its children so that when a user navigates across the toolbar using the keyboard arrows, it is clear which item is focused.
   * Toolbars also use a [focus cycler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class) to provide continuous navigation. For instance, navigating to the next item when the last one is focused brings the focus back to the beginning of the toolbar.

3. When a user selects a toolbar item, its `focus()` method is executed. That brings us to the third layer.
   * Some components of the toolbar are simple (like [`ButtonView`](../../../api/module_ui_button_buttonview-ButtonView.html)) and their DOM elements are leaves of the focus tree. But some components, for instance, the [`DropdownView`](../../../api/module_ui_dropdown_dropdownview-DropdownView.html), are containers and allow the focus to go deeper. Each dropdown has a focusable button and can host one child view in its [`DropdownPanelView`](../../../api/module_ui_dropdown_dropdownpanelview-DropdownPanelView.html). It does not need a focus tracker because there are only two ways a user can navigate it: down its panel or away from it.

4. When a user enters the dropdown’s panel, they visit another (fourth) layer of focus. This time it is the [`ListView`](../../../api/module_ui_list_listview-ListView.html) that, like the `ToolbarView`, also needs a focus tracker and a focus cycler to allow smooth keyboard navigation across its items.

5. The outermost leaf of the focus tree in this example is a [`ListItemView`](../../../api/module_ui_list_listitemview-ListItemView.html). It has the [`focus()`](../../../api/module_ui_list_listitemview-ListItemView.html#function-focus) method that focuses its element in the DOM.

And here is the summary of the tools used by each focus layer (UI component):

| Focus layer |                                                                                              | Needs [focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class)? | Needs [keystroke handler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-keystrokehandler-class)? | Needs [focus cycler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class)? |
| ----------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| 1           | [`ClassicEditorUI`](../../../api/module_editor-classic_classiceditorui-ClassicEditorUI.html) | ✅                                                                                                                  | ✅                                                                                                                          | ❌                                                                                                                |
| 2           | [`ToolbarView`](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html)                 | ✅                                                                                                                  | ✅                                                                                                                          | ✅                                                                                                                |
| 3           | [`DropdownView`](../../../api/module_ui_dropdown_dropdownview-DropdownView.html)             | ❌                                                                                                                  | ✅                                                                                                                          | ❌                                                                                                                |
| 4           | [`ListView`](../../../api/module_ui_list_listview-ListView.html)                             | ✅                                                                                                                  | ✅                                                                                                                          | ✅                                                                                                                |
| 5           | [`ListItemView`](../../../api/module_ui_list_listitemview-ListItemView.html)                 | ❌                                                                                                                  | ❌                                                                                                                          | ❌                                                                                                                |

Most components have [focus trackers](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class) to keep up with the focus inside of them. Some components that host more children also use [focus cyclers](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class) and [keystroke handlers](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-keystrokehandler-class) to help the user navigate across them. You can learn how to use them in the later sections of this guide:

* [Implementing focusable UI components](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--implementing-focusable-ui-components),
* [Using the `FocusTracker` class](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class),
* [Using the `KeystrokeHandler` class](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-keystrokehandler-class),
* [Using the `FocusCycler` class](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class).

#### Implementing focusable UI components

Any UI [view](#ckeditor5/latest/framework/architecture/ui-library.html--views) can be focusable. To become one, a view must implement the `focus()` method that focuses the DOM [element](../../../api/module_ui_view-View.html#member-element) and the `tabindex="-1"` attribute set on the element that prevents the native navigation using the keyboard (which should be handled by the [focus cycler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class) on the parent–level):

> **Note**
>
> The [`tabindex="-1"`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex) is a native DOM attribute that controls whether a DOM element can be focused (and in which order). Setting its value to `"-1"` tells the web browser that it should exclude it from the native keyboard navigation and allow it only to be focused using JavaScript. Because your component will belong to the editor focus management system, you should do that if you want to avoid collisions with the web browser.

**NPM**

```js
import { View } from 'ckeditor5';

class MyListItemView extends View {
	constructor( locale, text ) {
		super( locale );

// More initializations.
		// ...

this.setTemplate( {
			tag: 'li',
			attributes: {
				tabindex: -1
			},
			children: [ text ]
		} );
	}

// More methods.
	// ...

focus() {
		this.element.focus();
	}
}
```

**CDN**

```js
const { View } = CKEDITOR;

class MyListItemView extends View {
	constructor( locale, text ) {
		super( locale );

// More initializations.
		// ...

this.setTemplate( {
			tag: 'li',
			attributes: {
				tabindex: -1
			},
			children: [ text ]
		} );
	}

// More methods.
	// ...

focus() {
		this.element.focus();
	}
}
```

If a view has many focusable children (like a list), the `focus()` method should focus the first child:

**NPM**

```js
import { View } from 'ckeditor5';

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

this.items = this.createCollection();

this.setTemplate( {
			tag: 'ul',
			children: this.items
		} );
	}

// More methods.
	// ...

focus() {
		if ( this.items.length ) {
			// This will call MyListItemView#focus().
			this.items.first.focus();
		}
	}
}
```

**CDN**

```js
const { View } = CKEDITOR;

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

this.items = this.createCollection();

this.setTemplate( {
			tag: 'ul',
			children: this.items
		} );
	}

// More methods.
	// ...

focus() {
		if ( this.items.length ) {
			// This will call MyListItemView#focus().
			this.items.first.focus();
		}
	}
}
```

Focusable views are what make it possible to navigate the interface of CKEditor using the keyboard. In the [next section](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class), you will learn how parent views keep track of focus among their children using the `FocusTracker` class.

#### Using the `FocusTracker` class

One of the key focus management helpers in the CKEditor 5 UI is the [`FocusTracker`](../../../api/module_utils_focustracker-FocusTracker.html) class and its instances. They work at the DOM level and offer a fairly simple API:

* Methods to [`add()`](../../../api/module_utils_focustracker-FocusTracker.html#function-add) and [`remove()`](../../../api/module_utils_focustracker-FocusTracker.html#function-remove) tracked DOM elements.
* An observable [`isFocused`](../../../api/module_utils_focustracker-FocusTracker.html#member-isFocused) property telling the world that one of the tracked elements has focus in the DOM.
* An observable [`focusedElement`](../../../api/module_utils_focustracker-FocusTracker.html#member-focusedElement) property that precisely says which DOM element is focused.

Focus trackers listen to DOM `focus` and `blur` events coming from elements they track and they determine if any is currently focused. As a rule of thumb, a [parent](#ckeditor5/latest/framework/architecture/ui-library.html--view-collections-and-the-ui-tree) to more than one focusable element should have a focus tracker.

> **Note**
>
> Keep in mind that simple components that have no focusable children or just a single focusable child may not need a focus tracker.

##### A note about the global focus tracker

Each editor instance has a **global focus tracker** that can be accessed via [`editor.ui.focusTracker`](../../../api/module_ui_editorui_editorui-EditorUI.html#member-focusTracker). It is a special instance that glues all the pieces of the user interface together (including the editing root) and stores the focus state of the **entire editor instance**.

You can **always** listen to the global focus tracker and tell if the user is using the UI:

```js
editor.ui.focusTracker.on( 'change:isFocused', ( evt, data, isFocused ) => {
    console.log( `The editor is focused: ${ isFocused }.` );
} );
```

The class responsible for the UI of the editor ([`ClassicEditorUI`](../../../api/module_editor-classic_classiceditorui-ClassicEditorUI.html), [`InlineEditorUI`](../../../api/module_editor-inline_inlineeditorui-InlineEditorUI.html), etc.) **must** inform the global focus tracker about the focusable building blocks of the interface, for instance, editable roots of the editor (where the editing takes place) or toolbars.

The same applies to plugins bringing any focusable UI. For instance, the [contextual balloon](../../../api/module_ui_panel_balloon_contextualballoon-ContextualBalloon.html) plugin that offers a shared floating balloon used by many features across the project (link editing, image tools, widget toolbars, etc.) also registers the balloon in the global focus tracker. Please keep this in mind when developing your custom editor plugins.

The continuity of editor focus is maintained **only** when the global focus tracker is aware of **all** focusable blocks of the UI. Their location in DOM is irrelevant: next to the editable root, in the [“body” collection](../../../api/module_ui_editorui_bodycollection-BodyCollection.html) or even somewhere else. To the global focus tracker they are all pieces of the same editor.

> **Note**
>
> Check out the [Focus state analysis section ](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-state-analysis)to see the global focus tracker working in a real–life scenario.

##### A practical example

Take a look at the following example of a list that has multiple items, a classic use case for a focus tracker:

**NPM**

```js
import { View, FocusTracker } from 'ckeditor5';

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// A view collection containing items of the list.
		this.items = this.createCollection();

// Setting the template.
		// ...

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();
	}

// More methods.
	// ...
}
```

**CDN**

```js
const { View, FocusTracker } = CKEDITOR;

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// A view collection containing items of the list.
		this.items = this.createCollection();

// Setting the template.
		// ...

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();
	}

// More methods.
	// ...
}
```

To make sure your focus tracker instance and the `items` view collection stay synchronized, create listeners that will update the tracker when a new child view is added or some are removed ([view collections fire events](../../../api/module_ui_viewcollection-ViewCollection.html)). The best way to do that is inside the [`render()`](../../../api/module_ui_view-View.html#function-render) method:

```js
// Previously imported packages.
// ...

class MyListView extends View {
    constructor( locale ) {
        // More initializations.
        // ...
    }

// More methods.
    // ...

render() {
        super.render();

// Children added before rendering should be known to the #focusTracker.
        for ( const item of this.items ) {
            this.focusTracker.add( item.element );
        }

// Make sure items added to the collection are recognized by the #focusTracker.
        this.items.on( 'add', ( evt, item ) => {
            this.focusTracker.add( item.element );
        } );

// Make sure items removed from the collection are ignored by the #focusTracker.
        this.items.on( 'remove', ( evt, item ) => {
            this.focusTracker.remove( item.element );
        } );
    }

// More methods.
    // ...
}
```

The `MyListView` can now track focused children, and it is time to help the user navigate them using the keyboard. In the next section, you will create a [keystroke handler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-keystrokehandler-class) that will bring you closer to the goal.

#### Using the `KeystrokeHandler` class

The [`KeystrokeHandler`](../../../api/module_utils_keystrokehandler-KeystrokeHandler.html) helper class allows registering callbacks for the keystrokes. It is used in many views across the UI of the editor for many purposes. For instance, it is responsible for focusing the toolbar on the `Alt`+`F10` key press or it opens the link pop-up form when you hit `Ctrl`+`L` on a selected text.

However, in the context of focus management, it is used by the [focus cycler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focuscycler-class) you will get familiar with in the next section. You can learn more about the [`KeystrokeHandler`](../../../api/module_utils_keystrokehandler-KeystrokeHandler.html) class in the API documentation but for now, you should only know how to create and initialize it before moving forward:

**NPM**

```js
import { FocusCycler, View, FocusTracker, KeystrokeHandler } from 'ckeditor5';

export default class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();
	}

render() {
		super.render();

// Setting the focus tracker.
		// ...

// Start listening for the keystrokes coming from #element, which will allow
		// the focus cycler to handle the keyboard navigation.
		this.keystrokes.listenTo( this.element );
	}

destroy() {
		// Stop listening to all keystrokes when the view is destroyed.
		this.keystrokes.destroy();
	}

// More methods.
	// ...
}
```

**CDN**

```js
const { FocusCycler, View, FocusTracker, KeystrokeHandler } = CKEDITOR;

export default class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();
	}

render() {
		super.render();

// Setting the focus tracker.
		// ...

// Start listening for the keystrokes coming from #element, which will allow
		// the focus cycler to handle the keyboard navigation.
		this.keystrokes.listenTo( this.element );
	}

destroy() {
		// Stop listening to all keystrokes when the view is destroyed.
		this.keystrokes.destroy();
	}

// More methods.
	// ...
}
```

#### Using the `FocusCycler` class

[`FocusCycler`](../../../api/module_ui_focuscycler-FocusCycler.html) helps the user navigate the user interface using the keystrokes (arrow keys, `Tab`, `Return`, `Esc`, etc.). This helper class was created with components hosting multiple children in mind, for instance, lists, toolbars or forms. It _cycles_ over their children so, for instance, if the last child is focused and the user wants to move forward, the focus is moved back to the first child. It also supports components that have a variable (dynamic) number of focusable children.

Each focus cycler instance works together with a [focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-focustracker-class) and a [keystroke handler](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--using-the-keystrokehandler-class). The former delivers the current state of the focus, while the latter helps the cycler integrate with keystrokes, for instance, to focus the next item in the list on the down arrow key press.

Take a look at the example list class using focus cycler, keystroke handler and focus tracker instances together to enable the keyboard navigation. First, all the helpers must be created:

**NPM**

```js
import { FocusCycler, View, FocusTracker, KeystrokeHandler } from 'ckeditor5';

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// The view collection containing items of the list.
		this.items = this.createCollection();

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();

// The focus cycler that glues it all together.
		this.focusCycler = new FocusCycler( {
			focusables: this.items,
			focusTracker: this.focusTracker,
			keystrokeHandler: this.keystrokes,
			actions: {
				// Navigate list items backward using the arrow up key.
				focusPrevious: 'arrowup',

// Navigate toolbar items forward using the arrow down key.
				focusNext: 'arrowdown'
			}
		} );
	}

// More methods.
	// ...
}
```

**CDN**

```js
const { FocusCycler, View, FocusTracker, KeystrokeHandler } = CKEDITOR;

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// More initializations.
		// ...

// The view collection containing items of the list.
		this.items = this.createCollection();

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();

// Navigate toolbar items forward using the arrow down key.
				focusNext: 'arrowdown'
			}
		} );
	}

// More methods.
	// ...
}
```

Similarly to the previous sections of this guide, feed the focus tracker and synchronize it with the list items collection in the `render()` method. Since the [`MyListView#element`](../../../api/module_ui_view-View.html#member-element) has already been rendered at that stage, this is also the right moment to start listening to the keyboard events:

```js
// Previously imported packages.
// ...

class MyListView extends View {
    constructor( locale ) {
        // More initializations.
        // ...
    }

render() {
        super.render();

// Items added before rendering should be known to the #focusTracker.
        for ( const item of this.items ) {
            this.focusTracker.add( item.element );
        }

// Make sure items added to the collection are recognized by the #focusTracker.
        this.items.on( 'add', ( evt, item ) => {
            this.focusTracker.add( item.element );
        } );

// Make sure items removed from the collection are ignored by the #focusTracker.
        this.items.on( 'remove', ( evt, item ) => {
            this.focusTracker.remove( item.element );
        } );

// Start listening for the keystrokes coming from #element, which will allow
        // the #focusCycler to handle the keyboard navigation.
        this.keystrokes.listenTo( this.element );
    }

focus() {
        if ( this.items.length ) {
            // This will call MyListItemView#focus().
            this.items.first.focus();
        }
    }

destroy() {
        // Stop listening to all keystrokes when the view is destroyed.
        this.keystrokes.destroy();
    }

// More methods.
    // ...
}
```

#### Using all focus helpers together

The complete code of a list class that hosts multiple item views and supports the keyboard navigation across them (when it gets focused) looks as follows:

**NPM**

```js
import { FocusCycler, View, FocusTracker, KeystrokeHandler } from 'ckeditor5';

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// The view collection containing items of the list.
		this.items = this.createCollection();

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();

// Navigate toolbar items forward using the arrow down key.
				focusNext: 'arrowdown'
			}
		} );

// More intializations.
		// ...

this.setTemplate( {
				tag: 'ul',
				children: this.items
		} );
	}

render() {
		super.render();

// Items added before rendering should be known to the #focusTracker.
		for ( const item of this.items ) {
			this.focusTracker.add( item.element );
		}

// Make sure items added to the collection are recognized by the #focusTracker.
		this.items.on( 'add', ( evt, item ) => {
			this.focusTracker.add( item.element );
		} );

// Make sure items removed from the collection are ignored by the #focusTracker.
		this.items.on( 'remove', ( evt, item ) => {
			this.focusTracker.remove( item.element );
		} );

// Start listening for the keystrokes coming from #element, which will allow
		// the #focusCycler to handle the keyboard navigation.
		this.keystrokes.listenTo( this.element );
	}

focus() {
		if ( this.items.length ) {
			// This will call MyListItemView#focus().
			this.items.first.focus();
		}
	}

destroy() {
		// Stop listening to all keystrokes when the view is destroyed.
		this.keystrokes.destroy();
	}
}

class MyListItemView extends View {
	constructor( locale, text ) {
		super( locale );

// More initializations.
		// ...

this.setTemplate( {
			tag: 'li',
			attributes: {
				tabindex: -1
			},
			children: [ text ]
		} );
	}

// More methods.
	// ...

focus() {
		this.element.focus();
	}
}
```

**CDN**

```js
const { FocusCycler, View, FocusTracker, KeystrokeHandler } = CKEDITOR;

class MyListView extends View {
	constructor( locale ) {
		super( locale );

// The view collection containing items of the list.
		this.items = this.createCollection();

// The instance of the focus tracker that tracks focus in #items.
		this.focusTracker = new FocusTracker();

// The keystroke handler that will help the focus cycler respond to the keystrokes.
		this.keystrokes = new KeystrokeHandler();

// Navigate toolbar items forward using the arrow down key.
				focusNext: 'arrowdown'
			}
		} );

// More intializations.
		// ...

this.setTemplate( {
				tag: 'ul',
				children: this.items
		} );
	}

render() {
		super.render();

// Items added before rendering should be known to the #focusTracker.
		for ( const item of this.items ) {
			this.focusTracker.add( item.element );
		}

// Make sure items added to the collection are recognized by the #focusTracker.
		this.items.on( 'add', ( evt, item ) => {
			this.focusTracker.add( item.element );
		} );

// Make sure items removed from the collection are ignored by the #focusTracker.
		this.items.on( 'remove', ( evt, item ) => {
			this.focusTracker.remove( item.element );
		} );

// Start listening for the keystrokes coming from #element, which will allow
		// the #focusCycler to handle the keyboard navigation.
		this.keystrokes.listenTo( this.element );
	}

focus() {
		if ( this.items.length ) {
			// This will call MyListItemView#focus().
			this.items.first.focus();
		}
	}

destroy() {
		// Stop listening to all keystrokes when the view is destroyed.
		this.keystrokes.destroy();
	}
}

class MyListItemView extends View {
	constructor( locale, text ) {
		super( locale );

// More initializations.
		// ...

this.setTemplate( {
			tag: 'li',
			attributes: {
				tabindex: -1
			},
			children: [ text ]
		} );
	}

// More methods.
	// ...

focus() {
		this.element.focus();
	}
}
```

You can quickly run it in the context of an existing editor in the following way:

```js
ClassicEditor
    .create( {
        // The editor's configuration.
        // ...
    } )
    .then( editor => {
        const list = new MyListView( editor.locale );

// Create two example children.
        const firstChild = new MyListItemView( editor.locale, 'First child' );
        const secondChild = new MyListItemView( editor.locale, 'Second child' );

// Add children to the list.
        list.items.add( firstChild );
        list.items.add( secondChild );

// Render the list and put it in the DOM.
        list.render();
        editor.ui.view.body.add( list );

// Focus the list. This should focus the first child.
        // Use up and down keyboard arrows to cycle across the list items.
        list.focus();
    } )
    .catch( err => {
        console.error( err.stack );
    } );
```

Now you can use the keyboard arrows to cycle the focused list items:

### Focus state analysis

This section contains an analysis of a common focus navigation scenario in an [inline editor](#ckeditor5/latest/examples/builds/inline-editor.html). While the [previous section](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--focus-in-the-editor-ui) was focused on tools that make up the focus management system, this time we will focus on their state. This should help you better understand how all little pieces work in a bigger picture.

#### Scenario

Take a look at the following scenario where both mouse and keyboard are used to navigate the interface of the editor:

And here are the steps of the scenario:

1. The editor is not focused (the focus is somewhere else on the web page).
2. The [editable area](../../../api/module_ui_editableui_inline_inlineeditableuiview-InlineEditableUIView.html) gets focused using the mouse. The main toolbar shows up and because the link was clicked, the [toolbar view](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html) also pops up.
3. The `Tab` key is used to focus the [link preview](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html) in the balloon.
4. The `→` key is used to focus the [“Edit link” button](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html).
5. The `Space` key is used to execute the “Edit link” button. The focus moves to the [input](../../../api/module_link_ui_linkformview-LinkFormView.html#member-urlInputView) in the [`LinkFormView`](../../../api/module_link_ui_linkformview-LinkFormView.html).
6. The `Tab` key is used to move from the link URL field to the [“Update” button](../../../api/module_link_ui_linkformview-LinkFormView.html#member-saveButtonView).
7. The `Tab` key is used to move from the “Update” button to the [“Bookmarks” button](#ckeditor5/latest/features/bookmarks.html).
8. The `Esc` key is used to close the editing form.
9. The `Esc` key is used to close the link balloon and go back to the editable.

There are 3 focus tracker instances at play in the scenario:

1. The [`EditorUI#focusTracker`](../../../api/module_ui_editorui_editorui-EditorUI.html#member-focusTracker) (the [“global” focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--a-note-about-the-global-focus-tracker)),
2. The [`ToolbarView#focusTracker`](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html#member-focusTracker),
3. The [`LinkFormView#focusTracker`](../../../api/module_link_ui_linkformview-LinkFormView.html#member-focusTracker).

Let’s see how they react to the user actions (states were recorded **after** each step):

| Step | [`EditorUI#focusTracker`](../../../api/module_ui_editorui_editorui-EditorUI.html#member-focusTracker) |                  | [`ToolbarView#focusTracker`](../../../api/module_ui_toolbar_toolbarview-ToolbarView.html#member-focusTracker) |                    | [`LinkFormView#focusTracker`](../../../api/module_link_ui_linkformview-LinkFormView.html#member-focusTracker) |                  |
| ---- | ----------------------------------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------- | ---------------- |
|      | `isFocused`                                                                                           | `focusedElement` | `isFocused`                                                                                                   | `focusedElement`   | `isFocused`                                                                                                   | `focusedElement` |
| 1    | ❌                                                                                                     | `null`           | ❌                                                                                                             | `null`             | ❌                                                                                                             | `null`           |
| 2    | ✅                                                                                                     | editable         | ❌                                                                                                             | `null`             | ❌                                                                                                             | `null`           |
| 3    | ✅                                                                                                     | balloon panel    | ✅✅                                                                                                            | URL preview        | ❌                                                                                                             | `null`           |
| 4    | ✅                                                                                                     | balloon panel    |                                                                                                               | "Edit link" button | ❌                                                                                                             | `null`           |
| 5    | ✅                                                                                                     | balloon panel    | ❌                                                                                                             | `null`             | ✅                                                                                                             | URL input        |
| 6    | ✅                                                                                                     | balloon panel    | ❌                                                                                                             | `null`             | ✅                                                                                                             | "Save" button    |
| 7    | ✅                                                                                                     | balloon panel    | ❌                                                                                                             | `null`             | ✅                                                                                                             | "Cancel" button  |
| 8    | ✅                                                                                                     | editable         | ❌                                                                                                             | `null`             | ❌                                                                                                             | `null`           |
| 9    | ✅                                                                                                     | editable         | ❌                                                                                                             | `null`             | ❌                                                                                                             | `null`           |

#### Conclusions

* The [global focus tracker](#ckeditor5/latest/framework/deep-dive/ui/focus-tracking.html--a-note-about-the-global-focus-tracker) (the one you can access via `editor.ui.focusTracker`) is always aware of the focus state, even when the focus is in the farthest regions of the UI.

* It does not know which element is focused on deeper layers (for instance the “Edit link” button), though. All it knows is where the focus went (for example, from the editable to the balloon panel).
  * It lacks precise information about the focus in the link UI because this is the responsibility of the focus tracker of the link UI layer.
  * All editor features **can always depend on the global focus tracker** when necessary. For instance, the main editor toolbar is displayed as long as the global focus tracker knows the focus is somewhere in the editor.

* You can see that the focus management is modular: `ToolbarView` and `LinkFormView` only know about the focus as long as one of their children has it.

* Focus trackers belonging to `ToolbarView` and `LinkFormView` know precisely which element has focus. This is their region of interest and, unlike the global focus tracker of the editor, they need that information to allow navigation using the keyboard.

<a id="ckeditor5/latest/framework/deep-dive/ui/localization.html">source file: "ckeditor5/latest/framework/deep-dive/ui/localization.html"</a>

## Localization

### Introduction

All CKEditor 5 WYSIWYG editor features support message localization. It means that the user interface of any feature can be translated into various languages and regions depending on the user’s preferences.

CKEditor 5 translation system is open to third-party plugins. Any custom features that you introduce can be localized. The system also provides a way to add missing or overwrite existing translations and supports translating plural forms.

> **Warning**
>
> Make sure to use up-to-date CKEditor 5 development tool packages. Versions of the tools older than v19.0.1 do not provide support for features described in this guide.

#### Open translation API

The CKEditor 5 localization system focuses on the following points:

* Supporting the localization of third-party plugins.
* Making it possible to pass your own translations to fix missing or invalid localizations.
* Generating deterministic builds.
* Exposing easy-to-use APIs for providing translations and writing localizable content.
* Supporting plural forms in each step of the localization system for better translations.

#### Glossary of terms

Before we start, let us explain the meaning of terms that are crucial for the translation process:

* _A message_ – A string or an object that should be translated.\
  The string version works as a shortcut for the `{ id: message, string: message }` object form.
* _A message ID_ – A property used to distinguish messages.\
  It is useful for short messages where a collision might occur, like `%0 images`.
* _A message string_ – The default (English) form of the message.\
  When the message supports plural versions, this is the default singular version.
* _A message plural_ – An optional plural (English) version of the message.\
  The presence of this property indicates that the message should support both singular and plural forms.
* _A PO file (`.po`)_ – A file containing translations for the language in the [PO format](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html).\
  All localizable packages of CKEditor 5 contain such files in the `lang/translations/` directory.
* _A POT file (`.pot`)_ – A file containing source messages (English sentences) that will be translated.
* _A translation asset_ – A JavaScript file or a part of the file with generated translations for one language.

### Writing a localizable UI

All _messages_ that need localization should be passed to the special CKEditor 5’s [`t()` function](../../../api/module_utils_locale-Locale.html#member-t).

In JavaScript files, retrieve it as a standalone function, for example from the editor’s [`Locale`](../../../api/module_utils_locale-Locale.html) instance (`const { t } = editor.locale;`) or from any view method (`const t = this.t;`).

In TypeScript files, the translation tools can also detect direct `Locale#t()` calls based on type information, so `editor.t()`, `editor.locale.t()`, `locale.t()`, and `this.t()` are supported as well.

As the first argument, the `t()` function accepts either a string literal or an object literal containing the `id`, `string` and `plural` (optional) properties. The string literal will serve as both the _message ID_ and the _message string_.

As the second argument, the translation function accepts a value or an array of values. These values will be used to fill the placeholders in more advanced translation scenarios. If the `plural` property is specified, the first value will be used as the quantity determining the plural form.

> **Warning**
>
> Due to the fact that a static code analyzer is used in the translation process, the supported call patterns depend on the source file type. In JavaScript files, the analyzer looks for a function named exactly `t()`, so it should not be called on a `Locale` instance and it cannot have a different name. In TypeScript files, the analyzer also recognizes direct `Locale#t()` calls based on type information.
>
> For the same reason, the first argument can only be a string literal or an object literal. Variables cannot be passed.

When using the `t()` function, you can create your own _localizable messages_ or reuse _messages_ created in CKEditor 5 packages that your project depends on. In the case of reusing _messages_, you will not need to worry about translating them as all the work will be done by the CKEditor 5 team. Obviously, [your help in translating](#ckeditor5/latest/framework/contributing/contributing.html--translating) will still be appreciated!

For a simple _localizable messages_, use the string form for simplicity:

```js
const emojiName = 'cat';

// Assuming that the English language was picked:
t( 'insert emoji' ); // "insert emoji"
t( 'insert %0 emoji', emojiName ); // "insert cat emoji"
t( 'insert %0 emoji', [ emojiName ] ); // "insert cat emoji"
```

For more advanced scenarios, use plain object forms:

```js
const quantity = 3;

// Assuming that the English language was picked:
t( { string: '%0 emoji', id: 'ACTION_EMOJI' }, 'insert' ); // "insert emoji"
t( { string: '%0 emoji', plural: '%0 emojis', id: 'N_EMOJIS' }, quantity ); // "3 emojis"
t( { string: '%1 %0 emoji', plural: '%1 %0 emojis', id: 'ACTION_N_EMOJIS' }, [ quantity, 'Insert' ] ); // "Insert 3 emojis"
```

#### Example: Localizing the plugin UI

This example shows how to create a localizable user interface of a plugin. Here is how you can create a button that will insert a smiling face emoji. The button will have a localizable tooltip.

```ts
// Custom plugin configuration, including necessary imports.
// The code below should be put into a custom plugin class extending the Plugin class.
// ...

editor.ui.componentFactory.add( 'smilingFaceEmoji', locale => {
    const buttonView = new ButtonView( locale );

// The localized label.
    const label = editor.locale.t( 'Insert smiling face emoji' );

buttonView.set( {
        label,
        icon: emojiIcon,
        tooltip: true
    } );

buttonView.on( 'execute', () => {
        editor.execute( 'insertSmilingFaceEmoji' );
        editor.editing.view.focus();
    } );
} );

// The rest of the custom plugin configuration.
// ...
```

> **Warning**
>
> See [how to create a complete plugin](#ckeditor5/latest/framework/tutorials/crash-course/editor.html) to have a better understanding of creating CKEditor 5 plugins.

#### Example: Localizing pending actions

[Pending actions](../../../api/module_core_pendingactions-PendingActions.html) are used to inform the user that an action is in progress and they will lose data if they exit the editor at the given moment. Here is how you can localize them:

```js
class FileRepository {
    // More methods.
    // ...

updatePendingAction() {
        const pendingActions = this.editor.plugins.get( PendingActions );

const t = this.editor.t;
        const getMessage = value => t( 'Upload in progress (%0%).', value ); // Upload in progress (12%).

this._pendingAction = pendingActions.add( getMessage( this.uploadedPercent ) );
        this._pendingAction.bind( 'message' ).to( this, 'uploadedPercent', getMessage );
    }
}
```

### Adding translations and localizing the editor UI

First of all, if you found a missing or incorrect translation in any of CKEditor 5 features, [see how you can contribute to the project](#ckeditor5/latest/framework/contributing/contributing.html--translating). CKEditor 5 is an Open Source project used by people from all around the world, so your help will be appreciated by others.

Adding translations to the editor can be done in three ways to satisfy various needs.

* By [adding translations via the translation-service’s `add()` function](#ckeditor5/latest/framework/deep-dive/ui/localization.html--using-the-add-function).\
  This can be done before initiating the CKEditor 5 editor instance but it requires importing the CKEditor 5 utility function.
* By [extending the global `window.CKEDITOR_TRANSLATIONS` object](#ckeditor5/latest/framework/deep-dive/ui/localization.html--using-the-windowckeditor_translations-object).\
  This can be done before initiating the CKEditor 5 editor instance.
* By [creating `.po` files with translations](#ckeditor5/latest/framework/deep-dive/ui/localization.html--creating-po-files) in the `lang/translations/` directory of the published package like other CKEditor 5 packages do.\
  This option will be useful for third-party plugin creators as it allows bundling translations only for needed languages during the build step.

#### Using the `add()` function

The first option for adding translations is via [the translation-service’s `add()` helper](../../../api/module_utils_translation-service.html#function-add). This utility adds translations to the global `window.CKEDITOR_TRANSLATIONS` object by extending it. Since it needs to be imported, it works only before building the editor.

Starting with the CKEditor 5 v19.0.0 release, the `add()` method now accepts an optional `getPluralForm()` function as the third argument. This function is only needed for defining the plural form if no language file was loaded for a particular language. It also accepts an array of translations for a _message_ if the _message_ should support singular and plural forms.

```js
add( 'pl', {
    'Add space': [ 'Dodaj spację', 'Dodaj %0 spacje', 'Dodaj %0 spacji' ]
} );

// Assuming that the Polish language was picked:
t( { string: 'Add space', plural: 'Add %0 spaces' }, 1 ) // "Dodaj spację"
t( { string: 'Add space', plural: 'Add %0 spaces' }, 2 ) // "Dodaj 2 spacje"
t( { string: 'Add space', plural: 'Add %0 spaces' }, 5 ) // "Dodaj 5 spacji"
```

#### Using the `window.CKEDITOR_TRANSLATIONS` object

The second option is adding translations via the global `window.CKEDITOR_TRANSLATIONS` object.

For each language that should be supported, the `dictionary` property of this object should be extended and the `getPluralForm()` function should be provided if missing.

The `dictionary` property is a `message ID ⇒ translations` map, where the `translations` can be either a string or an array of translations with plural forms for the given language if the message should support plural forms as well.

The `getPluralForm()` property should be a function that returns the plural form index for a given quantity. Note that when using CKEditor 5 translations, this property will be defined by _CKEditor 5 translation assets_.

Check an example below that demonstrates a part of the `window.CKEDITOR_TRANSLATIONS` object with Polish translations for the `Cancel` and `Add space` _message IDs_:

```js
{
    // Each key should be a valid language code.
    pl: {
        // A map of translations for the 'pl' language.
        dictionary: {
            'Cancel': 'Anuluj',
            'Add space': [ 'Dodaj spację', 'Dodaj %0 spacje', 'Dodaj %0 spacji' ]
        },

// A function that returns the plural form index for the given language.
        // Note that you only need to pass this function when you add translations for a new language.
        getPluralForm: n => n == 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && ( n % 100 < 10 || n % 100 >= 20 ) ? 1 : 2
    }
    // Other languages.
    // ...
}
```

It is important to extend the existing properties in the `window.CKEDITOR_TRANSLATIONS` object to not lose other translations. This can be achieved easily using `Object.assign()` and the `||` operator.

```js
// Make sure that the global object is defined. If not, define it.
window.CKEDITOR_TRANSLATIONS = window.CKEDITOR_TRANSLATIONS || {};

// Make sure that the dictionary for Polish translations exist.
window.CKEDITOR_TRANSLATIONS[ 'pl' ] = window.CKEDITOR_TRANSLATIONS[ 'pl' ] || {};
window.CKEDITOR_TRANSLATIONS[ 'pl' ].dictionary =  window.CKEDITOR_TRANSLATIONS[ 'pl' ].dictionary || {};

// Extend the dictionary for Polish translations with your translations:
Object.assign( window.CKEDITOR_TRANSLATIONS[ 'pl' ].dictionary, {
    'Save': 'Zapisz'
} );
```

If you add a new language, remember to set the `getPluralForm()` function which should return a number (or a Boolean for languages with simple plural rules like English) that indicates which form should be used for the given value.

#### Creating `.po` files

The third option of adding plugins should fit mostly owners of plugins that contain many localizable messages. Using this option you need to create a `.po` file per each language code in the `lang/translations/` directory containing translations that follow the [PO file format](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html).

```
# lang/translations/es.po

msgid ""
msgstr ""
"Language: es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

msgid "Align left"
msgstr "Alinear a la izquierda"
```

> **Note**
>
> If you develop your own plugin outside the CKEditor 5 ecosystem, the easiest way to process the `.po` files and generate _translation assets_ for your package is to use the [package generator](#ckeditor5/latest/framework/development-tools/package-generator/using-package-generator.html). Its build setup handles the `lang/` directory, including translation synchronization.

To build and configure a localized editor, follow the steps from the [Setting the UI language guide](#ckeditor5/latest/getting-started/setup/ui-language.html).

### Re-using translations from other packages

If you want to re-use a _message_ that already exists in another package, you should call the translation function through an alias with a different name instead of [using `t()` as a function](#ckeditor5/latest/framework/deep-dive/ui/localization.html--writing-a-localizable-ui). This prevents the static code analyzer from treating it as a new source message.

We use this approach already in the [collaboration features](#ckeditor5/latest/features/collaboration/collaboration.html) and the [slash commands feature](#ckeditor5/latest/features/slash-commands.html). You can find an example from the [list of default commands](../../../api/module_slash-command_slashcommandconfig-SlashCommandConfig.html#function-getDefaultCommands) that we used in the slash commands feature below. Please note the difference between using `t()` and `translateVariableKey()`. `translateVariableKey( 'Block quote' )` will re-use a translation from another package whilst `t( 'Create a block quote' )` will be processed by a static code analyzer. As a result we make sure that the translation for the `title` is taken from the [block quote](#ckeditor5/latest/features/block-quote.html) feature where the _message_ “Block quote” is already translated. But for the `description` we create a new translation.

```ts
public getDefaultCommands() {
    const t = this.editor.t;
    const translateVariableKey = this.editor.locale.t;

return [
        {
            id: 'blockQuote',
            commandName: 'blockQuote',
            icon: IconQuote,
            title: translateVariableKey( 'Block quote' ),
            description: t( 'Create a block quote' )
        },
        // More command definitions
        // ...
    ]
}
```

### Known limitations

* Currently it is impossible to change the chosen editor’s language at runtime without destroying the editor.

<a id="ckeditor5/latest/framework/deep-dive/ui/theme-customization.html">source file: "ckeditor5/latest/framework/deep-dive/ui/theme-customization.html"</a>

## Theme customization

You can customize the CKEditor 5 UI theme by overriding its CSS variables (custom properties) to change colors, spacing, fonts, and more. The demo below shows the default theme restyled as a dark theme using this approach:

**Mode:**

Light

Dark

### Customization with CSS variables

Assuming you finished our [quick start](#ckeditor5/latest/getting-started/installation/cloud/quick-start.html) guide, and you have a running CKEditor 5 instance, let’s use the full potential of CSS variables (custom properties). The customization explained in this guide will make the theme dark, with slightly bigger text and more rounded corners.

The file containing custom variables can be named `custom.css` and it will look as below:

```css
:root {
    /* Helper variables to avoid duplication in the colors. */

--ck-custom-foreground: hsl(255, 3%, 18%);
    --ck-custom-border: hsl(300, 1%, 22%);
    --ck-custom-white: hsl(0, 0%, 100%);

/* -- Overrides generic colors. ------------------------------------------------------------- */

--ck-content-font-color: var(--ck-custom-white);

--ck-color-base-background: hsl(270, 1%, 29%);
    --ck-color-base-border: hsl(240, 4%, 24%);

--ck-color-focus-border: hsl(208, 90%, 62%);
    --ck-color-text: hsl(0, 0%, 98%);
    --ck-color-shadow-drop: hsla(0, 0%, 0%, 0.2);
    --ck-color-shadow-inner: hsla(0, 0%, 0%, 0.1);

/* -- Overrides the default .ck-button class colors. ---------------------------------------- */

--ck-color-button-default-hover-background: hsl(270, 1%, 22%);
    --ck-color-button-default-active-background: hsl(270, 2%, 20%);
    --ck-color-button-default-active-shadow: hsl(270, 2%, 23%);

--ck-color-button-on-background: var(--ck-custom-foreground);
    --ck-color-button-on-hover-background: hsl(255, 4%, 16%);
    --ck-color-button-on-active-background: hsl(255, 4%, 14%);
    --ck-color-button-on-active-shadow: hsl(240, 3%, 19%);
    --ck-color-button-on-disabled-background: var(--ck-custom-foreground);

--ck-color-button-action-background: hsl(168, 76%, 42%);
    --ck-color-button-action-hover-background: hsl(168, 76%, 38%);
    --ck-color-button-action-active-background: hsl(168, 76%, 36%);
    --ck-color-button-action-active-shadow: hsl(168, 75%, 34%);
    --ck-color-button-action-disabled-background: hsl(168, 76%, 42%);
    --ck-color-button-action-text: var(--ck-custom-white);

--ck-color-button-save: hsl(120, 100%, 46%);
    --ck-color-button-cancel: hsl(15, 100%, 56%);

/* -- Overrides the default .ck-dropdown class colors. -------------------------------------- */

--ck-color-dropdown-panel-border: var(--ck-custom-foreground);

/* -- Overrides the default .ck-dialog class colors. ----------------------------------- */

--ck-color-dialog-form-header-border: var(--ck-custom-border);

/* -- Overrides the default .ck-splitbutton class colors. ----------------------------------- */

--ck-color-split-button-hover-background: var(--ck-color-button-default-hover-background);
    --ck-color-split-button-hover-border: var(--ck-custom-foreground);

/* -- Overrides the default .ck-input class colors. ----------------------------------------- */

--ck-color-input-border: hsl(257, 3%, 43%);
    --ck-color-input-text: hsl(0, 0%, 98%);
    --ck-color-input-disabled-background: hsl(255, 4%, 21%);
    --ck-color-input-disabled-border: hsl(250, 3%, 38%);
    --ck-color-input-disabled-text: hsl(0, 0%, 78%);

/* -- Overrides the default .ck-list class colors. ------------------------------------------ */

--ck-color-list-button-hover-background: var(--ck-custom-foreground);
    --ck-color-list-button-on-background: hsl(208, 88%, 52%);
    --ck-color-list-button-on-text: var(--ck-custom-white);

/* -- Overrides the default .ck-balloon-panel class colors. --------------------------------- */

--ck-color-panel-border: var(--ck-custom-border);

/* -- Overrides the default .ck-toolbar class colors. --------------------------------------- */

--ck-color-toolbar-border: var(--ck-custom-border);

/* -- Overrides the default .ck-tooltip class colors. --------------------------------------- */

--ck-color-tooltip-background: hsl(252, 7%, 14%);
    --ck-color-tooltip-text: hsl(0, 0%, 93%);

/* -- Overrides the default colors used by the ckeditor5-image package. --------------------- */

--ck-content-color-image-caption-background: hsl(0, 0%, 97%);
    --ck-content-color-image-caption-text: hsl(0, 0%, 20%);

/* -- Overrides the default colors used by the ckeditor5-widget package. -------------------- */

--ck-color-widget-blurred-border: hsl(0, 0%, 87%);
    --ck-color-widget-hover-border: hsl(43, 100%, 68%);
    --ck-color-widget-editable-focus-background: var(--ck-custom-white);

/* -- Overrides the default colors used by the ckeditor5-link package. ---------------------- */

--ck-color-link-default: hsl(190, 100%, 75%);
}

/* Improve displaying links. */
.ck.ck-editor__editable a {
    color: hsl(210, 100%, 63%);
}

/* Improve displaying code blocks. */
.ck-content pre {
    color: hsl(0, 0%, 91%);
    border-color: hsl(0, 0%, 77%);
}
```

Depending on your setup method, you can either import a style sheet into your `js` file:

```js
import { ClassicEditor } from 'ckeditor5';

import 'ckeditor5/ckeditor5.css';

// Override the default styles.
import 'custom.css';

ClassicEditor
    .create( /* ... */ )
    .then( editor => {
        console.log( editor );
    } )
    .catch( err => {
        console.error( err.stack );
    } );
```

Or import it via the `link` in `html` in the CDN setup:

```html
<link rel="stylesheet" href="path/to/custom.css" type="text/css">
```

<a id="ckeditor5/latest/framework/deep-dive/ui/widget-internals.html">source file: "ckeditor5/latest/framework/deep-dive/ui/widget-internals.html"</a>

## Deep dive into widget internals

Widgets are self-contained, object-like elements in the editor content (such as images, tables, or media embeds) that users select and move as a single unit. This guide covers advanced widget internals: configuring the type-around feature and excluding DOM events from a widget’s default handlers.

### Disabling the widget type around feature

The [`WidgetTypeAround`](../../../api/module_widget_widgettypearound_widgettypearound-WidgetTypeAround.html) plugin allows users to type around the widgets, in places where it is normally impossible to place the caret due to limitations of the web browsers. Although this feature boosts productivity and ease of typing, some integrations may not want or need it, for instance:

* When the UI of the feature collides with the integration.
* When typing outside widgets should be impossible (content made exclusively of widgets).
* When certain widgets have a fixed location in the document that should never change.

In the sections that follow, you will learn how to configure CKEditor 5 WYSIWYG editor to address these specific needs.

#### Hiding the buttons that insert paragraphs around widgets

The easiest way to get rid of the type-around widget buttons is to hide them using CSS. Put the following code snippet anywhere in your application and the buttons will no longer be displayed:

```css
.ck.ck-editor__editable .ck-widget .ck-widget__type-around__button {
    display: none;
}
```

If you only want to customize the type around widget buttons, you can use the same CSS selector to modify their look or position.

> **Note**
>
> Hiding the type around widget buttons does not disable the feature. Users will still be able to activate the caret before or after individual widgets using the arrow keys and typing. [Learn how to disable the entire feature](#ckeditor5/latest/framework/deep-dive/ui/widget-internals.html--disabling-the-entire-feature).

#### Disabling the entire feature

Although the [`WidgetTypeAround`](../../../api/module_widget_widgettypearound_widgettypearound-WidgetTypeAround.html) plugin is an integral part of the [widget](../../../api/module_widget_widget-Widget.html) subsystem and is loaded by default whenever an editor feature uses widgets (for instance, for [images](#ckeditor5/latest/features/images/images-overview.html) or [tables](#ckeditor5/latest/features/tables/tables.html)), you can still disable it on the fly. Turning off the feature will both hide the widget buttons and disable other behaviors, for instance:

* The caret will not be rendered before or after a widget when the user navigates the document using arrow keys.
* The `Enter` and `Shift`+`Enter` keystrokes will no longer insert paragraphs if pressed when a widget is selected.

Use the [`forceDisabled()`](../../../api/module_core_plugin-Plugin.html#function-forceDisabled) method of the plugin to disable it on the fly like in the snippet below:

```js
ClassicEditor
    .create( {
        // The editor's configuration.
        // ...
    } )
    .then( editor => {
        const widgetTypeAroundPlugin = editor.plugins.get( 'WidgetTypeAround' );

// Disable the widget type around plugin.
        widgetTypeAroundPlugin.forceDisabled( 'MyApplication' );
    } )
    .catch( err => {
        console.error( err.stack );
    } );
```

You can always re–enable the plugin using the following snippet

```js
widgetTypeAroundPlugin.clearForceDisabled( 'MyApplication' );
```

Refer to the [API documentation](../../../api/module_core_plugin-Plugin.html#function-clearForceDisabled) to learn more.

### Exclude DOM events from default handlers

Sometimes it can be useful to prevent processing of events by default handlers, for example using React component inside an `UIElement` in the widget where, by default, widget itself wants to control everything. To make it possible the only thing to do is to add a `data-cke-ignore-events` attribute to an element or to its ancestor and then all events triggered by any of children from that element will be ignored in default handlers.

Let’s see it in an short example:

```html
<div data-cke-ignore-events="true">
    <button>Click!</button>
</div>
```

In the above template events dispatched from the button, which is placed inside `<div>` containing `data-cke-ignore-events` attribute, will be ignored by default event handlers.

<a id="ckeditor5/latest/framework/deep-dive/upload-adapter.html">source file: "ckeditor5/latest/framework/deep-dive/upload-adapter.html"</a>

## Custom image upload adapter

An upload adapter connects CKEditor 5’s file upload to a server or storage of your choice. This guide explains the file upload architecture and how to implement a custom upload adapter.

While this guide is mainly focused on image upload (the most common kind of upload), the presented concepts and the API allow development of all sorts of file upload adapters for different file types like PDF files, movies, etc.

> **Note**
>
> If you do not feel like getting through this guide but you want a simple upload adapter that works, check out the [Simple upload adapter](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html) plugin we implemented for you.

> **Note**
>
> Check out the comprehensive [Image upload overview](#ckeditor5/latest/features/images/image-upload/image-upload.html) to learn about other ways to upload images into CKEditor 5.

### Glossary of terms

Before you start, make sure all terms used in this guide are clear.

| Term                                                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Upload adapter                                                                         | A piece of code (a class) that handles the image upload from the moment it is requested by the user (for example, when the file is dropped into the content) to the moment the server returns a response to the requested upload. A bridge between the feature and the server.Upload adapters are used by other plugins like [image upload](../../api/module_image_imageupload-ImageUpload.html) to connect to the server and fetch the response. For every user action (for example, when a file is dropped into the content), a new upload adapter instance is created.CKEditor 5 comes with some [official upload adapters](#ckeditor5/latest/features/images/image-upload/image-upload.html--official-upload-adapters) but you can also [implement your own adapters](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--implementing-a-custom-upload-adapter).See the ["How does the image upload work?"](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--how-does-the-image-upload-work) section to learn more. |
| [`UploadAdapter`](../../api/module_upload_filerepository-UploadAdapter.html) interface | An interface defining the minimal API required to create an upload adapter. In other words, it tells you what methods your upload adapter class must have to work.See ["The anatomy of the adapter"](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--the-anatomy-of-the-adapter) section to learn more.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [File repository](../../api/module_upload_filerepository-FileRepository.html) plugin   | A central point for managing file upload in CKEditor 5. It glues upload adapters and features using them:- Upload adapters are enabled in the editor by defining the [`FileRepository.createUploadAdapter()`](../../api/module_upload_filerepository-FileRepository.html#member-createUploadAdapter) factory method.
- Features like [image upload](../../api/module_image_imageupload-ImageUpload.html) use the `FileRepository` API to create a new upload adapter instance each time an upload is requested by the user.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [Image upload](../../api/module_image_imageupload-ImageUpload.html) plugin             | A top-level plugin that responds to actions of the users (for example, when a file is dropped into the content) by uploading files to the server and updating the edited content once the upload finishes. This particular plugin handles user actions related to uploading images.It uses the `FileRepository` API to spawn upload adapter instances, triggers the image upload (`UploadAdapter.upload()`), and uses the data returned by the adapter's upload promise to update the image in the editor content.See the ["How does the image upload work?"](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--how-does-the-image-upload-work) section to learn more.                                                                                                                                                                                                                                                                                                                                                          |

### How does the image upload work?

Before you can create your custom upload adapter, you should learn about the image upload process in CKEditor 5. The whole process consists of the following steps:

1. First, an image (or images) needs to get into the rich-text editor content. There are many ways to do that, for instance:

* pasting an image from the clipboard,
   * dragging a file from the file system,
   * selecting an image through a file system dialog.

The images are intercepted by the [image upload](../../api/module_image_imageupload-ImageUpload.html) plugin.

2. For every image, the image upload plugin [creates an instance of a file loader](../../api/module_upload_filerepository-FileRepository.html#function-createLoader).

* The role of the **file loader** is to read the file from the disk and upload it to the server by using the upload adapter.
   * The role of the **upload adapter** is, therefore, to securely send the file to the server and pass the response from the server (for example, the URL to the saved file) back to the file loader (or handle an error, if there was one).

3. While the images are being uploaded, the image upload plugin:

* Creates placeholders for these images.
   * Inserts them into the editor.
   * Displays the progress bar for each of them.
   * When an image is deleted from the editor content before the upload finishes, it aborts the upload process.

4. Once the file is uploaded, the upload adapter notifies the editor about this fact by resolving its `Promise`. It passes the URL (or URLs in case of responsive images) to the image upload plugin which replaces the `src` and `srcset` attributes of the image placeholder in the editor content.

This is just an overview of the image upload process. Actually, the whole thing is more complicated. For instance, images can be copied and pasted within the WYSIWYG editor (while the upload takes place) and all potential upload errors must be handled, too. The good news is these tasks are handled transparently by the [image upload](../../api/module_image_imageupload-ImageUpload.html) plugin so you do not have to worry about them.

To sum up, for the image upload to work in the rich-text editor, two conditions must be true:

* **The [image upload](../../api/module_image_imageupload-ImageUpload.html) plugin must be enabled** in the editor.

* **The upload adapter needs to be defined**. This can be done by using (enabling _and_ configuring):

* [One of the existing upload adapters](#ckeditor5/latest/features/images/image-upload/image-upload.html--official-upload-adapters).
  * [Your custom upload adapter](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--implementing-a-custom-upload-adapter) and handling uploaded files on your server backend.

### The anatomy of the adapter

A custom upload adapter allows you to take **full control** over the process of sending the files to the server as well as passing the response from the server back to the rich-text editor.

Any upload adapter, whether an image upload adapter or a generic file upload adapter, must implement the [`UploadAdapter` interface](../../api/module_upload_filerepository-UploadAdapter.html) to work, that is, it must bring its own `upload()` and `abort()` methods.

* The [`upload()`](../../api/module_upload_filerepository-UploadAdapter.html#function-upload) method must return a promise:

* **resolved** by a successful upload with an object containing information about the uploaded file (see the section about [responsive images](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--responsive-images-and-srcset-attribute) to learn more),
  * **rejected** because of an error, in which case nothing is inserted into the content.

* The [`abort()`](../../api/module_upload_filerepository-UploadAdapter.html#function-abort) method must allow the editor to stop the upload process. It is necessary, for instance, when the image was removed from the content by the user before the upload finished or the editor instance was [destroyed](../../api/module_core_editor_editor-Editor.html#function-destroy).

In its simplest form, a custom adapter implementing the `UploadAdapter` interface will look as follows. Note that `server.upload()`, `server.onUploadProgress()` and `server.abortUpload()` should be replaced by specific implementations (dedicated for your application) and only demonstrate the minimal communication necessary for the upload to work:

```js
class MyUploadAdapter {
    constructor( loader ) {
        // The file loader instance to use during the upload.
        this.loader = loader;
    }

// Starts the upload process.
    upload() {
        // Update the loader's progress.
        server.onUploadProgress( data => {
            loader.uploadTotal = data.total;
            loader.uploaded = data.uploaded;
        } );

// Return a promise that will be resolved when the file is uploaded.
        return loader.file
            .then( file => server.upload( file ) );
    }

// Aborts the upload process.
    abort() {
        // Reject the promise returned from the upload() method.
        server.abortUpload();
    }
}
```

Define the [`FileRepository.createUploadAdapter()`](../../api/module_upload_filerepository-FileRepository.html#member-createUploadAdapter) factory method which uses the `MyUploadAdapter` class to enable the upload adapter in the editor:

```js
editor.plugins.get( 'FileRepository' ).createUploadAdapter = ( loader ) => {
    return new MyUploadAdapter( loader );
};
```

### Implementing a custom upload adapter

In this section, you are going to implement and enable a custom upload adapter. The adapter will use the native [`XMLHttpRequest`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) to send files returned by the loader to a pre–configured URL on the server, handling the `error`, `abort`, `load`, and `progress` events fired by the request.

> **Note**
>
> If you do not feel like getting through this guide but you want a simple `XMLHttpRequest`–based upload adapter that works, check out the [Simple upload adapter](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html) plugin we implemented for you. It comes with pretty much the same functionality. Just install it, configure it, and you are ready to go.

> **Note**
>
> If the [Simple upload adapter](#ckeditor5/latest/features/images/image-upload/simple-upload-adapter.html) is not enough for you and you want a custom upload adapter developed on top this guide, go straight to the [full source code](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--the-complete-implementation) and start experimenting.

> **Note**
>
> This is just an example implementation and `XMLHttpRequest` might not necessarily be the best solution for your application.
>
> Use the provided code snippets as an inspiration for your own custom upload adapter – it is up to you to choose the technologies and APIs to use. For instance, you may want to check out the native [`fetch()` API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch) that works with `Promises` out of the box.

To start off, define the `MyUploadAdapter` class with its constructor.

```js
class MyUploadAdapter {
    constructor( loader ) {
        // The file loader instance to use during the upload. It sounds scary but do not
        // worry — the loader will be passed into the adapter later on in this guide.
        this.loader = loader;
    }

// More methods.
    // ...
}
```

Implement the minimal `UploadAdapter` adapter interface as explained in [“The anatomy of the adapter”](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--the-anatomy-of-the-adapter) section. The details of the implementation are explained in the following chapters of this guide.

```js
class MyUploadAdapter {
    // The constructor method.
    // ...

// Starts the upload process.
    upload() {
        return this.loader.file
            .then( file => new Promise( ( resolve, reject ) => {
                this._initRequest();
                this._initListeners( resolve, reject, file );
                this._sendRequest( file );
            } ) );
    }

// Aborts the upload process.
    abort() {
        if ( this.xhr ) {
            this.xhr.abort();
        }
    }

// More methods.
    // ...
}
```

#### Using `XMLHttpRequest` in an adapter

Let’s see what the `_initRequest()` method looks like in your custom upload adapter. It should prepare the `XMLHttpRequest` object before it can be used to upload an image.

> **Note**
>
> For the sake of keeping the code simple, in this example implementation no particular security mechanism is used that would prevent your application and services from being abused.
>
> We **strongly recommend** using both authentication and [CSRF protection](https://owasp.org/www-community/attacks/csrf) mechanisms (i.e. CSRF tokens) in your application. For instance, they can be implemented as [`XMLHttpRequest`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader) headers.

```js
class MyUploadAdapter {
    // More methods.
    // ...

// Initializes the XMLHttpRequest object using the URL passed to the constructor.
    _initRequest() {
        const xhr = this.xhr = new XMLHttpRequest();

// Note that your request may look different. It is up to you and your editor
        // integration to choose the right communication channel. This example uses
        // a POST request with JSON as a data structure but your configuration
        // could be different.
        xhr.open( 'POST', 'http://example.com/image/upload/path', true );
        xhr.responseType = 'json';
    }
}
```

Now focus on the `_initListeners()` method which attaches the `error`, `abort`, `load`, and `progress` event listeners to the `XMLHttpRequest` object created in the last step.

A successful image upload will finish when the upload promise is resolved upon the `load` event fired by the `XMLHttpRequest` request. The promise must be resolved with an object containing information about the image. See the documentation of the [`upload()`](../../api/module_upload_filerepository-UploadAdapter.html#function-upload) method to learn more.

```js
class MyUploadAdapter {
    // More methods.
    // ...

// Initializes XMLHttpRequest listeners.
    _initListeners( resolve, reject, file ) {
        const xhr = this.xhr;
        const loader = this.loader;
        const genericErrorText = `Couldn't upload file: ${ file.name }.`;

xhr.addEventListener( 'error', () => reject( genericErrorText ) );
        xhr.addEventListener( 'abort', () => reject() );
        xhr.addEventListener( 'load', () => {
            const response = xhr.response;

// This example assumes the XHR server's "response" object will come with
            // an "error" which has its own "message" that can be passed to reject()
            // in the upload promise.
            //
            // Your integration may handle upload errors in a different way so make sure
            // it is done properly. The reject() function must be called when the upload fails.
            if ( !response || response.error ) {
                return reject( response && response.error ? response.error.message : genericErrorText );
            }

// If the upload is successful, resolve the upload promise with an object containing
            // at least the "default" URL, pointing to the image on the server.
            // This URL will be used to display the image in the content. Learn more in the
            // UploadAdapter#upload documentation.
            resolve( {
                default: response.url
            } );
        } );

// Upload progress when it is supported. The file loader has the #uploadTotal and #uploaded
        // properties which are used e.g. to display the upload progress bar in the editor
        // user interface.
        if ( xhr.upload ) {
            xhr.upload.addEventListener( 'progress', evt => {
                if ( evt.lengthComputable ) {
                    loader.uploadTotal = evt.total;
                    loader.uploaded = evt.loaded;
                }
            } );
        }
    }
}
```

Finally, the `_sendRequest()` method sends the `XMLHttpRequest`. In this example, the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) interface is used to pass the file provided by the [file loader](../../api/module_upload_filerepository-FileRepository.html#function-createLoader).

> **Note**
>
> Both the data format and actual data passed to `XMLHttpRequest.send()` in this example implementation are arbitrary. Your implementation could be different and it will depend on the backend of your application and interfaces it provides.

```js
class MyUploadAdapter {
    // More methods.
    // ...

// Prepares the data and sends the request.
    _sendRequest( file ) {
        // Prepare the form data.
        const data = new FormData();

data.append( 'upload', file );

// Important note: This is the right place to implement security mechanisms
        // like authentication and CSRF protection. For instance, you can use
        // XMLHttpRequest.setRequestHeader() to set the request headers containing
        // the CSRF token generated earlier by your application.

// Send the request.
        this.xhr.send( data );
    }
}
```

#### Responsive images and `srcset` attribute

If the upload is successful, a `Promise` returned by the [`MyUploadAdapter.upload()`](../../api/module_upload_filerepository-UploadAdapter.html#function-upload) method can resolve with more than just a `default` path to the uploaded image. See the implementation of `MyUploadAdapter._initListeners()`. This usually looks like this:

```js
{
    default: 'http://example.com/images/image–default-size.png'
}
```

Other image sizes can also be provided in the response, allowing [responsive images](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images) in the editor. The response containing more than just one image size could look like this:

```js
{
    default: 'http://example.com/images/image–default-size.png',
    '160': 'http://example.com/images/image–size-160.image.png',
    '500': 'http://example.com/images/image–size-500.image.png',
    '1000': 'http://example.com/images/image–size-1000.image.png',
    '1052': 'http://example.com/images/image–default-size.png'
}
```

> **Note**
>
> When returning multiple images, the widest returned one should be the default one. It is essential to correctly set the `width` attribute of the image in the rich-text editor content.

The [image upload](../../api/module_image_imageupload-ImageUpload.html) plugin is capable of handling multiple image sizes returned by the upload adapter. It will automatically add the URLs to other images sizes to the `srcset` attribute of the image in the content.

Knowing that, you can implement the `XMLHttpRequest#load` listener that resolves the upload promise in the [previous section](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--using-xmlhttprequest-in-an-adapter) so that it passes the entire `urls` property of the server response to the image upload plugin:

```js
// The rest of the MyUploadAdapter class definition.
// ...

xhr.addEventListener( 'load', () => {
    const response = xhr.response;

// Response handling.
    // ...

// response.urls = {
    // 	default: 'http://example.com/images/image–default-size.png',
    // 	'160': '...',
    // 	'500': '...',
    // 	More response urls.
    //  ...
    // 	'1052': 'http://example.com/images/image–default-size.png'
    // }
    resolve( response.urls );
} );

// The rest of the MyUploadAdapter class definition.
// ...
```

#### Passing additional data to the response

There is a chance you might need to pass some data from the server to provide additional data to some features. To do that, you need to wrap all URLs in the `urls` property and pass additional data in the top level of the object.

For image uploading, you can later retrieve the data in the [`uploadComplete`](../../api/module_image_imageupload_imageuploadediting-ImageUploadEditing.html#event-uploadComplete) event. This allows setting new attributes and overriding the existing ones on the model image based on the data just after the image is uploaded.

```js
{
    urls: {
        default: 'http://example.com/images/image–default-size.png',
        // Optional different sizes of images.
    },
    customProperty: 'foo'
}
```

#### Activating a custom upload adapter

Having implemented the adapter, you must figure out how to enable it in the WYSIWYG editor. The good news is that it is pretty easy, and you do not need to rebuild the editor to do that!

You are going to extend the basic implementation presented in [“The anatomy of the adapter”](#ckeditor5/latest/framework/deep-dive/upload-adapter.html--the-anatomy-of-the-adapter) section of this guide so your custom adapter becomes an editor plugin. To do that, create a simple standalone plugin (`MyCustomUploadAdapterPlugin`) that will [create an instance of the file loader](../../api/module_upload_filerepository-FileRepository.html#function-createLoader) and glue it with your custom `MyUploadAdapter`.

**NPM**

```js
import { ClassicEditor, Essentials, Paragraph, Image, ImageUpload } from 'ckeditor5';

class MyUploadAdapter {
	// MyUploadAdapter class definition.
	// ...
}

function MyCustomUploadAdapterPlugin( editor ) {
	editor.plugins.get( 'FileRepository' ).createUploadAdapter = ( loader ) => {
		// Configure the URL to the upload script in your backend here!
		return new MyUploadAdapter( loader );
	};
}
```

**CDN**

```js
const { ClassicEditor, Essentials, Paragraph, Image, ImageUpload } = CKEDITOR;

class MyUploadAdapter {
	// MyUploadAdapter class definition.
	// ...
}

Enable the `MyCustomUploadAdapterPlugin` in the editor by using the [`config.extraPlugins`](../../api/module_core_editor_editorconfig-EditorConfig.html#member-extraPlugins) option:

```js
ClassicEditor
    .create( {
        plugins: [ MyCustomUploadAdapterPlugin, Essentials, Paragraph, Image, ImageUpload, /* ... */ ],
        // More configuration options.
        // ...
    } )
    .catch( error => {
        console.log( error );
    } );
```

Run the editor and see if your implementation works. Drop an image into the WYSIWYG editor content and it should be uploaded to the server thanks to the `MyUploadAdapter`.

#### The complete implementation

Here is what the complete implementation of an `XMLHttpRequest`–based upload adapter looks like. You can use this code as a foundation to build custom upload adapters for your applications.

**NPM**

```js
import { ClassicEditor, Essentials, Paragraph, Image, ImageUpload } from 'ckeditor5';

class MyUploadAdapter {
	constructor( loader ) {
		// The file loader instance to use during the upload.
		this.loader = loader;
	}

// Starts the upload process.
	upload() {
		return this.loader.file
			.then( file => new Promise( ( resolve, reject ) => {
				this._initRequest();
				this._initListeners( resolve, reject, file );
				this._sendRequest( file );
			} ) );
	}

// Aborts the upload process.
	abort() {
		if ( this.xhr ) {
			this.xhr.abort();
		}
	}

// Initializes the XMLHttpRequest object using the URL passed to the constructor.
	_initRequest() {
		const xhr = this.xhr = new XMLHttpRequest();

// Note that your request may look different. It is up to you and your editor
		// integration to choose the right communication channel. This example uses
		// a POST request with JSON as a data structure but your configuration
		// could be different.
		xhr.open( 'POST', 'http://example.com/image/upload/path', true );
		xhr.responseType = 'json';
	}

// Initializes XMLHttpRequest listeners.
	_initListeners( resolve, reject, file ) {
		const xhr = this.xhr;
		const loader = this.loader;
		const genericErrorText = `Couldn't upload file: ${ file.name }.`;

xhr.addEventListener( 'error', () => reject( genericErrorText ) );
		xhr.addEventListener( 'abort', () => reject() );
		xhr.addEventListener( 'load', () => {
			const response = xhr.response;

// This example assumes the XHR server's "response" object will come with
			// an "error" which has its own "message" that can be passed to reject()
			// in the upload promise.
			//
			// Your integration may handle upload errors in a different way so make sure
			// it is done properly. The reject() function must be called when the upload fails.
			if ( !response || response.error ) {
				return reject( response && response.error ? response.error.message : genericErrorText );
			}

// If the upload is successful, resolve the upload promise with an object containing
			// at least the "default" URL, pointing to the image on the server.
			// This URL will be used to display the image in the content. Learn more in the
			// UploadAdapter#upload documentation.
			resolve( {
				default: response.url
			} );
		} );

// Upload progress when it is supported. The file loader has the #uploadTotal and #uploaded
		// properties which are used e.g. to display the upload progress bar in the editor
		// user interface.
		if ( xhr.upload ) {
			xhr.upload.addEventListener( 'progress', evt => {
				if ( evt.lengthComputable ) {
					loader.uploadTotal = evt.total;
					loader.uploaded = evt.loaded;
				}
			} );
		}
	}

// Prepares the data and sends the request.
	_sendRequest( file ) {
		// Prepare the form data.
		const data = new FormData();

data.append( 'upload', file );

// Important note: This is the right place to implement security mechanisms
		// like authentication and CSRF protection. For instance, you can use
		// XMLHttpRequest.setRequestHeader() to set the request headers containing
		// the CSRF token generated earlier by your application.

// Send the request.
		this.xhr.send( data );
	}
}

function MyCustomUploadAdapterPlugin( editor ) {
	editor.plugins.get( 'FileRepository' ).createUploadAdapter = ( loader ) => {
		// Configure the URL to the upload script in your back-end here!
		return new MyUploadAdapter( loader );
	};
}

ClassicEditor
	.create( {
		plugins: [ MyCustomUploadAdapterPlugin, Essentials, Paragraph, Image, ImageUpload, /* ... */ ],
		// More configuration options.
		// ...
	} )
	.catch( error => {
		console.log( error );
	} );
```