@ckeditor/ckeditor5-engine 47.6.1 → 48.0.0-alpha.0

package/src/model/text.js

@@ -1,92 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/model/text
- */
-import { ModelNode } from './node.js';
-// @if CK_DEBUG_ENGINE // const { convertMapToStringifiedObject } = require( '../dev-utils/utils' );
-/**
- * Model text node. Type of {@link module:engine/model/node~ModelNode node} that
- * contains {@link module:engine/model/text~ModelText#data text data}.
- *
- * **Important:** see {@link module:engine/model/node~ModelNode} to read about restrictions using `Text` and `Node` API.
- *
- * **Note:** keep in mind that `Text` instances might indirectly got removed from model tree when model is changed.
- * This happens when {@link module:engine/model/writer~ModelWriter model writer} is used to change model and the text node is merged with
- * another text node. Then, both text nodes are removed and a new text node is inserted into the model. Because of
- * this behavior, keeping references to `Text` is not recommended. Instead, consider creating
- * {@link module:engine/model/liveposition~ModelLivePosition live position} placed before the text node.
- */
-export class ModelText extends ModelNode {
-    /**
-     * Text data contained in this text node.
-     *
-     * @internal
-     */
-    _data;
-    /**
-     * Creates a text node.
-     *
-     * **Note:** Constructor of this class shouldn't be used directly in the code.
-     * Use the {@link module:engine/model/writer~ModelWriter#createText} method instead.
-     *
-     * @internal
-     * @param data Node's text.
-     * @param attrs Node's attributes. See {@link module:utils/tomap~toMap} for a list of accepted values.
-     */
-    constructor(data, attrs) {
-        super(attrs);
-        this._data = data || '';
-    }
-    /**
-     * @inheritDoc
-     */
-    get offsetSize() {
-        return this.data.length;
-    }
-    /**
-     * Returns a text data contained in the node.
-     */
-    get data() {
-        return this._data;
-    }
-    /**
-     * Converts `Text` instance to plain object and returns it.
-     *
-     * @returns`Text` instance converted to plain object.
-     */
-    toJSON() {
-        const json = super.toJSON();
-        json.data = this.data;
-        return json;
-    }
-    /**
-     * Creates a copy of this text node and returns it. Created text node has same text data and attributes as original text node.
-     *
-     * @internal
-     * @returns `Text` instance created using given plain object.
-     */
-    _clone() {
-        return new ModelText(this.data, this.getAttributes());
-    }
-    /**
-     * Creates a `Text` instance from given plain object (i.e. parsed JSON string).
-     *
-     * @param json Plain object to be converted to `Text`.
-     * @returns `Text` instance created using given plain object.
-     */
-    static fromJSON(json) {
-        return new ModelText(json.data, json.attributes);
-    }
-}
-// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
-// Proper overload would interfere with that.
-ModelText.prototype.is = function (type) {
-    return type === '$text' || type === 'model:$text' ||
-        // This are legacy values kept for backward compatibility.
-        type === 'text' || type === 'model:text' ||
-        // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
-        type === 'node' || type === 'model:node';
-};

package/src/model/textproxy.js

