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

package/dist/model/schema.d.ts

@@ -41,6 +41,24 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * A dictionary containing attribute properties.
      */
     private readonly _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.
+     */
+    private readonly _customChildChecks;
+    /**
+     * 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.
+     */
+    private readonly _customAttributeChecks;
+    private readonly _genericCheckSymbol;
     private _compiledDefinitions?;
     /**
      * Creates a schema instance.
@@ -217,7 +235,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      */
     isContent(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
     /**
-     * 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
@@ -225,13 +243,20 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * 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 – 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 – 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.
@@ -239,8 +264,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      */
     checkChild(context: SchemaContextDefinition, def: string | Node | DocumentFragment): boolean;
     /**
-     * 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
@@ -248,116 +272,152 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * 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: SchemaContextDefinition, attributeName: string): boolean;
-    /**
-     * Checks whether the given element (`elementToMerge`) can be merged with the specified base element (`positionOrBaseElement`).
-     *
-     * In other words – 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.
-     *
-     * Instead of elements, you can pass the instance of the {@link module:engine/model/position~Position} class as the
-     * `positionOrBaseElement`. It means that the elements before and after the position will be checked whether they can be merged.
-     *
-     * @param positionOrBaseElement The position or base element to which the `elementToMerge` will be merged.
-     * @param elementToMerge The element to merge. Required if `positionOrBaseElement` is an element.
-     */
-    checkMerge(positionOrBaseElement: Position | Element, elementToMerge: Element): boolean;
+    checkMerge(position: Position): boolean;
+    checkMerge(baseElement: Element, elementToMerge: Element): boolean;
     /**
      * Allows registering a callback to the {@link #checkChild} 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 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.
+     * {@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: SchemaChildCheckCallback): void;
+    addChildCheck(callback: SchemaChildCheckCallback, itemName?: string): void;
     /**
      * 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.
+     *
+     * For example, by using this method you can disallow setting attributes on nodes in specific contexts:
+     *
+     * ```ts
+     * // Disallow setting `bold` on text inside `heading1` element:
+     * schema.addAttributeCheck( context => {
+     * 	if ( context.endsWith( 'heading1 $text' ) ) {
+     * 		return false;
+     * 	}
+     * }, 'bold' );
+     * ```
      *
-     * Example:
+     * You can skip the optional `attributeName` parameter to evaluate the callback for every `checkAttribute()` call.
      *
      * ```ts
-     * // Disallow bold on $text inside heading1.
+     * // 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.
+     * {@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: SchemaAttributeCheckCallback): void;
+    addAttributeCheck(callback: SchemaAttributeCheckCallback, attributeName?: string): void;
     /**
      * This method allows assigning additional metadata to the model attributes. For example,
      * {@link module:engine/model/schema~AttributeProperties `AttributeProperties#isFormatting` property} is
@@ -500,6 +560,22 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
     private _clearCache;
     private _compile;
     private _checkContextMatch;
+    /**
+     * 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.
+     */
+    private _evaluateChildChecks;
+    /**
+     * 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.
+     */
+    private _evaluateAttributeChecks;
     /**
      * Takes a flat range and an attribute name. Traverses the range recursively and deeply to find and return all ranges
      * inside the given range on which the attribute can be applied.
@@ -879,22 +955,32 @@ export interface SchemaItemDefinition {
     disallowAttributes?: string | Array<string>;
     /**
      * Inherits "allowed children" from other items.
+     *
+     * Note that the item's "own" rules take precedence over "inherited" rules and can overwrite them.
      */
     allowContentOf?: string | Array<string>;
     /**
      * Inherits "allowed in" from other items.
+     *
+     * Note that the item's "own" rules take precedence over "inherited" rules and can overwrite them.
      */
     allowWhere?: string | Array<string>;
     /**
      * Inherits "allowed attributes" from other items.
+     *
+     * Note that the item's "own" rules take precedence over "inherited" rules and can overwrite them.
      */
     allowAttributesOf?: string | Array<string>;
     /**
      * Inherits `is*` properties of other items.
+     *
+     * Note that the item's "own" rules take precedence over "inherited" rules and can overwrite them.
      */
     inheritTypesFrom?: string | Array<string>;
     /**
      * A shorthand for `allowContentOf`, `allowWhere`, `allowAttributesOf`, `inheritTypesFrom`.
+     *
+     * Note that the item's "own" rules take precedence over "inherited" rules and can overwrite them.
      */
     inheritAllFrom?: string;
     /**
@@ -1064,6 +1150,18 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
      * @returns A new schema context instance with an additional item.
      */
     push(item: string | Node): SchemaContext;
+    /**
+     * 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(): SchemaContext;
     /**
      * Gets an item on the given index.
      */
@@ -1113,7 +1211,7 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
  * * By defining an **array of node names** (potentially, mixed with real nodes) – The same as **name of node**
  * but it is possible to create a path.
  * * By defining a {@link module:engine/model/schema~SchemaContext} instance - in this case the same instance as provided
- * will be return.
+ * will be returned.
  *
  * Examples of context definitions passed to the {@link module:engine/model/schema~Schema#checkChild `Schema#checkChild()`}
  * method:

package/dist/view/observer/focusobserver.d.ts

@@ -51,6 +51,18 @@ export default class FocusObserver extends DomEventObserver<'focus' | 'blur'> {
      * @inheritDoc
      */
     destroy(): void;
+    /**
+     * The `focus` event handler.
+     */
+    private _handleFocus;
+    /**
+     * The `blur` event handler.
+     */
+    private _handleBlur;
+    /**
+     * Clears timeout.
+     */
+    private _clearTimeout;
 }
 /**
  * Fired when one of the editables gets focus.

package/dist/view/observer/mutationobserver.d.ts

@@ -11,8 +11,9 @@
  */
 import Observer from './observer.js';
 import type DomConverter from '../domconverter.js';
-import type Renderer from '../renderer.js';
 import type View from '../view.js';
+import type ViewNode from '../node.js';
+import type { ChangeType } from '../document.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.
@@ -29,10 +30,6 @@ export default class MutationObserver extends Observer {
      * Reference to the {@link module:engine/view/view~View#domConverter}.
      */
     readonly domConverter: DomConverter;
-    /**
-     * Reference to the {@link module:engine/view/view~View#_renderer}.
-     */
-    readonly renderer: Renderer;
     /**
      * Native mutation observer config.
      */
@@ -88,3 +85,35 @@ export default class MutationObserver extends Observer {
      */
     private _isBogusBrMutation;
 }
+/**
+ * Event fired on DOM mutations detected.
+ *
+ * This event is introduced by {@link module:engine/view/observer/mutationobserver~MutationObserver} and available
+ * by default in all editor instances (attached by {@link module:engine/view/view~View}).
+ *
+ * @eventName module:engine/view/document~Document#mutations
+ * @param data Event data containing detailed information about the event.
+ */
+export type ViewDocumentMutationsEvent = {
+    name: 'mutations';
+    args: [data: MutationsEventData];
+};
+/**
+ * The value of {@link ~ViewDocumentMutationsEvent}.
+ */
+export type MutationsEventData = {
+    mutations: Array<MutationData>;
+};
+/**
+ * A single entry in {@link ~MutationsEventData} mutations array.
+ */
+export type MutationData = {
+    /**
+     * Type of mutation detected.
+     */
+    type: ChangeType;
+    /**
+     * The view node related to the detected mutation.
+     */
+    node: ViewNode;
+};

package/dist/view/observer/selectionobserver.d.ts

@@ -11,11 +11,11 @@
  */
 import Observer from './observer.js';
 import MutationObserver from './mutationobserver.js';
+import FocusObserver from './focusobserver.js';
 import type View from '../view.js';
 import type DocumentSelection from '../documentselection.js';
 import type DomConverter from '../domconverter.js';
 import type Selection from '../selection.js';
-import FocusObserver from './focusobserver.js';
 type DomSelection = globalThis.Selection;
 /**
  * Selection observer class observes selection changes in the document. If a selection changes on the document this
@@ -92,7 +92,6 @@ export default class SelectionObserver extends Observer {
      * 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.
      */
     private _handleSelectionChange;

package/dist/view/renderer.d.ts

@@ -217,6 +217,18 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
      * @returns Actions array modified with the `update` actions.
      */
     private _findUpdateActions;
+    /**
+     * 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.
+     */
+    private _updateTextNode;
+    /**
+     * Part of the `_updateTextNode` method extracted for easier testing.
+     */
+    private _updateTextNodeInternal;
     /**
      * Marks text nodes to be synchronized.
      *

package/dist/view/view.d.ts

@@ -11,7 +11,6 @@
  */
 import Document from './document.js';
 import DowncastWriter from './downcastwriter.js';
-import Renderer from './renderer.js';
 import DomConverter from './domconverter.js';
 import Position, { type PositionOffset } from './position.js';
 import Range from './range.js';
@@ -99,10 +98,8 @@ export default class View extends /* #__PURE__ */ View_base {
     hasDomSelection: boolean;
     /**
      * Instance of the {@link module:engine/view/renderer~Renderer renderer}.
-     *
-     * @internal
      */
-    readonly _renderer: Renderer;
+    private readonly _renderer;
     /**
      * A DOM root attributes cache. It saves the initial values of DOM root attributes before the DOM element
      * is {@link module:engine/view/view~View#attachDomRoot attached} to the view so later on, when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-engine",
-  "version": "42.0.2-alpha.2",
+  "version": "43.0.0-alpha.0",
   "description": "The editing engine of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -24,7 +24,7 @@
   "type": "module",
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-utils": "42.0.2-alpha.2",
+    "@ckeditor/ckeditor5-utils": "43.0.0-alpha.0",
     "lodash-es": "4.17.21"
   },
   "author": "CKSource (http://cksource.com/)",

package/src/conversion/upcasthelpers.js

@@ -466,14 +466,7 @@ export function convertText() {
             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);

package/src/dev-utils/model.d.ts

@@ -75,6 +75,7 @@ export declare function setData(model: Model, data: string, options?: {
     selectionAttributes?: Record<string, unknown>;
     lastRangeBackward?: boolean;
     batchType?: BatchType;
+    inlineObjectElements?: Array<string>;
 }): void;
 export declare namespace setData {
     var _parse: typeof parse;
@@ -118,6 +119,7 @@ export declare function parse(data: string, schema: Schema, options?: {
     selectionAttributes?: Record<string, unknown> | Iterable<[string, unknown]>;
     lastRangeBackward?: boolean;
     context?: SchemaContextDefinition;
+    inlineObjectElements?: Array<string>;
 }): ModelNode | ModelDocumentFragment | {
     model: ModelNode | ModelDocumentFragment;
     selection: ModelSelection;

package/src/dev-utils/model.js

@@ -97,7 +97,8 @@ export function setData(model, data, options = {}) {
     const parsedResult = setData._parse(data, model.schema, {
         lastRangeBackward: options.lastRangeBackward,
         selectionAttributes: options.selectionAttributes,
-        context: [modelRoot.name]
+        context: [modelRoot.name],
+        inlineObjectElements: options.inlineObjectElements
     });
     // Retrieve DocumentFragment and Selection from parsed model.
     if ('model' in parsedResult) {
@@ -266,7 +267,8 @@ export function parse(data, schema, options = {}) {
     // Parse data to view using view utils.
     const parsedResult = viewParse(data, {
         sameSelectionCharacters: true,
-        lastRangeBackward: !!options.lastRangeBackward
+        lastRangeBackward: !!options.lastRangeBackward,
+        inlineObjectElements: options.inlineObjectElements
     });
     // Retrieve DocumentFragment and Selection from parsed view.
     let viewDocumentFragment;

package/src/dev-utils/utils.js

@@ -10,6 +10,7 @@
  * @module engine/dev-utils/utils
  */
 /* globals console */
+// @if CK_DEBUG_TYPING // const { debounce } = require( 'lodash-es' );
 /**
  * Helper function, converts a map to the 'key1="value1" key2="value1"' format.
  *
@@ -71,3 +72,9 @@ export function logDocument(document, version) {
         console.log('Tree log unavailable for given version: ' + version);
     }
 }
+// @if CK_DEBUG_TYPING // export const _debouncedLine = debounce( () => {
+// @if CK_DEBUG_TYPING // 	console.log(
+// @if CK_DEBUG_TYPING // 		'%c───────────────────────────────────────────────────────────────────────────────────────────────────────',
+// @if CK_DEBUG_TYPING // 		'font-weight: bold; color: red'
+// @if CK_DEBUG_TYPING // 	);
+// @if CK_DEBUG_TYPING // }, 300 );

package/src/dev-utils/view.d.ts

@@ -313,6 +313,7 @@ export declare function parse(data: string, options?: {
     lastRangeBackward?: boolean;
     rootElement?: ViewElement | ViewDocumentFragment;
     sameSelectionCharacters?: boolean;
+    inlineObjectElements?: Array<string>;
 }): ViewNode | ViewDocumentFragment | {
     view: ViewNode | ViewDocumentFragment;
     selection: DocumentSelection;

package/src/dev-utils/view.js

@@ -364,6 +364,9 @@ export function parse(data, options = {}) {
     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

package/src/index.d.ts

@@ -50,10 +50,11 @@ export type { default as Differ, DiffItem, DiffItemAttribute, DiffItemInsert, Di
 export type { default as Item } from './model/item.js';
 export type { default as Node, NodeAttributes } from './model/node.js';
 export type { default as RootElement } from './model/rootelement.js';
-export type { default as Schema, SchemaAttributeCheckCallback, SchemaChildCheckCallback, AttributeProperties, SchemaItemDefinition } from './model/schema.js';
+export type { default as Schema, SchemaAttributeCheckCallback, SchemaChildCheckCallback, AttributeProperties, SchemaItemDefinition, SchemaContext } from './model/schema.js';
 export type { default as Selection, Selectable } from './model/selection.js';
 export type { default as TypeCheckable } from './model/typecheckable.js';
 export type { default as Writer } from './model/writer.js';
+export * from './model/utils/autoparagraphing.js';
 export type { DocumentChangeEvent } from './model/document.js';
 export type { DocumentSelectionChangeEvent } from './model/documentselection.js';
 export type { ModelApplyOperationEvent, ModelDeleteContentEvent, ModelGetSelectedContentEvent, ModelInsertContentEvent, ModelInsertObjectEvent, ModelModifySelectionEvent, ModelCanEditAtEvent } from './model/model.js';
@@ -99,6 +100,7 @@ export type { BubblingEvent } from './view/observer/bubblingemittermixin.js';
 export type { ViewDocumentArrowKeyEvent } from './view/observer/arrowkeysobserver.js';
 export type { ViewDocumentCompositionStartEvent, ViewDocumentCompositionUpdateEvent, ViewDocumentCompositionEndEvent } from './view/observer/compositionobserver.js';
 export type { ViewDocumentInputEvent } from './view/observer/inputobserver.js';
+export type { ViewDocumentMutationsEvent, MutationData } from './view/observer/mutationobserver.js';
 export type { ViewDocumentKeyDownEvent, ViewDocumentKeyUpEvent, KeyEventData } from './view/observer/keyobserver.js';
 export type { ViewDocumentLayoutChangedEvent } from './view/document.js';
 export type { ViewDocumentMouseDownEvent, ViewDocumentMouseUpEvent, ViewDocumentMouseOverEvent, ViewDocumentMouseOutEvent } from './view/observer/mouseobserver.js';

package/src/index.js

@@ -38,6 +38,8 @@ export { default as DocumentFragment } from './model/documentfragment.js';
 export { default as History } from './model/history.js';
 export { default as Text } from './model/text.js';
 export { default as TextProxy } from './model/textproxy.js';
+// Model utils.
+export * from './model/utils/autoparagraphing.js';
 // View.
 export { default as DataTransfer } from './view/datatransfer.js';
 export { default as DomConverter } from './view/domconverter.js';

package/src/model/model.js

@@ -90,11 +90,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
         // 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);