@ckeditor/ckeditor5-engine 42.0.2-alpha.2 → 43.0.0-alpha.0

package/dist/index.js

@@ -2,7 +2,7 @@
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-import { logWarning, EmitterMixin, CKEditorError, compareArrays, toArray, toMap, isIterable, ObservableMixin, count, EventInfo, Collection, keyCodes, isText, env, remove as remove$1, insertAt, diff, isNode, isComment, indexOf, fastDiff, global, isValidAttributeName, first, getAncestors, DomEmitterMixin, getCode, isArrowKeyCode, scrollViewportToShowTarget, spliceArray, uid, priorities, isInsideSurrogatePair, isInsideCombinedSymbol, isInsideEmojiSequence } from '@ckeditor/ckeditor5-utils/dist/index.js';
+import { logWarning, EmitterMixin, CKEditorError, compareArrays, toArray, toMap, isIterable, ObservableMixin, count, EventInfo, Collection, keyCodes, isText, env, remove as remove$1, insertAt, diff, fastDiff, isNode, isComment, indexOf, global, isValidAttributeName, first, getAncestors, DomEmitterMixin, getCode, isArrowKeyCode, scrollViewportToShowTarget, spliceArray, uid, priorities, isInsideSurrogatePair, isInsideCombinedSymbol, isInsideEmojiSequence } from '@ckeditor/ckeditor5-utils/dist/index.js';
 import { clone, isPlainObject, isObject, unset, get, merge, set, extend, debounce, isEqualWith, cloneDeep, isEqual } from 'lodash-es';
 
 // Each document stores information about its placeholder elements and check functions.
@@ -7332,6 +7332,7 @@ const validNodesToInsert = [
         this.selection = selection;
         this.set('isFocused', false);
         this.set('isSelecting', false);
+        this.set('isComposing', false);
         // Rendering the selection and inline filler manipulation should be postponed in (non-Android) Blink until the user finishes
         // creating the selection in DOM to avoid accidental selection collapsing
         // (https://github.com/ckeditor/ckeditor5/issues/10562, https://github.com/ckeditor/ckeditor5/issues/10723).
@@ -7343,12 +7344,6 @@ const validNodesToInsert = [
                 }
             });
         }