@@ -1,202 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/model/textproxy
- */
-import { ModelTypeCheckable } from './typecheckable.js';
-import { CKEditorError } from '@ckeditor/ckeditor5-utils';
-// @if CK_DEBUG_ENGINE // const { convertMapToStringifiedObject } = require( '../dev-utils/utils' );
-/**
- * `ModelTextProxy` represents a part of {@link module:engine/model/text~ModelText text node}.
- *
- * Since {@link module:engine/model/position~ModelPosition positions} can be placed between characters of a text node,
- * {@link module:engine/model/range~ModelRange ranges} may contain only parts of text nodes.
- * When {@link module:engine/model/range~ModelRange#getItems getting items}
- * contained in such range, we need to represent a part of that text node, since returning the whole text node would be incorrect.
- * `ModelTextProxy` solves this issue.
- *
- * `ModelTextProxy` has an API similar to {@link module:engine/model/text~ModelText Text} and allows to do
- * most of the common tasks performed on model nodes.
- *
- * **Note:** Some `ModelTextProxy` instances may represent whole text node, not just a part of it.
- * See {@link module:engine/model/textproxy~ModelTextProxy#isPartial}.
- *
- * **Note:** `ModelTextProxy` is not an instance of {@link module:engine/model/node~ModelNode node}. Keep this in mind when using it as a
- * parameter of methods.
- *
- * **Note:** `ModelTextProxy` is a readonly interface. If you want to perform changes on model data represented by a `ModelTextProxy`
- * use {@link module:engine/model/writer~ModelWriter model writer API}.
- *
- * **Note:** `ModelTextProxy` instances are created on the fly, basing on the current state of model. Because of this, it is
- * highly unrecommended to store references to `ModelTextProxy` instances. `ModelTextProxy` instances are not refreshed when
- * model changes, so they might get invalidated. Instead, consider creating {@link module:engine/model/liveposition~ModelLivePosition live
- * position}.
- *
- * `ModelTextProxy` instances are created by {@link module:engine/model/treewalker~ModelTreeWalker model tree walker}.
- * You should not need to create an instance of this class by your own.
- */
-export class ModelTextProxy extends ModelTypeCheckable {
-    /**
-     * Text node which part is represented by this text proxy.
-     */
-    textNode;
-    /**
-     * Text data represented by this text proxy.
-     */
-    data;
-    /**
-     * Offset in {@link module:engine/model/textproxy~ModelTextProxy#textNode text node} from which the text proxy starts.
-     */
-    offsetInText;
-    /**
-     * Creates a text proxy.
-     *
-     * @internal
-     * @param textNode Text node which part is represented by this text proxy.
-     * @param offsetInText Offset in {@link module:engine/model/textproxy~ModelTextProxy#textNode text node} from which the text proxy
-     * starts.
-     * @param length Text proxy length, that is how many text node's characters, starting from `offsetInText` it represents.
-     */
-    constructor(textNode, offsetInText, length) {
-        super();
-        this.textNode = textNode;
-        if (offsetInText < 0 || offsetInText > textNode.offsetSize) {
-            /**
-             * Given `offsetInText` value is incorrect.
-             *
-             * @error model-textproxy-wrong-offsetintext
-             */
-            throw new CKEditorError('model-textproxy-wrong-offsetintext', this);
-        }
-        if (length < 0 || offsetInText + length > textNode.offsetSize) {
-            /**
-             * Given `length` value is incorrect.
-             *
-             * @error model-textproxy-wrong-length
-             */
-            throw new CKEditorError('model-textproxy-wrong-length', this);
-        }
-        this.data = textNode.data.substring(offsetInText, offsetInText + length);
-        this.offsetInText = offsetInText;
-    }
-    /**
-     * Offset at which this text proxy starts in it's parent.
-     *
-     * @see module:engine/model/node~ModelNode#startOffset
-     */
-    get startOffset() {
-        return this.textNode.startOffset !== null ? this.textNode.startOffset + this.offsetInText : null;
-    }
-    /**
-     * Offset size of this text proxy. Equal to the number of characters represented by the text proxy.
-     *
-     * @see module:engine/model/node~ModelNode#offsetSize
-     */
-    get offsetSize() {
-        return this.data.length;
-    }
-    /**
-     * Offset at which this text proxy ends in it's parent.
-     *
-     * @see module:engine/model/node~ModelNode#endOffset
-     */
-    get endOffset() {
-        return this.startOffset !== null ? this.startOffset + this.offsetSize : null;
-    }
-    /**
-     * Flag indicating whether `ModelTextProxy` instance covers only part of the original
-     * {@link module:engine/model/text~ModelText text node} (`true`) or the whole text node (`false`).
-     *
-     * This is `false` when text proxy starts at the very beginning of
-     * {@link module:engine/model/textproxy~ModelTextProxy#textNode textNode}
-     * ({@link module:engine/model/textproxy~ModelTextProxy#offsetInText offsetInText} equals `0`) and text proxy sizes is equal to
-     * text node size.
-     */
-    get isPartial() {
-        return this.offsetSize !== this.textNode.offsetSize;
-    }
-    /**
-     * Parent of this text proxy, which is same as parent of text node represented by this text proxy.
-     */
-    get parent() {
-        return this.textNode.parent;
-    }
-    /**
-     * Root of this text proxy, which is same as root of text node represented by this text proxy.
-     */
-    get root() {
-        return this.textNode.root;
-    }
-    /**
-     * Gets path to this text proxy.
-     *
-     * @see module:engine/model/node~ModelNode#getPath
-     */
-    getPath() {
-        const path = this.textNode.getPath();
-        if (path.length > 0) {
-            path[path.length - 1] += this.offsetInText;
-        }
-        return path;
-    }
-    /**
-     * Returns ancestors array of this text proxy.
-     *
-     * @param options Options object.
-     * @param options.includeSelf When set to `true` this text proxy will be also included in parent's array.
-     * @param options.parentFirst When set to `true`, array will be sorted from text proxy parent to root element,
-     * otherwise root element will be the first item in the array.
-     * @returns Array with ancestors.
-     */
-    getAncestors(options = {}) {
-        const ancestors = [];
-        let parent = options.includeSelf ? this : this.parent;
-        while (parent) {
-            ancestors[options.parentFirst ? 'push' : 'unshift'](parent);
-            parent = parent.parent;
-        }
-        return ancestors;
-    }
-    /**
-     * Checks if this text proxy has an attribute for given key.
-     *
-     * @param key Key of attribute to check.
-     * @returns `true` if attribute with given key is set on text proxy, `false` otherwise.
-     */
-    hasAttribute(key) {
-        return this.textNode.hasAttribute(key);
-    }
-    /**
-     * Gets an attribute value for given key or `undefined` if that attribute is not set on text proxy.
-     *
-     * @param key Key of attribute to look for.
-     * @returns Attribute value or `undefined`.
-     */
-    getAttribute(key) {
-        return this.textNode.getAttribute(key);
-    }
-    /**
-     * Returns iterator that iterates over this node's attributes. Attributes are returned as arrays containing two
-     * items. First one is attribute key and second is attribute value.
-     *
-     * This format is accepted by native `Map` object and also can be passed in `Node` constructor.
-     */
-    getAttributes() {
-        return this.textNode.getAttributes();
-    }
-    /**
-     * Returns iterator that iterates over this node's attribute keys.
-     */
-    getAttributeKeys() {
-        return this.textNode.getAttributeKeys();
-    }
-}
-// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
-// Proper overload would interfere with that.
-ModelTextProxy.prototype.is = function (type) {
-    return type === '$textProxy' || type === 'model:$textProxy' ||
-        // This are legacy values kept for backward compatibility.
-        type === 'textProxy' || type === 'model:textProxy';
-};

