@ckeditor/ckeditor5-engine 27.1.0 → 29.2.0

package/src/model/schema.js

@@ -18,23 +18,23 @@ import Text from './text';
 import TreeWalker from './treewalker';
 
 /**
- * The model's schema. It defines allowed and disallowed structures of nodes as well as nodes' attributes.
- * The schema is usually defined by features and based on them the editing framework and features
- * make decisions how to change and process the model.
+ * The model's schema. It defines the allowed and disallowed structures of nodes as well as nodes' attributes.
+ * The schema is usually defined by the features and based on them, the editing framework and features
+ * make decisions on how to change and process the model.
  *
  * The instance of schema is available in {@link module:engine/model/model~Model#schema `editor.model.schema`}.
  *
  * Read more about the schema in:
  *
- * * {@glink framework/guides/architecture/editing-engine#schema Schema} section of the
- * {@glink framework/guides/architecture/editing-engine Introduction to the Editing engine architecture}.
- * * {@glink framework/guides/deep-dive/schema Schema deep dive} guide.
+ * * The {@glink framework/guides/architecture/editing-engine#schema schema section} of the
+ * {@glink framework/guides/architecture/editing-engine Introduction to the Editing engine architecture} guide.
+ * * The {@glink framework/guides/deep-dive/schema Schema deep dive} guide.
  *
  * @mixes module:utils/observablemixin~ObservableMixin
  */
 export default class Schema {
 	/**
-	 * Creates schema instance.
+	 * Creates a schema instance.
 	 */
 	constructor() {
 		this._sourceDefinitions = {};
@@ -61,7 +61,7 @@ export default class Schema {
 	}
 
 	/**
-	 * Registers schema item. Can only be called once for every item name.
+	 * Registers a schema item. Can only be called once for every item name.
 	 *
 	 *		schema.register( 'paragraph', {
 	 *			inheritAllFrom: '$block'
@@ -205,6 +205,7 @@ export default class Schema {
 	 *		schema.isRegistered( 'foo' ); // -> false
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+ 	 * @returns {Boolean}
 	 */
 	isRegistered( item ) {
 		return !!this.getDefinition( item );
@@ -220,10 +221,11 @@ export default class Schema {
 	 *		const paragraphElement = writer.createElement( 'paragraph' );
 	 *		schema.isBlock( paragraphElement ); // -> true
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#block-elements Block elements} section of the Schema deep dive
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#block-elements Block elements} section of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+  	 * @returns {Boolean}
 	 */
 	isBlock( item ) {
 		const def = this.getDefinition( item );
@@ -243,12 +245,13 @@ export default class Schema {
 	 *		schema.isLimit( 'paragraph' ); // -> false
 	 *		schema.isLimit( '$root' ); // -> true
 	 *		schema.isLimit( editor.model.document.getRoot() ); // -> true
-	 *		schema.isLimit( 'image' ); // -> true
+	 *		schema.isLimit( 'imageBlock' ); // -> true
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#limit-elements Limit elements} section of the Schema deep dive
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#limit-elements Limit elements} section of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+  	 * @returns {Boolean}
 	 */
 	isLimit( item ) {
 		const def = this.getDefinition( item );
@@ -269,15 +272,16 @@ export default class Schema {
 	 * was set to `true`.
 	 *
 	 *		schema.isObject( 'paragraph' ); // -> false
-	 *		schema.isObject( 'image' ); // -> true
+	 *		schema.isObject( 'imageBlock' ); // -> true
 	 *
-	 *		const imageElement = writer.createElement( 'image' );
+	 *		const imageElement = writer.createElement( 'imageBlock' );
 	 *		schema.isObject( imageElement ); // -> true
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#object-elements Object elements} section of the Schema deep dive
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#object-elements Object elements} section of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+  	 * @returns {Boolean}
 	 */
 	isObject( item ) {
 		const def = this.getDefinition( item );
@@ -301,10 +305,11 @@ export default class Schema {
 	 *		const text = writer.createText( 'foo' );
 	 *		schema.isInline( text ); // -> true
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#inline-elements Inline elements} section of the Schema deep dive
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#inline-elements Inline elements} section of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+	 * @returns {Boolean}
 	 */
 	isInline( item ) {
 		const def = this.getDefinition( item );
@@ -318,16 +323,17 @@ export default class Schema {
 	 *
 	 *		schema.isSelectable( 'paragraph' ); // -> false
 	 *		schema.isSelectable( 'heading1' ); // -> false
-	 *		schema.isSelectable( 'image' ); // -> true
+	 *		schema.isSelectable( 'imageBlock' ); // -> true
 	 *		schema.isSelectable( 'tableCell' ); // -> true
 	 *
 	 *		const text = writer.createText( 'foo' );
 	 *		schema.isSelectable( text ); // -> false
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#selectable-elements Selectable elements} section of the Schema deep dive}
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#selectable-elements Selectable elements section} of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+	 * @returns {Boolean}
 	 */
 	isSelectable( item ) {
 		const def = this.getDefinition( item );
@@ -345,16 +351,17 @@ export default class Schema {
 	 *
 	 *		schema.isContent( 'paragraph' ); // -> false
 	 *		schema.isContent( 'heading1' ); // -> false
-	 *		schema.isContent( 'image' ); // -> true
+	 *		schema.isContent( 'imageBlock' ); // -> true
 	 *		schema.isContent( 'horizontalLine' ); // -> true
 	 *
 	 *		const text = writer.createText( 'foo' );
 	 *		schema.isContent( text ); // -> true
 	 *
-	 * See the {@glink framework/guides/deep-dive/schema#content-elements Content elements} section of the Schema deep dive}
-	 * guide for more details.
+	 * See the {@glink framework/guides/deep-dive/schema#content-elements Content elements section} of
+	 * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide for more details.
 	 *
 	 * @param {module:engine/model/item~Item|module:engine/model/schema~SchemaContextItem|String} item
+	 * @returns {Boolean}
 	 */
 	isContent( item ) {
 		const def = this.getDefinition( item );
@@ -384,6 +391,7 @@ export default class Schema {
 	 * @fires checkChild
 	 * @param {module:engine/model/schema~SchemaContextDefinition} context The context in which the child will be checked.
 	 * @param {module:engine/model/node~Node|String} def The child to check.
+	 * @returns {Boolean}
 	 */
 	checkChild( context, def ) {
 		// Note: context and child are already normalized here to a SchemaContext and SchemaCompiledItemDefinition.
@@ -408,6 +416,7 @@ export default class Schema {
 	 * @fires checkAttribute
 	 * @param {module:engine/model/schema~SchemaContextDefinition} context The context in which the attribute will be checked.
 	 * @param {String} attributeName
+	 * @returns {Boolean}
 	 */
 	checkAttribute( context, attributeName ) {
 		const def = this.getDefinition( context.last );
@@ -883,6 +892,10 @@ export default class Schema {
 			compiledDefinitions[ itemName ] = compileBaseItemRule( sourceRules[ itemName ], itemName );
 		}
 
+		for ( const itemName of itemNames ) {
+			compileAllowChildren( compiledDefinitions, itemName );
+		}
+
 		for ( const itemName of itemNames ) {
 			compileAllowContentOf( compiledDefinitions, itemName );
 		}
@@ -898,6 +911,7 @@ export default class Schema {
 
 		for ( const itemName of itemNames ) {
 			cleanUpAllowIn( compiledDefinitions, itemName );
+			setupAllowChildren( compiledDefinitions, itemName );
 			cleanUpAllowAttributes( compiledDefinitions, itemName );
 		}
 
@@ -1090,6 +1104,7 @@ mix( Schema, ObservableMixin );
  * You can define the following rules:
  *
  * * {@link ~SchemaItemDefinition#allowIn `allowIn`} – Defines in which other items this item will be allowed.
+ * * {@link ~SchemaItemDefinition#allowChildren `allowChildren`} – Defines which other items are allowed inside this item.
  * * {@link ~SchemaItemDefinition#allowAttributes `allowAttributes`} – Defines allowed attributes of the given item.
  * * {@link ~SchemaItemDefinition#allowContentOf `allowContentOf`} – Inherits "allowed children" from other items.
  * * {@link ~SchemaItemDefinition#allowWhere `allowWhere`} – Inherits "allowed in" from other items.
@@ -1112,7 +1127,7 @@ mix( Schema, ObservableMixin );
  * In other words, all actions that happen inside a limit element are limited to its content.
  * All objects are treated as limit elements, too.
  * * {@link ~SchemaItemDefinition#isObject `isObject`} – Whether an item is "self-contained" and should be treated as a whole.
- * Examples of object elements: `image`, `table`, `video`, etc. An object is also a limit, so
+ * Examples of object elements: `imageBlock`, `table`, `video`, etc. An object is also a limit, so
  * {@link module:engine/model/schema~Schema#isLimit `isLimit()`} returns `true` for object elements automatically.
  *
  * Read more about the meaning of these types in the
@@ -1157,21 +1172,29 @@ mix( Schema, ObservableMixin );
  *			isBlock: true
  *		} );
  *
- * Make `image` a block object, which is allowed everywhere where `$block` is.
+ * Allow `paragraph` inside a `$root` and allow `$text` as a `paragraph` child:
+ *
+ *		schema.register( 'paragraph', {
+ *			allowIn: '$root',
+ *			allowChildren: '$text',
+ *			isBlock: true
+ *		} );
+ *
+ * Make `imageBlock` a block object, which is allowed everywhere where `$block` is.
  * Also, allow `src` and `alt` attributes in it:
  *
- *		schema.register( 'image', {
+ *		schema.register( 'imageBlock', {
  *			allowWhere: '$block',
  *			allowAttributes: [ 'src', 'alt' ],
  *			isBlock: true,
  *			isObject: true
  *		} );
  *
- * Make `caption` allowed in `image` and make it allow all the content of `$block`s (usually, `$text`).
+ * Make `caption` allowed in `imageBlock` and make it allow all the content of `$block`s (usually, `$text`).
  * Also, mark it as a limit element so it cannot be split:
  *
  *		schema.register( 'caption', {
- *			allowIn: 'image',
+ *			allowIn: 'imageBlock',
  *			allowContentOf: '$block',
  *			isLimit: true
  *		} );
@@ -1205,6 +1228,7 @@ mix( Schema, ObservableMixin );
  * @typedef {Object} module:engine/model/schema~SchemaItemDefinition
  *
  * @property {String|Array.<String>} allowIn Defines in which other items this item will be allowed.
+ * @property {String|Array.<String>} allowChildren Defines which other items are allowed inside this item.
  * @property {String|Array.<String>} allowAttributes Defines allowed attributes of the given item.
  * @property {String|Array.<String>} allowContentOf Inherits "allowed children" from other items.
  * @property {String|Array.<String>} allowWhere Inherits "allowed in" from other items.
@@ -1219,14 +1243,15 @@ mix( Schema, ObservableMixin );
  * Most block type items will inherit from `$block` (through `inheritAllFrom`).
  *
  * Read more about the block elements in the
- * {@glink framework/guides/deep-dive/schema#block-elements Block elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#block-elements Block elements section} of
+ * the {@glink framework/guides/deep-dive/schema Schema deep dive}.
  *
  * @property {Boolean} isInline
  * Whether an item is "text-like" and should be treated as an inline node. Examples of inline elements:
  * `$text`, `softBreak` (`<br>`), etc.
  *
  * Read more about the inline elements in the
- * {@glink framework/guides/deep-dive/schema#inline-elements Inline elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#inline-elements Inline elements section} of the Schema deep dive guide.
  *
  * @property {Boolean} isLimit
  * It can be understood as whether this element should not be split by <kbd>Enter</kbd>.
@@ -1234,36 +1259,40 @@ mix( Schema, ObservableMixin );
  * a limit element are limited to its content.
  *
  * Read more about the limit elements in the
- * {@glink framework/guides/deep-dive/schema#limit-elements Limit elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#limit-elements Limit elements section} of
+ * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide.
  *
  * @property {Boolean} isObject
  * Whether an item is "self-contained" and should be treated as a whole. Examples of object elements:
- * `image`, `table`, `video`, etc.
+ * `imageBlock`, `table`, `video`, etc.
  *
  * **Note:** An object is also a limit, so
  * {@link module:engine/model/schema~Schema#isLimit `isLimit()`} returns `true` for object elements automatically.
  *
  * Read more about the object elements in the
- * {@glink framework/guides/deep-dive/schema#object-elements Object elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#object-elements Object elements section} of the Schema deep dive guide.
  *
  * @property {Boolean} isSelectable
- * `true` when an element should be selectable as a whole by the user. Examples of selectable elements: `image`, `table`, `tableCell`, etc.
+ * `true` when an element should be selectable as a whole by the user. Examples of selectable elements: `imageBlock`, `table`, `tableCell`,
+ * etc.
  *
  * **Note:** An object is also a selectable element, so
  * {@link module:engine/model/schema~Schema#isSelectable `isSelectable()`} returns `true` for object elements automatically.
  *
  * Read more about selectable elements in the
- * {@glink framework/guides/deep-dive/schema#selectable-elements Selectable elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#selectable-elements Selectable elements section} of
+ * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide.
  *
  * @property {Boolean} isContent
  * An item is a content when it always finds its way to the editor data output regardless of the number and type of its descendants.
- * Examples of content elements: `$text`, `image`, `table`, etc. (but not `paragraph`, `heading1` or `tableCell`).
+ * Examples of content elements: `$text`, `imageBlock`, `table`, etc. (but not `paragraph`, `heading1` or `tableCell`).
  *
  * **Note:** An object is also a content element, so
  * {@link module:engine/model/schema~Schema#isContent `isContent()`} returns `true` for object elements automatically.
  *
  * Read more about content elements in the
- * {@glink framework/guides/deep-dive/schema#content-elements Content elements} section of the Schema deep dive} guide.
+ * {@glink framework/guides/deep-dive/schema#content-elements Content elements section} of
+ * the {@glink framework/guides/deep-dive/schema Schema deep dive} guide.
  */
 
 /**
@@ -1280,6 +1309,7 @@ mix( Schema, ObservableMixin );
  * * The `name` property,
  * * The `is*` properties,
  * * The `allowIn` array,
+ * * The `allowChildren` array,
  * * The `allowAttributes` array.
  *
  * @typedef {Object} module:engine/model/schema~SchemaCompiledItemDefinition
@@ -1562,6 +1592,8 @@ function compileBaseItemRule( sourceItemRules, itemName ) {
 		allowAttributes: [],
 		allowAttributesOf: [],
 
+		allowChildren: [],
+
 		inheritTypesFrom: []
 	};
 
@@ -1574,6 +1606,8 @@ function compileBaseItemRule( sourceItemRules, itemName ) {
 	copyProperty( sourceItemRules, itemRule, 'allowAttributes' );
 	copyProperty( sourceItemRules, itemRule, 'allowAttributesOf' );
 
+	copyProperty( sourceItemRules, itemRule, 'allowChildren' );
+
 	copyProperty( sourceItemRules, itemRule, 'inheritTypesFrom' );
 
 	makeInheritAllWork( sourceItemRules, itemRule );
@@ -1581,6 +1615,25 @@ function compileBaseItemRule( sourceItemRules, itemName ) {
 	return itemRule;
 }
 
+function compileAllowChildren( compiledDefinitions, itemName ) {
+	const item = compiledDefinitions[ itemName ];
+
+	for ( const allowChildrenItem of item.allowChildren ) {
+		const allowedChildren = compiledDefinitions[ allowChildrenItem ];
+
+		// The allowChildren property may point to an unregistered element.
+		if ( !allowedChildren ) {
+			continue;
+		}
+
+		allowedChildren.allowIn.push( itemName );
+	}
+
+	// The allowIn property already includes correct items, reset the allowChildren property
+	// to avoid duplicates later when setting up compilation results.
+	item.allowChildren.length = 0;
+}
+
 function compileAllowContentOf( compiledDefinitions, itemName ) {
 	for ( const allowContentOfItemName of compiledDefinitions[ itemName ].allowContentOf ) {
 		// The allowContentOf property may point to an unregistered element.
@@ -1654,6 +1707,17 @@ function cleanUpAllowIn( compiledDefinitions, itemName ) {
 	itemRule.allowIn = Array.from( new Set( existingItems ) );
 }
 
+// Setup allowChildren items based on allowIn.
+function setupAllowChildren( compiledDefinitions, itemName ) {
+	const itemRule = compiledDefinitions[ itemName ];
+
+	for ( const allowedParentItemName of itemRule.allowIn ) {
+		const allowedParentItem = compiledDefinitions[ allowedParentItemName ];
+
+		allowedParentItem.allowChildren.push( itemName );
+	}
+}
+
 function cleanUpAllowAttributes( compiledDefinitions, itemName ) {
 	const itemRule = compiledDefinitions[ itemName ];
 

package/src/model/selection.js

@@ -71,7 +71,7 @@ export default class Selection {
 	 *		// Creates backward selection.
 	 *		const selection = writer.createSelection( range, { backward: true } );
 	 *
-	 * @param {module:engine/model/selection~Selectable} selectable
+	 * @param {module:engine/model/selection~Selectable} [selectable]
 	 * @param {Number|'before'|'end'|'after'|'on'|'in'} [placeOrOffset] Sets place or offset of the selection.
 	 * @param {Object} [options]
 	 * @param {Boolean} [options.backward] Sets this selection instance to be backward.

package/src/model/treewalker.js

@@ -382,10 +382,9 @@ function formatReturnValue( type, item, previousPosition, nextPosition, length )
 /**
  * Type of the step made by {@link module:engine/model/treewalker~TreeWalker}.
  * Possible values: `'elementStart'` if walker is at the beginning of a node, `'elementEnd'` if walker is at the end of node,
- * `'character'` if walker traversed over a character, or `'text'` if walker traversed over multiple characters (available in
- * character merging mode, see {@link module:engine/model/treewalker~TreeWalker#constructor}).
+ * or `'text'` if walker traversed over text.
  *
- * @typedef {'elementStart'|'elementEnd'|'character'|'text'} module:engine/model/treewalker~TreeWalkerValueType
+ * @typedef {'elementStart'|'elementEnd'|'text'} module:engine/model/treewalker~TreeWalkerValueType
  */
 
 /**
@@ -404,7 +403,7 @@ function formatReturnValue( type, item, previousPosition, nextPosition, length )
  * the position after the item.
  * * Backward iteration: For `'elementEnd'` it is last position inside element. For all other types it is the position
  * before the item.
- * @property {Number} [length] Length of the item. For `'elementStart'` and `'character'` it is 1. For `'text'` it is
+ * @property {Number} [length] Length of the item. For `'elementStart'` it is 1. For `'text'` it is
  * the length of the text. For `'elementEnd'` it is `undefined`.
  */
 

package/src/model/utils/deletecontent.js

@@ -45,7 +45,7 @@ import DocumentSelection from '../documentselection';
  * @param {Boolean} [options.doNotAutoparagraph=false] Whether to create a paragraph if after content deletion selection is moved
  * to a place where text cannot be inserted.
  *
- * For example `<paragraph>x</paragraph>[<image src="foo.jpg"></image>]` will become:
+ * For example `<paragraph>x</paragraph>[<imageBlock src="foo.jpg"></imageBlock>]` will become:
  *
  * * `<paragraph>x</paragraph><paragraph>[]</paragraph>` with the option disabled (`doNotAutoparagraph == false`)
  * * `<paragraph>x</paragraph>[]` with the option enabled (`doNotAutoparagraph == true`).
@@ -53,9 +53,9 @@ import DocumentSelection from '../documentselection';
  * If you use this option you need to make sure to handle invalid selections yourself or leave
  * them to the selection post-fixer (may not always work).
  *
- * **Note:** if there is no valid position for the selection, the paragraph will always be created:
+ * **Note:** If there is no valid position for the selection, the paragraph will always be created:
  *
- * `[<image src="foo.jpg"></image>]` -> `<paragraph>[]</paragraph>`.
+ * `[<imageBlock src="foo.jpg"></imageBlock>]` -> `<paragraph>[]</paragraph>`.
  */
 export default function deleteContent( model, selection, options = {} ) {
 	if ( selection.isCollapsed ) {
@@ -148,7 +148,20 @@ function getLivePositionsForSelectedBlocks( range ) {
 			// This is how modifySelection works and here we are making use of it.
 			model.modifySelection( selection, { direction: 'backward' } );
 
-			endPosition = selection.getLastPosition();
+			const newEndPosition = selection.getLastPosition();
+
+			// For such a model and selection:
+			//     <paragraph>A[</paragraph><imageBlock></imageBlock><paragraph>]B</paragraph>
+			//
+			// After modifySelection(), we would end up with this:
+			//     <paragraph>A[</paragraph>]<imageBlock></imageBlock><paragraph>B</paragraph>
+			//
+			// So we need to check if there is no content in the skipped range (because we want to include the <imageBlock>).
+			const skippedRange = model.createRange( newEndPosition, endPosition );
+
+			if ( !model.hasContent( skippedRange, { ignoreMarkers: true } ) ) {
+				endPosition = newEndPosition;
+			}
 		}
 	}
 

package/src/model/utils/insertcontent.js

@@ -698,7 +698,7 @@ class Insertion {
 		// 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( paragraph, this.position.parent ) && this.schema.checkChild( paragraph, node ) ) {
+		if ( this._getAllowedIn( this.position.parent, paragraph ) && this.schema.checkChild( paragraph, node ) ) {
 			paragraph._appendChild( node );
 			this._handleNode( paragraph );
 		}
@@ -747,7 +747,7 @@ class Insertion {
 	 * `false` is returned if the node isn't allowed at any position up in the tree, `true` if was.
 	 */
 	_checkAndSplitToAllowedPosition( node ) {
-		const allowedIn = this._getAllowedIn( node, this.position.parent );
+		const allowedIn = this._getAllowedIn( this.position.parent, node );
 
 		if ( !allowedIn ) {
 			return false;
@@ -759,11 +759,6 @@ class Insertion {
 		}
 
 		while ( allowedIn != this.position.parent ) {
-			// If a parent which we'd need to leave is a limit element, break.
-			if ( this.schema.isLimit( this.position.parent ) ) {
-				return false;
-			}
-
 			if ( this.position.isAtStart ) {
 				// If insertion position is at the beginning of the parent, move it out instead of splitting.
 				// <p>^Foo</p> -> ^<p>Foo</p>
@@ -806,19 +801,24 @@ class Insertion {
 	 * Gets the element in which the given node is allowed. It checks the passed element and all its ancestors.
 	 *
 	 * @private
-	 * @param {module:engine/model/node~Node} node The node to check.
-	 * @param {module:engine/model/element~Element} element The element in which the node's correctness should be checked.
+	 * @param {module:engine/model/element~Element} contextElement The element in which context the node should be checked.
+	 * @param {module:engine/model/node~Node} childNode The node to check.
 	 * @returns {module:engine/model/element~Element|null}
 	 */
-	_getAllowedIn( node, element ) {
-		if ( this.schema.checkChild( element, node ) ) {
-			return element;
+	_getAllowedIn( contextElement, childNode ) {
+		if ( this.schema.checkChild( contextElement, childNode ) ) {
+			return contextElement;
 		}
 
-		if ( element.parent ) {
-			return this._getAllowedIn( node, element.parent );
+		// 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
+		// an illusion of the child being allowed. There's no way to insert it down there, though. It results in
+		// infinite loops.
+		if ( this.schema.isLimit( contextElement ) ) {
+			return null;
 		}
 
-		return null;
+		return this._getAllowedIn( contextElement.parent, childNode );
 	}
 }

package/src/model/utils/selection-post-fixer.js

@@ -24,7 +24,7 @@ import Position from '../position';
  * boundary (a range must be rooted within one limit element).
  * * Only {@link module:engine/model/schema~Schema#isSelectable selectable elements} can be selected from the outside
  * (e.g. `[<paragraph>foo</paragraph>]` is invalid). This rule applies independently to both selection ends, so this
- * selection is correct: `<paragraph>f[oo</paragraph><image></image>]`.
+ * selection is correct: `<paragraph>f[oo</paragraph><imageBlock></imageBlock>]`.
  *
  * If the position is not correct, the post-fixer will automatically correct it.
  *

package/src/view/documentselection.js

@@ -98,7 +98,7 @@ export default class DocumentSelection {
 	 * Returns true if selection instance is marked as `fake`.
 	 *
 	 * @see #_setTo
-	 * @returns {Boolean}
+	 * @type {Boolean}
 	 */
 	get isFake() {
 		return this._selection.isFake;
@@ -108,7 +108,7 @@ export default class DocumentSelection {
 	 * Returns fake selection label.
 	 *
 	 * @see #_setTo
-	 * @returns {String}
+	 * @type {String}
 	 */
 	get fakeSelectionLabel() {
 		return this._selection.fakeSelectionLabel;