-        this.set('isComposing', false);
-        this.on('change:isComposing', ()=>{
-            if (!this.isComposing) {
-                this.render();
-            }
-        });
     }
     /**
 	 * Marks a view node to be updated in the DOM by {@link #render `render()`}.
@@ -7402,15 +7397,15 @@ const validNodesToInsert = [
         // and we should not do it because the difference between view and DOM could lead to position mapping problems.
         if (this.isComposing && !env.isAndroid) {
             // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Rendering aborted while isComposing',
-            // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', ''
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Rendering aborted while isComposing.',
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-style: italic'
             // @if CK_DEBUG_TYPING // 	);
             // @if CK_DEBUG_TYPING // }
             return;
         }
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.group( '%c[Renderer]%c Rendering',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', ''
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         let inlineFillerPosition = null;
@@ -7689,10 +7684,10 @@ const validNodesToInsert = [
         }
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.group( '%c[Renderer]%c Update text',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', ''
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: normal'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
-        updateTextNode(domText, expectedText);
+        this._updateTextNode(domText, expectedText);
     // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
     // @if CK_DEBUG_TYPING // 	console.groupEnd();
     // @if CK_DEBUG_TYPING // }
@@ -7741,7 +7736,7 @@ const validNodesToInsert = [
         }
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.group( '%c[Renderer]%c Update children',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', ''
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: normal'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         // IME on Android inserts a new text node while typing after a link
@@ -7773,6 +7768,11 @@ const validNodesToInsert = [
         // We need to make sure that we update the existing text node and not replace it with another one.
         // The composition and different "language" browser extensions are fragile to text node being completely replaced.
         const actions = this._findUpdateActions(diff, actualDomChildren, expectedDomChildren, areTextNodes);
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping && actions.every( a => a == 'equal' ) ) {
+        // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Nothing to update.',
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-style: italic'
+        // @if CK_DEBUG_TYPING // 	);
+        // @if CK_DEBUG_TYPING // }
         let i = 0;
         const nodesToUnbind = new Set();
         // Handle deletions first.
@@ -7784,9 +7784,22 @@ const validNodesToInsert = [
         for (const action of actions){
             if (action === 'delete') {
                 // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Remove node',
-                // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', '', actualDomChildren[ i ]
-                // @if CK_DEBUG_TYPING // 	);
+                // @if CK_DEBUG_TYPING //	const node = actualDomChildren[ i ];
+                // @if CK_DEBUG_TYPING // 	if ( isText( node ) ) {
+                // @if CK_DEBUG_TYPING // 		console.info( '%c[Renderer]%c Remove text node' +
+                // @if CK_DEBUG_TYPING // 			`${ this.isComposing ? ' while composing (may break composition)' : '' }: ` +
+                // @if CK_DEBUG_TYPING // 			`%c${ _escapeTextNodeData( node.data ) }%c (${ node.data.length })`,
+                // @if CK_DEBUG_TYPING // 			'color: green; font-weight: bold',
+                // @if CK_DEBUG_TYPING // 			this.isComposing ? 'color: red; font-weight: bold' : '', 'color: blue', ''
+                // @if CK_DEBUG_TYPING // 		);
+                // @if CK_DEBUG_TYPING // 	} else {
+                // @if CK_DEBUG_TYPING // 		console.info( '%c[Renderer]%c Remove element' +
+                // @if CK_DEBUG_TYPING // 			`${ this.isComposing ? ' while composing (may break composition)' : '' }: `,
+                // @if CK_DEBUG_TYPING // 			'color: green; font-weight: bold',
+                // @if CK_DEBUG_TYPING // 			this.isComposing ? 'color: red; font-weight: bold' : '',
+                // @if CK_DEBUG_TYPING // 			node
+                // @if CK_DEBUG_TYPING // 		);
+                // @if CK_DEBUG_TYPING // 	}
                 // @if CK_DEBUG_TYPING // }
                 nodesToUnbind.add(actualDomChildren[i]);
                 remove$1(actualDomChildren[i]);
@@ -7798,23 +7811,27 @@ const validNodesToInsert = [
         for (const action of actions){
             if (action === 'insert') {
                 // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Insert node',
-                // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', '', expectedDomChildren[ i ]
-                // @if CK_DEBUG_TYPING // 	);
+                // @if CK_DEBUG_TYPING //	const node = expectedDomChildren[ i ];
+                // @if CK_DEBUG_TYPING //	if ( isText( node ) ) {
+                // @if CK_DEBUG_TYPING //		console.info( '%c[Renderer]%c Insert text node' +
+                // @if CK_DEBUG_TYPING //			`${ this.isComposing ? ' while composing (may break composition)' : '' }: ` +
+                // @if CK_DEBUG_TYPING //			`%c${ _escapeTextNodeData( node.data ) }%c (${ node.data.length })`,
+                // @if CK_DEBUG_TYPING //			'color: green; font-weight: bold',
+                // @if CK_DEBUG_TYPING //			this.isComposing ? 'color: red; font-weight: bold' : '',
+                // @if CK_DEBUG_TYPING //			'color: blue', ''
+                // @if CK_DEBUG_TYPING //		);
+                // @if CK_DEBUG_TYPING //	} else {
+                // @if CK_DEBUG_TYPING //		console.info( '%c[Renderer]%c Insert element:',
+                // @if CK_DEBUG_TYPING //			'color: green; font-weight: bold', 'font-weight: normal',
+                // @if CK_DEBUG_TYPING //			node
+                // @if CK_DEBUG_TYPING //		);
+                // @if CK_DEBUG_TYPING //	}
                 // @if CK_DEBUG_TYPING // }
                 insertAt(domElement, i, expectedDomChildren[i]);
                 i++;
             } else if (action === 'update') {
-                // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                // @if CK_DEBUG_TYPING // 	console.group( '%c[Renderer]%c Update text node',
-                // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', ''
-                // @if CK_DEBUG_TYPING // 	);
-                // @if CK_DEBUG_TYPING // }
-                updateTextNode(actualDomChildren[i], expectedDomChildren[i].data);
+                this._updateTextNode(actualDomChildren[i], expectedDomChildren[i].data);
                 i++;
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
             } else if (action === 'equal') {
                 // Force updating text nodes inside elements which did not change and do not need to be re-rendered (#1125).
                 // Do it here (not in the loop above) because only after insertions the `i` index is correct.
@@ -7890,6 +7907,60 @@ const validNodesToInsert = [
         }
         return newActions.concat(diff(actualSlice, expectedSlice, comparator).map((action)=>action === 'equal' ? 'update' : action));
     }
+    /**
+	 * Checks if text needs to be updated and possibly updates it by removing and inserting only parts
+	 * of the data from the existing text node to reduce impact on the IME composition.
+	 *
+	 * @param domText DOM text node to update.
+	 * @param expectedText The expected data of a text node.
+	 */ _updateTextNode(domText, expectedText) {
+        const actualText = domText.data;
+        if (actualText == expectedText) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Text node does not need update:%c ' +
+            // @if CK_DEBUG_TYPING // 		`${ _escapeTextNodeData( actualText ) }%c (${ actualText.length })`,
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-style: italic', 'color: blue', ''
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+            return;
+        }
+        // Our approach to interleaving space character with NBSP might differ with the one implemented by the browser.
+        // Avoid modifying the text node in the DOM if only NBSPs and spaces are interchanged.
+        // We should avoid DOM modifications while composing to avoid breakage of composition.
+        // See: https://github.com/ckeditor/ckeditor5/issues/13994.
+        if (env.isAndroid && this.isComposing && actualText.replace(/\u00A0/g, ' ') == expectedText.replace(/\u00A0/g, ' ')) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Text node ignore NBSP changes while composing: ' +
+            // @if CK_DEBUG_TYPING // 		`%c${ _escapeTextNodeData( actualText ) }%c (${ actualText.length }) ->` +
+            // @if CK_DEBUG_TYPING // 		` %c${ _escapeTextNodeData( expectedText ) }%c (${ expectedText.length })`,
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-style: italic', 'color: blue', '', 'color: blue', ''
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+            return;
+        }
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Update text node' +
+        // @if CK_DEBUG_TYPING // 		`${ this.isComposing ? ' while composing (may break composition)' : '' }: ` +
+        // @if CK_DEBUG_TYPING // 		`%c${ _escapeTextNodeData( actualText ) }%c (${ actualText.length }) ->` +
+        // @if CK_DEBUG_TYPING // 		` %c${ _escapeTextNodeData( expectedText ) }%c (${ expectedText.length })`,
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', this.isComposing ? 'color: red; font-weight: bold' : '',
+        // @if CK_DEBUG_TYPING // 		'color: blue', '', 'color: blue', ''
+        // @if CK_DEBUG_TYPING // 	);
+        // @if CK_DEBUG_TYPING // }
+        this._updateTextNodeInternal(domText, expectedText);
+    }
+    /**
+	 * Part of the `_updateTextNode` method extracted for easier testing.
+	 */ _updateTextNodeInternal(domText, expectedText) {
+        const actions = fastDiff(domText.data, expectedText);
+        for (const action of actions){
+            if (action.type === 'insert') {
+                domText.insertData(action.index, action.values.join(''));
+            } else {
+                domText.deleteData(action.index, action.howMany);
+            }
+        }
+    }
     /**
 	 * Marks text nodes to be synchronized.
 	 *
@@ -7983,7 +8054,7 @@ const validNodesToInsert = [
         const focus = this.domConverter.viewPositionToDom(this.selection.focus);
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Update DOM selection:',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', '', anchor, focus
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', '', anchor, focus
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         domSelection.setBaseAndExtent(anchor.parent, anchor.offset, focus.parent, focus.offset);
@@ -8183,39 +8254,14 @@ function filterOutFakeSelectionContainer(domChildList, fakeSelectionContainer) {
     // Fill it with a text node so we can update it later.
     container.textContent = '\u00A0';
     return container;
-}
-/**
- * Checks if text needs to be updated and possibly updates it by removing and inserting only parts
- * of the data from the existing text node to reduce impact on the IME composition.
- *
- * @param domText DOM text node to update.
- * @param expectedText The expected data of a text node.
- */ function updateTextNode(domText, expectedText) {
-    const actualText = domText.data;
-    if (actualText == expectedText) {
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Text node does not need update:',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', '',
-        // @if CK_DEBUG_TYPING // 		`"${ domText.data }" (${ domText.data.length })`
-        // @if CK_DEBUG_TYPING // 	);
-        // @if CK_DEBUG_TYPING // }
-        return;
-    }
-    // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-    // @if CK_DEBUG_TYPING // 	console.info( '%c[Renderer]%c Update text node:',
-    // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', '',
-    // @if CK_DEBUG_TYPING // 		`"${ domText.data }" (${ domText.data.length }) -> "${ expectedText }" (${ expectedText.length })`
-    // @if CK_DEBUG_TYPING // 	);
-    // @if CK_DEBUG_TYPING // }
-    const actions = fastDiff(actualText, expectedText);
-    for (const action of actions){
-        if (action.type === 'insert') {
-            domText.insertData(action.index, action.values.join(''));
-        } else {
-            domText.deleteData(action.index, action.howMany);
-        }
-    }
-}
+} // @if CK_DEBUG_TYPING // function _escapeTextNodeData( text ) {
+ // @if CK_DEBUG_TYPING // 	const escapedText = text
+ // @if CK_DEBUG_TYPING // 		.replace( /&/g, '&' )
+ // @if CK_DEBUG_TYPING // 		.replace( /\u00A0/g, ' ' )
+ // @if CK_DEBUG_TYPING // 		.replace( /\u2060/g, '⁠' );
+ // @if CK_DEBUG_TYPING //
+ // @if CK_DEBUG_TYPING // 	return `"${ escapedText }"`;
+ // @if CK_DEBUG_TYPING // }
 
 const BR_FILLER_REF = BR_FILLER(global.document); // eslint-disable-line new-cap
 const NBSP_FILLER_REF = NBSP_FILLER(global.document); // eslint-disable-line new-cap
@@ -9522,16 +9568,18 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
             startPosition: getNext ? Position$1._createAfter(node) : Position$1._createBefore(node),
             direction: getNext ? 'forward' : 'backward'
         });
-        for (const value of treeWalker){
-            // <br> found – it works like a block boundary, so do not scan further.
-            if (value.item.is('element', 'br')) {
+        for (const { item } of treeWalker){
+            // Found a text node in the same container element.
+            if (item.is('$textProxy')) {
+                return item;
+            } else if (item.is('element') && item.getCustomProperty('dataPipeline:transparentRendering')) {
+                continue;
+            } else if (item.is('element', 'br')) {
                 return null;
-            } else if (this._isInlineObjectElement(value.item)) {
-                return value.item;
-            } else if (value.item.is('containerElement')) {
+            } else if (this._isInlineObjectElement(item)) {
+                return item;
+            } else if (item.is('containerElement')) {
                 return null;
-            } else if (value.item.is('$textProxy')) {
-                return value.item;
             }
         }
         return null;
@@ -10018,6 +10066,7 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
     }
 }
 
+// @if CK_DEBUG_TYPING // const { _debouncedLine } = require( '../../dev-utils/utils.js' );
 /**
  * Mutation observer's role is to watch for any DOM changes inside the editor that weren't
  * done by the editor's {@link module:engine/view/renderer~Renderer} itself and reverting these changes.
@@ -10032,9 +10081,6 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
     /**
 	 * Reference to the {@link module:engine/view/view~View#domConverter}.
 	 */ domConverter;
-    /**
-	 * Reference to the {@link module:engine/view/view~View#_renderer}.
-	 */ renderer;
     /**
 	 * Native mutation observer config.
 	 */ _config;