package/src/model/treewalker.js

@@ -1,313 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { ModelPosition, getTextNodeAtPosition, getNodeAfterPosition, getNodeBeforePosition } from './position.js';
-import { ModelTextProxy } from './textproxy.js';
-import { CKEditorError } from '@ckeditor/ckeditor5-utils';
-/**
- * Position iterator class. It allows to iterate forward and backward over the document.
- */
-export class ModelTreeWalker {
-    /**
-     * Walking direction. Defaults `'forward'`.
-     */
-    direction;
-    /**
-     * Iterator boundaries.
-     *
-     * When the iterator is walking `'forward'` on the end of boundary or is walking `'backward'`
-     * on the start of boundary, then `{ done: true }` is returned.
-     *
-     * If boundaries are not defined they are set before first and after last child of the root node.
-     */
-    boundaries;
-    /**
-     * Flag indicating whether all consecutive characters with the same attributes should be
-     * returned as one {@link module:engine/model/textproxy~ModelTextProxy} (`true`) or one by one (`false`).
-     */
-    singleCharacters;
-    /**
-     * Flag indicating whether iterator should enter elements or not. If the iterator is shallow child nodes of any
-     * iterated node will not be returned along with `elementEnd` tag.
-     */
-    shallow;
-    /**
-     * Flag indicating whether iterator should ignore `elementEnd` tags. If the option is true walker will not
-     * return a parent node of the start position. If this option is `true` each {@link module:engine/model/element~ModelElement} will
-     * be returned once, while if the option is `false` they might be returned twice:
-     * for `'elementStart'` and `'elementEnd'`.
-     */
-    ignoreElementEnd;
-    /**
-     * Iterator position. This is always static position, even if the initial position was a
-     * {@link module:engine/model/liveposition~ModelLivePosition live position}. If start position is not defined then position depends
-     * on {@link #direction}. If direction is `'forward'` position starts form the beginning, when direction
-     * is `'backward'` position starts from the end.
-     */
-    _position;
-    /**
-     * Start boundary cached for optimization purposes.
-     */
-    _boundaryStartParent;
-    /**
-     * End boundary cached for optimization purposes.
-     */
-    _boundaryEndParent;
-    /**
-     * Parent of the most recently visited node. Cached for optimization purposes.
-     */
-    _visitedParent;
-    /**
-     * Creates a range iterator. All parameters are optional, but you have to specify either `boundaries` or `startPosition`.
-     *
-     * @param options Object with configuration.
-     */
-    constructor(options) {
-        if (!options || (!options.boundaries && !options.startPosition)) {
-            /**
-             * Neither boundaries nor starting position of a `TreeWalker` have been defined.
-             *
-             * @error model-tree-walker-no-start-position
-             */
-            throw new CKEditorError('model-tree-walker-no-start-position', null);
-        }
-        const direction = options.direction || 'forward';
-        if (direction != 'forward' && direction != 'backward') {
-            /**
-             * Only `backward` and `forward` direction allowed.
-             *
-             * @error model-tree-walker-unknown-direction
-             */
-            throw new CKEditorError('model-tree-walker-unknown-direction', options, { direction });
-        }
-        this.direction = direction;
-        this.boundaries = options.boundaries || null;
-        if (options.startPosition) {
-            this._position = options.startPosition.clone();
-        }
-        else {
-            this._position = ModelPosition._createAt(this.boundaries[this.direction == 'backward' ? 'end' : 'start']);
-        }
-        // Reset position stickiness in case it was set to other value, as the stickiness is kept after cloning.
-        this.position.stickiness = 'toNone';
-        this.singleCharacters = !!options.singleCharacters;
-        this.shallow = !!options.shallow;
-        this.ignoreElementEnd = !!options.ignoreElementEnd;
-        this._boundaryStartParent = this.boundaries ? this.boundaries.start.parent : null;
-        this._boundaryEndParent = this.boundaries ? this.boundaries.end.parent : null;
-        this._visitedParent = this.position.parent;
-    }
-    /**
-     * Iterable interface.
-     *
-     * @returns {Iterable.<module:engine/model/treewalker~ModelTreeWalkerValue>}
-     */
-    [Symbol.iterator]() {
-        return this;
-    }
-    /**
-     * Iterator position. This is always static position, even if the initial position was a
-     * {@link module:engine/model/liveposition~ModelLivePosition live position}. If start position is not defined then position depends
-     * on {@link #direction}. If direction is `'forward'` position starts form the beginning, when direction
-     * is `'backward'` position starts from the end.
-     */
-    get position() {
-        return this._position;
-    }
-    /**
-     * Moves {@link #position} in the {@link #direction} skipping values as long as the callback function returns `true`.
-     *
-     * For example:
-     *
-     * ```ts
-     * walker.skip( value => value.type == 'text' ); // <paragraph>[]foo</paragraph> -> <paragraph>foo[]</paragraph>
-     * walker.skip( () => true ); // Move the position to the end: <paragraph>[]foo</paragraph> -> <paragraph>foo</paragraph>[]
-     * walker.skip( () => false ); // Do not move the position.
-     * ```
-     *
-     * @param skip Callback function. Gets {@link module:engine/model/treewalker~ModelTreeWalkerValue} and should
-     * return `true` if the value should be skipped or `false` if not.
-     */
-    skip(skip) {
-        let done, value, prevPosition, prevVisitedParent;
-        do {
-            prevPosition = this.position;
-            prevVisitedParent = this._visitedParent;
-            ({ done, value } = this.next());
-        } while (!done && skip(value));
-        if (!done) {
-            this._position = prevPosition;
-            this._visitedParent = prevVisitedParent;
-        }
-    }
-    /**
-     * Moves tree walker {@link #position} to provided `position`. Tree walker will
-     * continue traversing from that position.
-     *
-     * Note: in contrary to {@link ~ModelTreeWalker#skip}, this method does not iterate over the nodes along the way.
-     * It simply sets the current tree walker position to a new one.
-     * From the performance standpoint, it is better to use {@link ~ModelTreeWalker#jumpTo} rather than {@link ~ModelTreeWalker#skip}.
-     *
-     * If the provided position is before the start boundary, the position will be
-     * set to the start boundary. If the provided position is after the end boundary,
-     * the position will be set to the end boundary.
-     * This is done to prevent the treewalker from traversing outside the boundaries.
-     *
-     * @param position Position to jump to.
-     */
-    jumpTo(position) {
-        if (this._boundaryStartParent && position.isBefore(this.boundaries.start)) {
-            position = this.boundaries.start;
-        }
-        else if (this._boundaryEndParent && position.isAfter(this.boundaries.end)) {
-            position = this.boundaries.end;
-        }
-        this._position = position.clone();
-        this._visitedParent = position.parent;
-    }
-    /**
-     * Gets the next tree walker's value.
-     */
-    next() {
-        if (this.direction == 'forward') {
-            return this._next();
-        }
-        else {
-            return this._previous();
-        }
-    }
-    /**
-     * Makes a step forward in model. Moves the {@link #position} to the next position and returns the encountered value.
-     */
-    _next() {
-        const previousPosition = this.position;
-        const position = this.position.clone();
-        const parent = this._visitedParent;
-        // We are at the end of the root.
-        if (parent.parent === null && position.offset === parent.maxOffset) {
-            return { done: true, value: undefined };
-        }
-        // We reached the walker boundary.
-        if (parent === this._boundaryEndParent && position.offset == this.boundaries.end.offset) {
-            return { done: true, value: undefined };
-        }
-        // Get node just after the current position.
-        // Use a highly optimized version instead of checking the text node first and then getting the node after. See #6582.
-        const textNodeAtPosition = getTextNodeAtPosition(position, parent);
-        const node = textNodeAtPosition || getNodeAfterPosition(position, parent, textNodeAtPosition);
-        if (node && node.is('model:element')) {
-            if (!this.shallow) {
-                // Manual operations on path internals for optimization purposes. Here and in the rest of the method.
-                position.path.push(0);
-                this._visitedParent = node;
-            }
-            else {
-                // We are past the walker boundaries.
-                if (this.boundaries && this.boundaries.end.isBefore(position)) {
-                    return { done: true, value: undefined };
-                }
-                position.offset++;
-            }
-            this._position = position;
-            return formatReturnValue('elementStart', node, previousPosition, position, 1);
-        }
-        if (node && node.is('model:$text')) {
-            let charactersCount;
-            if (this.singleCharacters) {
-                charactersCount = 1;
-            }
-            else {
-                let offset = node.endOffset;
-                if (this._boundaryEndParent == parent && this.boundaries.end.offset < offset) {
-                    offset = this.boundaries.end.offset;
-                }
-                charactersCount = offset - position.offset;
-            }
-            const offsetInTextNode = position.offset - node.startOffset;
-            const item = new ModelTextProxy(node, offsetInTextNode, charactersCount);
-            position.offset += charactersCount;
-            this._position = position;
-            return formatReturnValue('text', item, previousPosition, position, charactersCount);
-        }
-        // `node` is not set, we reached the end of current `parent`.
-        position.path.pop();
-        position.offset++;
-        this._position = position;
-        this._visitedParent = parent.parent;
-        if (this.ignoreElementEnd) {
-            return this._next();
-        }
-        return formatReturnValue('elementEnd', parent, previousPosition, position);
-    }
-    /**
-     * Makes a step backward in model. Moves the {@link #position} to the previous position and returns the encountered value.
-     */
-    _previous() {
-        const previousPosition = this.position;
-        const position = this.position.clone();
-        const parent = this._visitedParent;
-        // We are at the beginning of the root.
-        if (parent.parent === null && position.offset === 0) {
-            return { done: true, value: undefined };
-        }
-        // We reached the walker boundary.
-        if (parent == this._boundaryStartParent && position.offset == this.boundaries.start.offset) {
-            return { done: true, value: undefined };
-        }
-        // Get node just before the current position.
-        // Use a highly optimized version instead of checking the text node first and then getting the node before. See #6582.
-        const positionParent = position.parent;
-        const textNodeAtPosition = getTextNodeAtPosition(position, positionParent);
-        const node = textNodeAtPosition || getNodeBeforePosition(position, positionParent, textNodeAtPosition);
-        if (node && node.is('model:element')) {
-            position.offset--;
-            if (this.shallow) {
-                this._position = position;
-                return formatReturnValue('elementStart', node, previousPosition, position, 1);
-            }
-            position.path.push(node.maxOffset);
-            this._position = position;
-            this._visitedParent = node;
-            if (this.ignoreElementEnd) {
-                return this._previous();
-            }
-            return formatReturnValue('elementEnd', node, previousPosition, position);
-        }
-        if (node && node.is('model:$text')) {
-            let charactersCount;
-            if (this.singleCharacters) {
-                charactersCount = 1;
-            }
-            else {
-                let offset = node.startOffset;
-                if (this._boundaryStartParent == parent && this.boundaries.start.offset > offset) {
-                    offset = this.boundaries.start.offset;
-                }
-                charactersCount = position.offset - offset;
-            }
-            const offsetInTextNode = position.offset - node.startOffset;
-            const item = new ModelTextProxy(node, offsetInTextNode - charactersCount, charactersCount);
-            position.offset -= charactersCount;
-            this._position = position;
-            return formatReturnValue('text', item, previousPosition, position, charactersCount);
-        }
-        // `node` is not set, we reached the beginning of current `parent`.
-        position.path.pop();
-        this._position = position;
-        this._visitedParent = parent.parent;
-        return formatReturnValue('elementStart', parent, previousPosition, position, 1);
-    }
-}
-function formatReturnValue(type, item, previousPosition, nextPosition, length) {
-    return {
-        done: false,
-        value: {
-            type,
-            item,
-            previousPosition,
-            nextPosition,
-            length
-        }
-    };
-}

package/src/model/typecheckable.js

@@ -1,16 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-export class ModelTypeCheckable {
-    /* istanbul ignore next -- @preserve */
-    is() {
-        // There are a lot of overloads above.
-        // Overriding method in derived classes remove them and only `is( type: string ): boolean` is visible which we don't want.
-        // One option would be to copy them all to all classes, but that's ugly.
-        // It's best when TypeScript compiler doesn't see those overloads, except the one in the top base class.
-        // To overload a method, but not let the compiler see it, do after class definition:
-        // `MyClass.prototype.is = function( type: string ) {...}`
-        throw new Error('is() method is abstract');
-    }
-}

package/src/model/utils/autoparagraphing.js

@@ -1,63 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/model/utils/autoparagraphing
- */
-/**
- * Fixes all empty roots.
- *
- * @internal
- * @param writer The model writer.
- * @returns `true` if any change has been applied, `false` otherwise.
- */
-export function autoParagraphEmptyRoots(writer) {
-    const { schema, document } = writer.model;
-    for (const root of document.getRoots()) {
-        if (root.isEmpty && !schema.checkChild(root, '$text')) {
-            // If paragraph element is allowed in the root, create paragraph element.
-            if (schema.checkChild(root, 'paragraph')) {
-                writer.insertElement('paragraph', root);
-                // Other roots will get fixed in the next post-fixer round. Those will be triggered
-                // in the same batch no matter if this method was triggered by the post-fixing or not
-                // (the above insertElement call will trigger the post-fixers).
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Checks if the given node wrapped with a paragraph would be accepted by the schema in the given position.
- *
- * @internal
- * @param position The position at which to check.
- * @param nodeOrType The child node or child type to check.
- * @param schema A schema instance used for element validation.
- */
-export function isParagraphable(position, nodeOrType, schema) {
-    const context = schema.createContext(position);
-    // When paragraph is allowed in this context...
-    if (!schema.checkChild(context, 'paragraph')) {
-        return false;
-    }
-    // And a node would be allowed in this paragraph...
-    if (!schema.checkChild(context.push('paragraph'), nodeOrType)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Inserts a new paragraph at the given position and returns a position inside that paragraph.
- *
- * @internal
- * @param position The position where a paragraph should be inserted.
- * @param writer The model writer.
- * @returns  Position inside the created paragraph.
- */
-export function wrapInParagraph(position, writer) {
-    const paragraph = writer.createElement('paragraph');
-    writer.insert(paragraph, position);
-    return writer.createPositionAt(paragraph, 0);
-}