@@ -10054,7 +10100,6 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
             subtree: true
         };
         this.domConverter = view.domConverter;
-        this.renderer = view._renderer;
         this._domElements = new Set();
         this._mutationObserver = new window.MutationObserver(this._onMutations.bind(this));
     }
@@ -10150,10 +10195,12 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
         }
         // Now we build the list of mutations to mark elements. We did not do it earlier to avoid marking the
         // same node multiple times in case of duplication.
-        let hasMutations = false;
+        const mutations = [];
         for (const textNode of mutatedTextNodes){
-            hasMutations = true;
-            this.renderer.markToSync('text', textNode);
+            mutations.push({
+                type: 'text',
+                node: textNode
+            });
         }
         for (const viewElement of elementsWithMutatedChildren){
             const domElement = domConverter.mapViewToDom(viewElement);
@@ -10164,20 +10211,23 @@ const UNSAFE_ELEMENT_REPLACEMENT_ATTRIBUTE = 'data-ck-unsafe-element';
             // It may happen that as a result of many changes (sth was inserted and then removed),
             // both elements haven't really changed. #1031
             if (!isEqualWith(viewChildren, newViewChildren, sameNodes)) {
-                hasMutations = true;
-                this.renderer.markToSync('children', viewElement);
+                mutations.push({
+                    type: 'children',
+                    node: viewElement
+                });
             }
         }
         // In case only non-relevant mutations were recorded it skips the event and force render (#5600).
-        if (hasMutations) {
+        if (mutations.length) {
             // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	_debouncedLine();
             // @if CK_DEBUG_TYPING // 	console.group( '%c[MutationObserver]%c Mutations detected',
-            // @if CK_DEBUG_TYPING // 		'font-weight:bold;color:green', ''
+            // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green', 'font-weight: bold'
             // @if CK_DEBUG_TYPING // 	);
             // @if CK_DEBUG_TYPING // }
-            // At this point we have "dirty DOM" (changed) and de-synched view (which has not been changed).
-            // In order to "reset DOM" we render the view again.
-            this.view.forceRender();
+            this.document.fire('mutations', {
+                mutations
+            });
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.groupEnd();
         // @if CK_DEBUG_TYPING // }
@@ -10225,7 +10275,7 @@ function sameNodes(child1, child2) {
  */ class FocusObserver extends DomEventObserver {
     /**
 	 * Identifier of the timeout currently used by focus listener to delay rendering execution.
-	 */ _renderTimeoutId;
+	 */ _renderTimeoutId = null;
     /**
 	 * Set to `true` if the document is in the process of setting the focus.
 	 *
@@ -10243,30 +10293,18 @@ function sameNodes(child1, child2) {
         super(view);
         this.useCapture = true;
         const document = this.document;
-        document.on('focus', ()=>{
-            this._isFocusChanging = true;
-            // Unfortunately native `selectionchange` event is fired asynchronously.
-            // We need to wait until `SelectionObserver` handle the event and then render. Otherwise rendering will
-            // overwrite new DOM selection with selection from the view.
-            // See https://github.com/ckeditor/ckeditor5-engine/issues/795 for more details.
-            // Long timeout is needed to solve #676 and https://github.com/ckeditor/ckeditor5-engine/issues/1157 issues.
-            //
-            // Using `view.change()` instead of `view.forceRender()` to prevent double rendering
-            // in a situation where `selectionchange` already caused selection change.
-            this._renderTimeoutId = setTimeout(()=>{
-                this.flush();
-                view.change(()=>{});
-            }, 50);
-        });
-        document.on('blur', (evt, data)=>{
-            const selectedEditable = document.selection.editableElement;
-            if (selectedEditable === null || selectedEditable === data.target) {
-                document.isFocused = false;
-                this._isFocusChanging = false;
-                // Re-render the document to update view elements
-                // (changing document.isFocused already marked view as changed since last rendering).
-                view.change(()=>{});
+        document.on('focus', ()=>this._handleFocus());
+        document.on('blur', (evt, data)=>this._handleBlur(data));
+        // Focus the editor in cases where browser dispatches `beforeinput` event to a not-focused editable element.
+        // This is flushed by the beforeinput listener in the `InsertTextObserver`.
+        // Note that focus is set only if the document is not focused yet.
+        // See https://github.com/ckeditor/ckeditor5/issues/14702.
+        document.on('beforeinput', ()=>{
+            if (!document.isFocused) {
+                this._handleFocus();
             }
+        }, {
+            priority: 'highest'
         });
     }
     /**
@@ -10285,10 +10323,47 @@ function sameNodes(child1, child2) {
     /**
 	 * @inheritDoc
 	 */ destroy() {
+        this._clearTimeout();
+        super.destroy();
+    }
+    /**
+	 * The `focus` event handler.
+	 */ _handleFocus() {
+        this._clearTimeout();
+        this._isFocusChanging = true;
+        // Unfortunately native `selectionchange` event is fired asynchronously.
+        // We need to wait until `SelectionObserver` handle the event and then render. Otherwise rendering will
+        // overwrite new DOM selection with selection from the view.
+        // See https://github.com/ckeditor/ckeditor5-engine/issues/795 for more details.
+        // Long timeout is needed to solve #676 and https://github.com/ckeditor/ckeditor5-engine/issues/1157 issues.
+        //
+        // Using `view.change()` instead of `view.forceRender()` to prevent double rendering
+        // in a situation where `selectionchange` already caused selection change.
+        this._renderTimeoutId = setTimeout(()=>{
+            this._renderTimeoutId = null;
+            this.flush();
+            this.view.change(()=>{});
+        }, 50);
+    }
+    /**
+	 * The `blur` event handler.
+	 */ _handleBlur(data) {
+        const selectedEditable = this.document.selection.editableElement;
+        if (selectedEditable === null || selectedEditable === data.target) {
+            this.document.isFocused = false;
+            this._isFocusChanging = false;
+            // Re-render the document to update view elements
+            // (changing document.isFocused already marked view as changed since last rendering).
+            this.view.change(()=>{});
+        }
+    }
+    /**
+	 * Clears timeout.
+	 */ _clearTimeout() {
         if (this._renderTimeoutId) {
             clearTimeout(this._renderTimeoutId);
+            this._renderTimeoutId = null;
         }
-        super.destroy();
     }
 }
 
@@ -10367,7 +10442,7 @@ function sameNodes(child1, child2) {
             }
             // Make sure that model selection is up-to-date at the end of selecting process.
             // Sometimes `selectionchange` events could arrive after the `mouseup` event and that selection could be already outdated.
-            this._handleSelectionChange(null, domDocument);
+            this._handleSelectionChange(domDocument);
             this.document.isSelecting = false;
             // The safety timeout can be canceled when the document leaves the "is selecting" state.
             this._documentIsSelectingInactivityTimeoutDebounced.cancel();
@@ -10398,10 +10473,11 @@ function sameNodes(child1, child2) {
         });
         this.listenTo(domDocument, 'selectionchange', (evt, domEvent)=>{
             // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	_debouncedLine();
             // @if CK_DEBUG_TYPING // 	const domSelection = domDocument.defaultView!.getSelection();
-            // @if CK_DEBUG_TYPING // 	console.group( '%c[SelectionObserver]%c selectionchange', 'color:green', ''
+            // @if CK_DEBUG_TYPING // 	console.group( '%c[SelectionObserver]%c selectionchange', 'color: green', ''
             // @if CK_DEBUG_TYPING // 	);
-            // @if CK_DEBUG_TYPING // 	console.info( '%c[SelectionObserver]%c DOM Selection:', 'font-weight:bold;color:green', '',
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[SelectionObserver]%c DOM Selection:', 'font-weight: bold; color: green', '',
             // @if CK_DEBUG_TYPING // 		{ node: domSelection!.anchorNode, offset: domSelection!.anchorOffset },
             // @if CK_DEBUG_TYPING // 		{ node: domSelection!.focusNode, offset: domSelection!.focusOffset }
             // @if CK_DEBUG_TYPING // 	);
@@ -10411,13 +10487,13 @@ function sameNodes(child1, child2) {
             if (this.document.isComposing && !env.isAndroid) {
                 // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
                 // @if CK_DEBUG_TYPING // 	console.info( '%c[SelectionObserver]%c Selection change ignored (isComposing)',
-                // @if CK_DEBUG_TYPING // 		'font-weight:bold;color:green', ''
+                // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green', ''
                 // @if CK_DEBUG_TYPING // 	);
                 // @if CK_DEBUG_TYPING // 	console.groupEnd();
                 // @if CK_DEBUG_TYPING // }
                 return;
             }
-            this._handleSelectionChange(domEvent, domDocument);
+            this._handleSelectionChange(domDocument);
             // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.groupEnd();
             // @if CK_DEBUG_TYPING // }
@@ -10425,6 +10501,26 @@ function sameNodes(child1, child2) {
             // using their mouse).
             this._documentIsSelectingInactivityTimeoutDebounced();
         });
+        // Update the model DocumentSelection just after the Renderer and the SelectionObserver are locked.
+        // We do this synchronously (without waiting for the `selectionchange` DOM event) as browser updates
+        // the DOM selection (but not visually) to span the text that is under composition and could be replaced.
+        this.listenTo(this.view.document, 'compositionstart', ()=>{
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	const domSelection = domDocument.defaultView!.getSelection();
+            // @if CK_DEBUG_TYPING // 	console.group( '%c[SelectionObserver]%c update selection on compositionstart', 'color: green', ''
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[SelectionObserver]%c DOM Selection:', 'font-weight: bold; color: green', '',
+            // @if CK_DEBUG_TYPING // 		{ node: domSelection!.anchorNode, offset: domSelection!.anchorOffset },
+            // @if CK_DEBUG_TYPING // 		{ node: domSelection!.focusNode, offset: domSelection!.focusOffset }
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+            this._handleSelectionChange(domDocument);
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	console.groupEnd();
+        // @if CK_DEBUG_TYPING // }
+        }, {
+            priority: 'lowest'
+        });
         this._documents.add(domDocument);
     }
     /**
@@ -10451,9 +10547,8 @@ function sameNodes(child1, child2) {
 	 * a selection changes and fires {@link module:engine/view/document~Document#event:selectionChange} event on every change
 	 * and {@link module:engine/view/document~Document#event:selectionChangeDone} when a selection stop changing.
 	 *
-	 * @param domEvent DOM event.
 	 * @param domDocument DOM document.
-	 */ _handleSelectionChange(domEvent, domDocument) {
+	 */ _handleSelectionChange(domDocument) {
         if (!this.isEnabled) {
             return;
         }
@@ -10501,7 +10596,7 @@ function sameNodes(child1, child2) {
             };
             // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.info( '%c[SelectionObserver]%c Fire selection change:',
-            // @if CK_DEBUG_TYPING // 		'font-weight:bold;color:green', '',
+            // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green', '',
             // @if CK_DEBUG_TYPING // 		newViewSelection.getFirstRange()
             // @if CK_DEBUG_TYPING // 	);
             // @if CK_DEBUG_TYPING // }
@@ -10521,6 +10616,7 @@ function sameNodes(child1, child2) {
     }
 }
 
+// @if CK_DEBUG_TYPING // const { _debouncedLine } = require( '../../dev-utils/utils.js' );
 /**
  * {@link module:engine/view/document~Document#event:compositionstart Compositionstart},
  * {@link module:engine/view/document~Document#event:compositionupdate compositionupdate} and
@@ -10567,6 +10663,7 @@ function sameNodes(child1, child2) {
 	 * @inheritDoc
 	 */ onDomEvent(domEvent) {
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	_debouncedLine();
         // @if CK_DEBUG_TYPING // 	console.group( `%c[CompositionObserver]%c ${ domEvent.type }`, 'color: green', '' );
         // @if CK_DEBUG_TYPING // }
         this.fire(domEvent.type, domEvent, {
@@ -10672,6 +10769,7 @@ function getFiles(nativeDataTransfer) {
     return items.filter((item)=>item.kind === 'file').map((item)=>item.getAsFile());
 }
 
+// @if CK_DEBUG_TYPING // const { _debouncedLine } = require( '../../dev-utils/utils.js' );
 /**
  * Observer for events connected with data input.
  *
@@ -10685,6 +10783,7 @@ function getFiles(nativeDataTransfer) {
 	 * @inheritDoc
 	 */ onDomEvent(domEvent) {
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	_debouncedLine();
         // @if CK_DEBUG_TYPING // 	console.group( `%c[InputObserver]%c ${ domEvent.type }: ${ domEvent.inputType }`,
         // @if CK_DEBUG_TYPING // 		'color: green', 'color: default'
         // @if CK_DEBUG_TYPING // 	);
@@ -10702,14 +10801,14 @@ function getFiles(nativeDataTransfer) {
             data = domEvent.data;
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( `%c[InputObserver]%c event data: %c${ JSON.stringify( data ) }`,
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', 'font-weight:bold', 'color: blue;'
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', 'color: blue;'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         } else if (dataTransfer) {
             data = dataTransfer.getData('text/plain');
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( `%c[InputObserver]%c event data transfer: %c${ JSON.stringify( data ) }`,
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', 'font-weight:bold', 'color: blue;'
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', 'color: blue;'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         }
@@ -10720,7 +10819,7 @@ function getFiles(nativeDataTransfer) {
             targetRanges = Array.from(viewDocument.selection.getRanges());
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using fake selection:',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', 'font-weight:bold', targetRanges,
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges,
         // @if CK_DEBUG_TYPING // 		viewDocument.selection.isFake ? 'fake view selection' : 'fake DOM parent'
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
@@ -10740,7 +10839,7 @@ function getFiles(nativeDataTransfer) {
             }).filter((range)=>!!range);
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using target ranges:',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', 'font-weight:bold', targetRanges
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         } else if (env.isAndroid) {
@@ -10748,7 +10847,7 @@ function getFiles(nativeDataTransfer) {
             targetRanges = Array.from(view.domConverter.domSelectionToView(domSelection).getRanges());
         // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using selection ranges:',
-        // @if CK_DEBUG_TYPING // 		'color: green;font-weight: bold', 'font-weight:bold', targetRanges
+        // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges
         // @if CK_DEBUG_TYPING // 	);
         // @if CK_DEBUG_TYPING // }
         }
@@ -10923,8 +11022,6 @@ function getFiles(nativeDataTransfer) {
 	 */ domRoots = new Map();
     /**
 	 * Instance of the {@link module:engine/view/renderer~Renderer renderer}.
-	 *
-	 * @internal
 	 */ _renderer;
     /**
 	 * A DOM root attributes cache. It saves the initial values of DOM root attributes before the DOM element
@@ -11003,6 +11100,19 @@ function getFiles(nativeDataTransfer) {
                 }
             });
         }
+        // Listen to external content mutations (directly in the DOM) and mark them to get verified by the renderer.
+        this.listenTo(this.document, 'mutations', (evt, { mutations })=>{
+            mutations.forEach((mutation)=>this._renderer.markToSync(mutation.type, mutation.node));
+        }, {
+            priority: 'low'
+        });
+        // After all mutated nodes were marked to sync we can trigger view to DOM synchronization
+        // to make sure the DOM structure matches the view.
+        this.listenTo(this.document, 'mutations', ()=>{
+            this.forceRender();
+        }, {
+            priority: 'lowest'
+        });
     }
     /**
 	 * Attaches a DOM root element to the view element and enable all observers on that element.
@@ -20291,14 +20401,7 @@ function getFromAttributeCreator(config) {
             if (data.viewItem.data.trim().length == 0) {
                 return;
             }
-            // Wrap `$text` in paragraph and include any marker that is directly before `$text`. See #13053.
-            const nodeBefore = position.nodeBefore;
             position = wrapInParagraph(position, writer);
-            if (nodeBefore && nodeBefore.is('element', '$marker')) {
-                // Move `$marker` to the paragraph.
-                writer.move(writer.createRangeOn(nodeBefore), position);
-                position = writer.createPositionAfter(nodeBefore);
-            }
         }
         consumable.consume(data.viewItem);
         const text = writer.createText(data.viewItem.data);
@@ -21782,6 +21885,22 @@ const CONSUMABLE_TYPES = [
     /**
 	 * A dictionary containing attribute properties.
 	 */ _attributeProperties = {};
+    /**
+	 * Stores additional callbacks registered for schema items, which are evaluated when {@link ~Schema#checkChild} is called.
+	 *
+	 * Keys are schema item names for which the callbacks are registered. Values are arrays with the callbacks.
+	 *
+	 * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every {@link ~Schema#checkChild} call.
+	 */ _customChildChecks = new Map();
+    /**
+	 * Stores additional callbacks registered for attribute names, which are evaluated when {@link ~Schema#checkAttribute} is called.
+	 *
+	 * Keys are schema attribute names for which the callbacks are registered. Values are arrays with the callbacks.
+	 *
+	 * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every
+	 * {@link ~Schema#checkAttribute} call.
+	 */ _customAttributeChecks = new Map();
+    _genericCheckSymbol = Symbol('$generic');
     _compiledDefinitions;
     /**
 	 * Creates a schema instance.
@@ -22054,7 +22173,7 @@ const CONSUMABLE_TYPES = [
         return !!(def.isContent || def.isObject);
     }
     /**
-	 * Checks whether the given node (`child`) can be a child of the given context.
+	 * Checks whether the given node can be a child of the given context.
 	 *
 	 * ```ts
 	 * schema.checkChild( model.document.getRoot(), paragraph ); // -> false
@@ -22062,27 +22181,33 @@ const CONSUMABLE_TYPES = [
 	 * schema.register( 'paragraph', {
 	 * 	allowIn: '$root'
 	 * } );
+	 *
 	 * schema.checkChild( model.document.getRoot(), paragraph ); // -> true
 	 * ```
 	 *
-	 * Note: When verifying whether the given node can be a child of the given context, the
-	 * schema also verifies the entire context &ndash; from its root to its last element. Therefore, it is possible
-	 * for `checkChild()` to return `false` even though the context's last element can contain the checked child.
-	 * It happens if one of the context's elements does not allow its child.
+	 * Both {@link module:engine/model/schema~Schema#addChildCheck callback checks} and declarative rules (added when
+	 * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+	 * are evaluated when this method is called.
+	 *
+	 * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
+	 *
+	 * Note that when verifying whether the given node can be a child of the given context, the schema also verifies the entire
+	 * context &ndash; from its root to its last element. Therefore, it is possible for `checkChild()` to return `false` even though
+	 * the `context` last element can contain the checked child. It happens if one of the `context` elements does not allow its child.
+	 * When `context` is verified, {@link module:engine/model/schema~Schema#addChildCheck custom checks} are considered as well.
 	 *
 	 * @fires checkChild
 	 * @param context The context in which the child will be checked.
 	 * @param def The child to check.
 	 */ checkChild(context, def) {
-        // Note: context and child are already normalized here to a SchemaContext and SchemaCompiledItemDefinition.
+        // Note: `context` and `def` are already normalized here to `SchemaContext` and `SchemaCompiledItemDefinition`.
         if (!def) {
             return false;
         }
-        return this._checkContextMatch(def, context);
+        return this._checkContextMatch(context, def);
     }
     /**
-	 * Checks whether the given attribute can be applied in the given context (on the last
-	 * item of the context).
+	 * Checks whether the given attribute can be applied in the given context (on the last item of the context).
 	 *
 	 * ```ts
 	 * schema.checkAttribute( textNode, 'bold' ); // -> false
@@ -22090,22 +22215,36 @@ const CONSUMABLE_TYPES = [
 	 * schema.extend( '$text', {
 	 * 	allowAttributes: 'bold'
 	 * } );
+	 *
 	 * schema.checkAttribute( textNode, 'bold' ); // -> true
 	 * ```
 	 *
+	 * Both {@link module:engine/model/schema~Schema#addAttributeCheck callback checks} and declarative rules (added when
+	 * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+	 * are evaluated when this method is called.
+	 *
+	 * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
+	 *
 	 * @fires checkAttribute
 	 * @param context The context in which the attribute will be checked.
+	 * @param attributeName Name of attribute to check in the given context.
 	 */ checkAttribute(context, attributeName) {
+        // Note: `context` is already normalized here to `SchemaContext`.
         const def = this.getDefinition(context.last);
         if (!def) {
             return false;
         }
-        return def.allowAttributes.includes(attributeName);
+        // First, check all attribute checks declared as callbacks.
+        // Note that `_evaluateAttributeChecks()` will return `undefined` if neither child check was applicable (no decision was made).
+        const isAllowed = this._evaluateAttributeChecks(context, attributeName);
+        // If the decision was not made inside attribute check callbacks, then use declarative rules.
+        return isAllowed !== undefined ? isAllowed : def.allowAttributes.includes(attributeName);
     }
     /**
 	 * Checks whether the given element (`elementToMerge`) can be merged with the specified base element (`positionOrBaseElement`).
 	 *
-	 * In other words &ndash; whether `elementToMerge`'s children {@link #checkChild are allowed} in the `positionOrBaseElement`.
+	 * In other words &ndash; both elements are not a limit elements and whether `elementToMerge`'s children
+	 * {@link #checkChild are allowed} in the `positionOrBaseElement`.
 	 *
 	 * This check ensures that elements merged with {@link module:engine/model/writer~Writer#merge `Writer#merge()`}
 	 * will be valid.
@@ -22135,6 +22274,9 @@ const CONSUMABLE_TYPES = [
             }
             return this.checkMerge(nodeBefore, nodeAfter);
         }
+        if (this.isLimit(positionOrBaseElement) || this.isLimit(elementToMerge)) {
+            return false;
+        }
         for (const child of elementToMerge.getChildren()){
             if (!this.checkChild(positionOrBaseElement, child)) {
                 return false;
@@ -22147,112 +22289,137 @@ const CONSUMABLE_TYPES = [
 	 *
 	 * Callbacks allow you to implement rules which are not otherwise possible to achieve
 	 * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
-	 * For example, by using this method you can disallow elements in specific contexts.
 	 *
-	 * This method is a shorthand for using the {@link #event:checkChild} event. For even better control,
-	 * you can use that event instead.
+	 * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
 	 *
-	 * Example:
+	 * For example, by using this method you can disallow elements in specific contexts:
 	 *
 	 * ```ts
-	 * // Disallow heading1 directly inside a blockQuote.
+	 * // Disallow `heading1` inside a `blockQuote` that is inside a table.
 	 * schema.addChildCheck( ( context, childDefinition ) => {
-	 * 	if ( context.endsWith( 'blockQuote' ) && childDefinition.name == 'heading1' ) {
+	 * 	if ( context.endsWith( 'tableCell blockQuote' ) ) {
 	 * 		return false;
 	 * 	}
+	 * }, 'heading1' );
+	 * ```
+	 *
+	 * You can skip the optional `itemName` parameter to evaluate the callback for every `checkChild()` call.
+	 *
+	 * ```ts
+	 * // Inside specific custom element, allow only children, which allows for a specific attribute.
+	 * schema.addChildCheck( ( context, childDefinition ) => {
+	 * 	if ( context.endsWith( 'myElement' ) ) {
+	 * 		return childDefinition.allowAttributes.includes( 'myAttribute' );
+	 * 	}
 	 * } );
 	 * ```
 	 *
-	 * Which translates to:
+	 * Please note that the generic callbacks may affect the editor performance and should be avoided if possible.
+	 *
+	 * When one of the callbacks makes a decision (returns `true` or `false`) the processing is finished and other callbacks are not fired.
+	 * Callbacks are fired in the order they were added, however generic callbacks are fired before callbacks added for a specified item.
+	 *
+	 * You can also use `checkChild` event, if you need even better control. The result from the example above could also be
+	 * achieved with following event callback:
 	 *
 	 * ```ts
 	 * schema.on( 'checkChild', ( evt, args ) => {
 	 * 	const context = args[ 0 ];
 	 * 	const childDefinition = args[ 1 ];
 	 *
-	 * 	if ( context.endsWith( 'blockQuote' ) && childDefinition && childDefinition.name == 'heading1' ) {
+	 * 	if ( context.endsWith( 'myElement' ) ) {
 	 * 		// Prevent next listeners from being called.
 	 * 		evt.stop();
-	 * 		// Set the checkChild()'s return value.
-	 * 		evt.return = false;
+	 * 		// Set the `checkChild()` return value.
+	 * 		evt.return = childDefinition.allowAttributes.includes( 'myAttribute' );
 	 * 	}
 	 * }, { priority: 'high' } );
 	 * ```
 	 *
+	 * Note that the callback checks and declarative rules checks are processed on `normal` priority.
+	 *
+	 * Adding callbacks this way can also negatively impact editor performance.
+	 *
 	 * @param callback The callback to be called. It is called with two parameters:
 	 * {@link module:engine/model/schema~SchemaContext} (context) instance and
-	 * {@link module:engine/model/schema~SchemaCompiledItemDefinition} (child-to-check definition).
-	 * The callback may return `true/false` to override `checkChild()`'s return value. If it does not return
-	 * a boolean value, the default algorithm (or other callbacks) will define `checkChild()`'s return value.
-	 */ addChildCheck(callback) {
-        this.on('checkChild', (evt, [ctx, childDef])=>{
-            // checkChild() was called with a non-registered child.
-            // In 99% cases such check should return false, so not to overcomplicate all callbacks
-            // don't even execute them.
-            if (!childDef) {
-                return;
-            }
-            const retValue = callback(ctx, childDef);
-            if (typeof retValue == 'boolean') {
-                evt.stop();
-                evt.return = retValue;
-            }
-        }, {
-            priority: 'high'
-        });
+	 * {@link module:engine/model/schema~SchemaCompiledItemDefinition} (definition). The callback may return `true/false` to override
+	 * `checkChild()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks) will define
+	 * `checkChild()`'s return value.
+	 * @param itemName Name of the schema item for which the callback is registered. If specified, the callback will be run only for
+	 * `checkChild()` calls which `def` parameter matches the `itemName`. Otherwise, the callback will run for every `checkChild` call.
+	 */ addChildCheck(callback, itemName) {
+        const key = itemName !== undefined ? itemName : this._genericCheckSymbol;
+        const checks = this._customChildChecks.get(key) || [];
+        checks.push(callback);
+        this._customChildChecks.set(key, checks);
     }
     /**
 	 * Allows registering a callback to the {@link #checkAttribute} method calls.
 	 *
 	 * Callbacks allow you to implement rules which are not otherwise possible to achieve
 	 * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
-	 * For example, by using this method you can disallow attribute if node to which it is applied
-	 * is contained within some other element (e.g. you want to disallow `bold` on `$text` within `heading1`).
 	 *
-	 * This method is a shorthand for using the {@link #event:checkAttribute} event. For even better control,
-	 * you can use that event instead.
+	 * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
 	 *
-	 * Example:
+	 * For example, by using this method you can disallow setting attributes on nodes in specific contexts:
 	 *
 	 * ```ts
-	 * // Disallow bold on $text inside heading1.
+	 * // Disallow setting `bold` on text inside `heading1` element:
+	 * schema.addAttributeCheck( context => {
+	 * 	if ( context.endsWith( 'heading1 $text' ) ) {
+	 * 		return false;
+	 * 	}
+	 * }, 'bold' );
+	 * ```
+	 *
+	 * You can skip the optional `attributeName` parameter to evaluate the callback for every `checkAttribute()` call.
+	 *
+	 * ```ts
+	 * // Disallow formatting attributes on text inside custom `myTitle` element:
 	 * schema.addAttributeCheck( ( context, attributeName ) => {
-	 * 	if ( context.endsWith( 'heading1 $text' ) && attributeName == 'bold' ) {
+	 * 	if ( context.endsWith( 'myTitle $text' ) && schema.getAttributeProperties( attributeName ).isFormatting ) {
 	 * 		return false;
 	 * 	}
 	 * } );
 	 * ```
 	 *
-	 * Which translates to:
+	 * Please note that the generic callbacks may affect the editor performance and should be avoided if possible.
+	 *
+	 * When one of the callbacks makes a decision (returns `true` or `false`) the processing is finished and other callbacks are not fired.
+	 * Callbacks are fired in the order they were added, however generic callbacks are fired before callbacks added for a specified item.
+	 *
+	 * You can also use {@link #event:checkAttribute} event, if you need even better control. The result from the example above could also
+	 * be achieved with following event callback:
 	 *
 	 * ```ts
 	 * schema.on( 'checkAttribute', ( evt, args ) => {
 	 * 	const context = args[ 0 ];
 	 * 	const attributeName = args[ 1 ];
 	 *
-	 * 	if ( context.endsWith( 'heading1 $text' ) && attributeName == 'bold' ) {
+	 * 	if ( context.endsWith( 'myTitle $text' ) && schema.getAttributeProperties( attributeName ).isFormatting ) {
 	 * 		// Prevent next listeners from being called.
 	 * 		evt.stop();
-	 * 		// Set the checkAttribute()'s return value.
+	 * 		// Set the `checkAttribute()` return value.
 	 * 		evt.return = false;
 	 * 	}
 	 * }, { priority: 'high' } );
 	 * ```
 	 *
+	 * Note that the callback checks and declarative rules checks are processed on `normal` priority.
+	 *
+	 * Adding callbacks this way can also negatively impact editor performance.
+	 *
 	 * @param callback The callback to be called. It is called with two parameters:
-	 * {@link module:engine/model/schema~SchemaContext} (context) instance and attribute name.
-	 * The callback may return `true/false` to override `checkAttribute()`'s return value. If it does not return
-	 * a boolean value, the default algorithm (or other callbacks) will define `checkAttribute()`'s return value.
-	 */ addAttributeCheck(callback) {
-        this.on('checkAttribute', (evt, [ctx, attributeName])=>{
-            const retValue = callback(ctx, attributeName);
-            if (typeof retValue == 'boolean') {
-                evt.stop();
-                evt.return = retValue;
-            }
-        }, {
-            priority: 'high'
-        });
+	 * {@link module:engine/model/schema~SchemaContext `context`} and attribute name. The callback may return `true` or `false`, to
+	 * override `checkAttribute()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks)
+	 * will define `checkAttribute()`'s return value.
+	 * @param attributeName Name of the attribute for which the callback is registered. If specified, the callback will be run only for
+	 * `checkAttribute()` calls with matching `attributeName`. Otherwise, the callback will run for every `checkAttribute()` call.
+	 */ addAttributeCheck(callback, attributeName) {
+        const key = attributeName !== undefined ? attributeName : this._genericCheckSymbol;
+        const checks = this._customAttributeChecks.get(key) || [];
+        checks.push(callback);
+        this._customAttributeChecks.set(key, checks);
     }
     /**
 	 * This method allows assigning additional metadata to the model attributes. For example,
@@ -22579,18 +22746,68 @@ const CONSUMABLE_TYPES = [
         // Compile final definitions. Unnecessary properties are removed and some additional cleaning is applied.
         this._compiledDefinitions = compileDefinitions(definitions);
     }
-    _checkContextMatch(def, context, contextItemIndex = context.length - 1) {
-        const contextItem = context.getItem(contextItemIndex);
-        if (def.allowIn.includes(contextItem.name)) {
-            if (contextItemIndex == 0) {
-                return true;
-            } else {
-                const parentRule = this.getDefinition(contextItem);
-                return this._checkContextMatch(parentRule, context, contextItemIndex - 1);
-            }
-        } else {
+    _checkContextMatch(context, def) {
+        const parentItem = context.last;
+        // First, check all child checks declared as callbacks.
+        // Note that `_evaluateChildChecks()` will return `undefined` if neither child check was applicable (no decision was made).
+        let isAllowed = this._evaluateChildChecks(context, def);
+        // If the decision was not made inside child check callbacks, then use declarative rules.
+        isAllowed = isAllowed !== undefined ? isAllowed : def.allowIn.includes(parentItem.name);
+        // If the item is not allowed in the `context`, return `false`.
+        if (!isAllowed) {
             return false;
         }
+        // If the item is allowed, recursively verify the rest of the `context`.
+        const parentItemDefinition = this.getDefinition(parentItem);
+        const parentContext = context.trimLast();
+        // One of the items in the original `context` did not have a definition specified. In this case, the whole context is disallowed.
+        if (!parentItemDefinition) {
+            return false;
+        }
+        // Whole `context` was verified and passed checks.
+        if (parentContext.length == 0) {
+            return true;
+        }
+        // Verify "truncated" parent context. The last item of the original context is now the definition to check.
+        return this._checkContextMatch(parentContext, parentItemDefinition);
+    }
+    /**
+	 * Calls child check callbacks to decide whether `def` is allowed in `context`. It uses both generic and specific (defined for `def`
+	 * item) callbacks. If neither callback makes a decision, `undefined` is returned.
+	 *
+	 * Note that the first callback that makes a decision "wins", i.e., if any callback returns `true` or `false`, then the processing
+	 * is over and that result is returned.
+	 */ _evaluateChildChecks(context, def) {
+        const genericChecks = this._customChildChecks.get(this._genericCheckSymbol) || [];
+        const childChecks = this._customChildChecks.get(def.name) || [];
+        for (const check of [
+            ...genericChecks,
+            ...childChecks
+        ]){
+            const result = check(context, def);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+    }
+    /**
+	 * Calls attribute check callbacks to decide whether `attributeName` can be set on the last element of `context`. It uses both
+	 * generic and specific (defined for `attributeName`) callbacks. If neither callback makes a decision, `undefined` is returned.
+	 *
+	 * Note that the first callback that makes a decision "wins", i.e., if any callback returns `true` or `false`, then the processing
+	 * is over and that result is returned.
+	 */ _evaluateAttributeChecks(context, attributeName) {
+        const genericChecks = this._customAttributeChecks.get(this._genericCheckSymbol) || [];
+        const childChecks = this._customAttributeChecks.get(attributeName) || [];
+        for (const check of [
+            ...genericChecks,
+            ...childChecks
+        ]){
+            const result = check(context, attributeName);
+            if (result !== undefined) {
+                return result;
+            }
+        }
     }
     /**
 	 * Takes a flat range and an attribute name. Traverses the range recursively and deeply to find and return all ranges
@@ -22768,6 +22985,21 @@ const CONSUMABLE_TYPES = [
         ];
         return ctx;
     }
+    /**
+	 * Returns a new schema context that is based on this context but has the last item removed.
+	 *
+	 * ```ts
+	 * const ctxParagraph = new SchemaContext( [ '$root', 'blockQuote', 'paragraph' ] );
+	 * const ctxBlockQuote = ctxParagraph.trimLast(); // Items in `ctxBlockQuote` are: `$root` an `blockQuote`.
+	 * const ctxRoot = ctxBlockQuote.trimLast(); // Items in `ctxRoot` are: `$root`.
+	 * ```
+	 *
+	 * @returns A new reduced schema context instance.
+	 */ trimLast() {
+        const ctx = new SchemaContext([]);
+        ctx._items = this._items.slice(0, -1);
+        return ctx;
+    }
     /**
 	 * Gets an item on the given index.
 	 */ getItem(index) {
@@ -33350,25 +33582,14 @@ function removeRangeContent(range, writer) {
     /**
 	 * Handles insertion of a single node.
 	 */ _handleNode(node) {
-        // Let's handle object in a special way.
-        // * They should never be merged with other elements.
-        // * If they are not allowed in any of the selection ancestors, they could be either autoparagraphed or totally removed.
-        if (this.schema.isObject(node)) {
-            this._handleObject(node);
-            return;
-        }
-        // Try to find a place for the given node.
-        // Check if a node can be inserted in the given position or it would be accepted if a paragraph would be inserted.
-        // Inserts the auto paragraph if it would allow for insertion.
-        let isAllowed = this._checkAndAutoParagraphToAllowedPosition(node);
-        if (!isAllowed) {
-            // Split the position.parent's branch up to a point where the node can be inserted.
-            // If it isn't allowed in the whole branch, then of course don't split anything.
-            isAllowed = this._checkAndSplitToAllowedPosition(node);
-            if (!isAllowed) {
+        // Split the position.parent's branch up to a point where the node can be inserted.
+        // If it isn't allowed in the whole branch, then of course don't split anything.
+        if (!this._checkAndSplitToAllowedPosition(node)) {
+            // Handle element children if it's not an object (strip container).
+            if (!this.schema.isObject(node)) {
                 this._handleDisallowedNode(node);
-                return;
             }
+            return;
         }
         // Add node to the current temporary DocumentFragment.
         this._appendToFragment(node);
@@ -33404,24 +33625,12 @@ function removeRangeContent(range, writer) {
         this.position = livePosition.toPosition();
         livePosition.detach();
     }
-    /**
-	 * @param node The object element.
-	 */ _handleObject(node) {
-        // Try finding it a place in the tree.
-        if (this._checkAndSplitToAllowedPosition(node)) {
-            this._appendToFragment(node);
-        } else {
-            this._tryAutoparagraphing(node);
-        }
-    }
     /**
 	 * @param node The disallowed node which needs to be handled.
 	 */ _handleDisallowedNode(node) {
         // If the node is an element, try inserting its children (strip the parent).
         if (node.is('element')) {
             this.handleNodes(node.getChildren());
-        } else {
-            this._tryAutoparagraphing(node);
         }
     }
     /**
@@ -33626,35 +33835,8 @@ function removeRangeContent(range, writer) {
         return nextSibling instanceof Element && this.canMergeWith.has(nextSibling) && this.model.schema.checkMerge(node, nextSibling);
     }
     /**
-	 * Tries wrapping the node in a new paragraph and inserting it this way.
-	 *
-	 * @param node The node which needs to be autoparagraphed.
-	 */ _tryAutoparagraphing(node) {
-        const paragraph = this.writer.createElement('paragraph');
-        // Do not autoparagraph if the paragraph won't be allowed there,
-        // cause that would lead to an infinite loop. The paragraph would be rejected in
-        // the next _handleNode() call and we'd be here again.
-        if (this._getAllowedIn(this.position.parent, paragraph) && this.schema.checkChild(paragraph, node)) {
-            paragraph._appendChild(node);
-            this._handleNode(paragraph);
-        }
-    }
-    /**
-	 * Checks if a node can be inserted in the given position or it would be accepted if a paragraph would be inserted.
-	 * It also handles inserting the paragraph.
-	 *
-	 * @returns Whether an allowed position was found.
-	 * `false` is returned if the node isn't allowed at the current position or in auto paragraph, `true` if was.
-	 */ _checkAndAutoParagraphToAllowedPosition(node) {
-        if (this.schema.checkChild(this.position.parent, node)) {
-            return true;
-        }
-        // Do not auto paragraph if the paragraph won't be allowed there,
-        // cause that would lead to an infinite loop. The paragraph would be rejected in
-        // the next _handleNode() call and we'd be here again.
-        if (!this.schema.checkChild(this.position.parent, 'paragraph') || !this.schema.checkChild('paragraph', node)) {
-            return false;
-        }
+	 * Inserts a paragraph and moves the insertion position into it.
+	 */ _insertAutoParagraph() {
         // Insert nodes collected in temporary DocumentFragment if the position parent needs change to process further nodes.
         this._insertPartialFragment();
         // Insert a paragraph and move insertion position to it.
@@ -33663,7 +33845,6 @@ function removeRangeContent(range, writer) {
         this._setAffectedBoundaries(this.position);
         this._lastAutoParagraph = paragraph;
         this.position = this.writer.createPositionAt(paragraph, 0);
-        return true;
     }
     /**
 	 * @returns Whether an allowed position was found.
@@ -33707,17 +33888,30 @@ function removeRangeContent(range, writer) {
                 this.canMergeWith.add(this.position.nodeAfter);
             }
         }
+        // At this point, we split elements up to the parent in which `node` is allowed.
+        // Note that `_getAllowedIn()` checks if the `node` is allowed either directly, or when auto-paragraphed.
+        // So, let's check if the `node` is allowed directly. If not, we need to auto-paragraph it.
+        if (!this.schema.checkChild(this.position.parent, node)) {
+            this._insertAutoParagraph();
+        }
         return true;
     }
     /**
 	 * Gets the element in which the given node is allowed. It checks the passed element and all its ancestors.
 	 *
+	 * It also verifies if auto-paragraphing could help.
+	 *
 	 * @param contextElement The element in which context the node should be checked.
 	 * @param childNode The node to check.
 	 */ _getAllowedIn(contextElement, childNode) {
+        // Check if a node can be inserted in the given context...
         if (this.schema.checkChild(contextElement, childNode)) {
             return contextElement;
         }
+        // ...or it would be accepted if a paragraph would be inserted.
+        if (this.schema.checkChild(contextElement, 'paragraph') && this.schema.checkChild('paragraph', childNode)) {
+            return contextElement;
+        }
         // If the child wasn't allowed in the context element and the element is a limit there's no point in
         // checking any further towards the root. This is it: the limit is unsplittable and there's nothing
         // we can do about it. Without this check, the algorithm will analyze parent of the limit and may create
@@ -34117,11 +34311,7 @@ function getSearchRange(start, isForward) {
         // at the end of the conversion. `UpcastDispatcher` or at least `Conversion` class looks like a
         // better place for this registration but both know nothing about `Schema`.
         this.schema.register('$marker');
-        this.schema.addChildCheck((context, childDefinition)=>{
-            if (childDefinition.name === '$marker') {
-                return true;
-            }
-        });
+        this.schema.addChildCheck(()=>true, '$marker'); // Allow everywhere.
         injectSelectionPostFixer(this);
         // Post-fixer which takes care of adding empty paragraph elements to the empty roots.
         this.document.registerPostFixer(autoParagraphEmptyRoots);
@@ -36494,6 +36684,9 @@ setData$1._parse = parse$1;
     const processor = new XmlDataProcessor(viewDocument, {
         namespaces: Object.keys(allowedTypes)
     });
+    if (options.inlineObjectElements) {
+        processor.domConverter.inlineObjectElements.push(...options.inlineObjectElements);
+    }
     // Convert data to view.
     let view = processor.toView(data);
     // At this point we have a view tree with Elements that could have names like `attribute:b:1`. In the next step
@@ -37159,7 +37352,8 @@ getData._stringify = stringify;
         selectionAttributes: options.selectionAttributes,
         context: [
             modelRoot.name
-        ]
+        ],
+        inlineObjectElements: options.inlineObjectElements
     });
     // Retrieve DocumentFragment and Selection from parsed model.
     if ('model' in parsedResult) {
@@ -37330,7 +37524,8 @@ setData._parse = parse;
     // Parse data to view using view utils.
     const parsedResult = parse$1(data, {
         sameSelectionCharacters: true,
-        lastRangeBackward: !!options.lastRangeBackward
+        lastRangeBackward: !!options.lastRangeBackward,
+        inlineObjectElements: options.inlineObjectElements
     });
     // Retrieve DocumentFragment and Selection from parsed view.
     let viewDocumentFragment;
@@ -37465,5 +37660,5 @@ function* convertAttributes(attributes, converter) {
     }
 }
 
-export { AttributeElement, AttributeOperation, BubblingEventInfo, ClickObserver, Conversion, DataController, DataTransfer, DocumentFragment, DocumentSelection, DomConverter, DomEventData, DomEventObserver, DowncastWriter, EditingController, View as EditingView, Element, FocusObserver, History, HtmlDataProcessor, InsertOperation, LivePosition, LiveRange, MarkerOperation, Matcher, MergeOperation, Model, MouseObserver, MoveOperation, NoOperation, Observer, OperationFactory, Position, Range, RenameOperation, Renderer, RootAttributeOperation, RootOperation, SplitOperation, StylesMap, StylesProcessor, TabObserver, Text, TextProxy, TreeWalker, UpcastWriter, AttributeElement as ViewAttributeElement, ContainerElement as ViewContainerElement, Document$1 as ViewDocument, DocumentFragment$1 as ViewDocumentFragment, EditableElement as ViewEditableElement, Element$1 as ViewElement, EmptyElement as ViewEmptyElement, RawElement as ViewRawElement, RootEditableElement as ViewRootEditableElement, Text$1 as ViewText, TreeWalker$1 as ViewTreeWalker, UIElement as ViewUIElement, XmlDataProcessor, getData as _getModelData, getData$1 as _getViewData, parse as _parseModel, parse$1 as _parseView, setData as _setModelData, setData$1 as _setViewData, stringify as _stringifyModel, stringify$1 as _stringifyView, addBackgroundRules, addBorderRules, addMarginRules, addPaddingRules, disablePlaceholder, enablePlaceholder, getBoxSidesShorthandValue, getBoxSidesValueReducer, getBoxSidesValues, getFillerOffset$4 as getFillerOffset, getPositionShorthandNormalizer, getShorthandValues, hidePlaceholder, isAttachment, isColor, isLength, isLineStyle, isPercentage, isPosition, isRepeat, isURL, needsPlaceholder, showPlaceholder, transformSets };
+export { AttributeElement, AttributeOperation, BubblingEventInfo, ClickObserver, Conversion, DataController, DataTransfer, DocumentFragment, DocumentSelection, DomConverter, DomEventData, DomEventObserver, DowncastWriter, EditingController, View as EditingView, Element, FocusObserver, History, HtmlDataProcessor, InsertOperation, LivePosition, LiveRange, MarkerOperation, Matcher, MergeOperation, Model, MouseObserver, MoveOperation, NoOperation, Observer, OperationFactory, Position, Range, RenameOperation, Renderer, RootAttributeOperation, RootOperation, SplitOperation, StylesMap, StylesProcessor, TabObserver, Text, TextProxy, TreeWalker, UpcastWriter, AttributeElement as ViewAttributeElement, ContainerElement as ViewContainerElement, Document$1 as ViewDocument, DocumentFragment$1 as ViewDocumentFragment, EditableElement as ViewEditableElement, Element$1 as ViewElement, EmptyElement as ViewEmptyElement, RawElement as ViewRawElement, RootEditableElement as ViewRootEditableElement, Text$1 as ViewText, TreeWalker$1 as ViewTreeWalker, UIElement as ViewUIElement, XmlDataProcessor, getData as _getModelData, getData$1 as _getViewData, parse as _parseModel, parse$1 as _parseView, setData as _setModelData, setData$1 as _setViewData, stringify as _stringifyModel, stringify$1 as _stringifyView, addBackgroundRules, addBorderRules, addMarginRules, addPaddingRules, autoParagraphEmptyRoots, disablePlaceholder, enablePlaceholder, getBoxSidesShorthandValue, getBoxSidesValueReducer, getBoxSidesValues, getFillerOffset$4 as getFillerOffset, getPositionShorthandNormalizer, getShorthandValues, hidePlaceholder, isAttachment, isColor, isLength, isLineStyle, isParagraphable, isPercentage, isPosition, isRepeat, isURL, needsPlaceholder, showPlaceholder, transformSets, wrapInParagraph };
 //# sourceMappingURL=index.js.map