@ckeditor/ckeditor5-clipboard 0.0.0-nightly-next-20260117.0 → 0.0.0-nightly-20260118.0

package/src/dragdropblocktoolbar.js

@@ -0,0 +1,124 @@
+/**
+ * @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 clipboard/dragdropblocktoolbar
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import { env, global, DomEmitterMixin } from '@ckeditor/ckeditor5-utils';
+import { ClipboardObserver } from './clipboardobserver.js';
+/**
+ * Integration of a block Drag and Drop support with the block toolbar.
+ *
+ * @internal
+ */
+export class DragDropBlockToolbar extends Plugin {
+    /**
+     * Whether current dragging is started by block toolbar button dragging.
+     */
+    _isBlockDragging = false;
+    /**
+     * DOM Emitter.
+     */
+    _domEmitter = new (DomEmitterMixin())();
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'DragDropBlockToolbar';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        this.listenTo(editor, 'change:isReadOnly', (evt, name, isReadOnly) => {
+            if (isReadOnly) {
+                this.forceDisabled('readOnlyMode');
+                this._isBlockDragging = false;
+            }
+            else {
+                this.clearForceDisabled('readOnlyMode');
+            }
+        });
+        if (env.isAndroid) {
+            this.forceDisabled('noAndroidSupport');
+        }
+        if (editor.plugins.has('BlockToolbar')) {
+            const blockToolbar = editor.plugins.get('BlockToolbar');
+            const element = blockToolbar.buttonView.element;
+            this._domEmitter.listenTo(element, 'dragstart', (evt, data) => this._handleBlockDragStart(data));
+            this._domEmitter.listenTo(global.document, 'dragover', (evt, data) => this._handleBlockDragging(data));
+            this._domEmitter.listenTo(global.document, 'drop', (evt, data) => this._handleBlockDragging(data));
+            this._domEmitter.listenTo(global.document, 'dragend', () => this._handleBlockDragEnd(), { useCapture: true });
+            if (this.isEnabled) {
+                element.setAttribute('draggable', 'true');
+            }
+            this.on('change:isEnabled', (evt, name, isEnabled) => {
+                element.setAttribute('draggable', isEnabled ? 'true' : 'false');
+            });
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        this._domEmitter.stopListening();
+        return super.destroy();
+    }
+    /**
+     * The `dragstart` event handler.
+     */
+    _handleBlockDragStart(domEvent) {
+        if (!this.isEnabled) {
+            return;
+        }
+        const model = this.editor.model;
+        const selection = model.document.selection;
+        const view = this.editor.editing.view;
+        const blocks = Array.from(selection.getSelectedBlocks());
+        const draggedRange = model.createRange(model.createPositionBefore(blocks[0]), model.createPositionAfter(blocks[blocks.length - 1]));
+        model.change(writer => writer.setSelection(draggedRange));
+        this._isBlockDragging = true;
+        view.focus();
+        view.getObserver(ClipboardObserver).onDomEvent(domEvent);
+    }
+    /**
+     * The `dragover` and `drop` event handler.
+     */
+    _handleBlockDragging(domEvent) {
+        if (!this.isEnabled || !this._isBlockDragging) {
+            return;
+        }
+        const clientX = domEvent.clientX + (this.editor.locale.contentLanguageDirection == 'ltr' ? 100 : -100);
+        const clientY = domEvent.clientY;
+        const target = document.elementFromPoint(clientX, clientY);
+        const view = this.editor.editing.view;
+        if (!target || !target.closest('.ck-editor__editable')) {
+            return;
+        }
+        view.getObserver(ClipboardObserver).onDomEvent({
+            ...domEvent,
+            type: domEvent.type,
+            dataTransfer: domEvent.dataTransfer,
+            target,
+            clientX,
+            clientY,
+            preventDefault: () => domEvent.preventDefault(),
+            stopPropagation: () => domEvent.stopPropagation()
+        });
+    }
+    /**
+     * The `dragend` event handler.
+     */
+    _handleBlockDragEnd() {
+        this._isBlockDragging = false;
+    }
+}

package/src/dragdroptarget.js

@@ -0,0 +1,390 @@
+/**
+ * @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 clipboard/dragdroptarget
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import { global, Rect, DomEmitterMixin, delay, ResizeObserver } from '@ckeditor/ckeditor5-utils';
+import { LineView } from './lineview.js';
+import { throttle } from 'es-toolkit/compat';
+/**
+ * Part of the Drag and Drop handling. Responsible for finding and displaying the drop target.
+ *
+ * @internal
+ */
+export class DragDropTarget extends Plugin {
+    /**
+     * A delayed callback removing the drop marker.
+     *
+     * @internal
+     */
+    removeDropMarkerDelayed = delay(() => this.removeDropMarker(), 40);
+    /**
+     * A throttled callback updating the drop marker.
+     */
+    _updateDropMarkerThrottled = throttle(targetRange => this._updateDropMarker(targetRange), 40);
+    /**
+     * A throttled callback reconverting the drop parker.
+     */
+    _reconvertMarkerThrottled = throttle(() => {
+        if (this.editor.model.markers.has('drop-target')) {
+            this.editor.editing.reconvertMarker('drop-target');
+        }
+    }, 0);
+    /**
+     * The horizontal drop target line view.
+     */
+    _dropTargetLineView = new LineView();
+    /**
+     * DOM Emitter.
+     */
+    _domEmitter = new (DomEmitterMixin())();
+    /**
+     * Map of document scrollable elements.
+     */
+    _scrollables = new Map();
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'DragDropTarget';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        this._setupDropMarker();
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        this._domEmitter.stopListening();
+        for (const { resizeObserver } of this._scrollables.values()) {
+            resizeObserver.destroy();
+        }
+        this._updateDropMarkerThrottled.cancel();
+        this.removeDropMarkerDelayed.cancel();
+        this._reconvertMarkerThrottled.cancel();
+        return super.destroy();
+    }
+    /**
+     * Finds the drop target range and updates the drop marker.
+     *
+     * @return The updated drop target range or null if no valid range was found.
+     * @internal
+     */
+    updateDropMarker(targetViewElement, targetViewRanges, clientX, clientY, blockMode, draggedRange) {
+        this.removeDropMarkerDelayed.cancel();
+        const targetRange = findDropTargetRange(this.editor, targetViewElement, targetViewRanges, clientX, clientY, blockMode, draggedRange);
+        /* istanbul ignore next -- @preserve */
+        if (!targetRange) {
+            return null;
+        }
+        if (draggedRange && draggedRange.containsRange(targetRange)) {
+            // Target range is inside the dragged range.
+            this.removeDropMarker();
+            return null;
+        }
+        if (targetRange && !this.editor.model.canEditAt(targetRange)) {
+            // Do not show drop marker if target place is not editable.
+            this.removeDropMarker();
+            return null;
+        }
+        this._updateDropMarkerThrottled(targetRange);
+        return targetRange;
+    }
+    /**
+     * Finds the final drop target range.
+     *
+     * @internal
+     */
+    getFinalDropRange(targetViewElement, targetViewRanges, clientX, clientY, blockMode, draggedRange) {
+        const targetRange = findDropTargetRange(this.editor, targetViewElement, targetViewRanges, clientX, clientY, blockMode, draggedRange);
+        // The dragging markers must be removed after searching for the target range because sometimes
+        // the target lands on the marker itself.
+        this.removeDropMarker();
+        return targetRange;
+    }
+    /**
+     * Removes the drop target marker.
+     *
+     * @internal
+     */
+    removeDropMarker() {
+        const model = this.editor.model;
+        this.removeDropMarkerDelayed.cancel();
+        this._updateDropMarkerThrottled.cancel();
+        this._dropTargetLineView.isVisible = false;
+        if (model.markers.has('drop-target')) {
+            model.change(writer => {
+                writer.removeMarker('drop-target');
+            });
+        }
+    }
+    /**
+     * Creates downcast conversion for the drop target marker.
+     */
+    _setupDropMarker() {
+        const editor = this.editor;
+        editor.ui.view.body.add(this._dropTargetLineView);
+        // Drop marker conversion for hovering over widgets.
+        editor.conversion.for('editingDowncast').markerToHighlight({
+            model: 'drop-target',
+            view: {
+                classes: ['ck-clipboard-drop-target-range']
+            }
+        });
+        // Drop marker conversion for in text and block drop target.
+        editor.conversion.for('editingDowncast').markerToElement({
+            model: 'drop-target',
+            view: (data, { writer }) => {
+                // Inline drop.
+                if (editor.model.schema.checkChild(data.markerRange.start, '$text')) {
+                    this._dropTargetLineView.isVisible = false;
+                    return this._createDropTargetPosition(writer);
+                }
+                // Block drop.
+                else {
+                    if (data.markerRange.isCollapsed) {
+                        this._updateDropTargetLine(data.markerRange);
+                    }
+                    else {
+                        this._dropTargetLineView.isVisible = false;
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Updates the drop target marker to the provided range.
+     *
+     * @param targetRange The range to set the marker to.
+     */
+    _updateDropMarker(targetRange) {
+        const editor = this.editor;
+        const markers = editor.model.markers;
+        editor.model.change(writer => {
+            if (markers.has('drop-target')) {
+                if (!markers.get('drop-target').getRange().isEqual(targetRange)) {
+                    writer.updateMarker('drop-target', { range: targetRange });
+                }
+            }
+            else {
+                writer.addMarker('drop-target', {
+                    range: targetRange,
+                    usingOperation: false,
+                    affectsData: false
+                });
+            }
+        });
+    }
+    /**
+     * Creates the UI element for vertical (in-line) drop target.
+     */
+    _createDropTargetPosition(writer) {
+        return writer.createUIElement('span', { class: 'ck ck-clipboard-drop-target-position' }, function (domDocument) {
+            const domElement = this.toDomElement(domDocument);
+            // Using word joiner to make this marker as high as text and also making text not break on marker.
+            domElement.append('\u2060', domDocument.createElement('span'), '\u2060');
+            return domElement;
+        });
+    }
+    /**
+     * Updates the horizontal drop target line.
+     */
+    _updateDropTargetLine(range) {
+        const editing = this.editor.editing;
+        const nodeBefore = range.start.nodeBefore;
+        const nodeAfter = range.start.nodeAfter;
+        const nodeParent = range.start.parent;
+        const viewElementBefore = nodeBefore ? editing.mapper.toViewElement(nodeBefore) : null;
+        const domElementBefore = viewElementBefore ? editing.view.domConverter.mapViewToDom(viewElementBefore) : null;
+        const viewElementAfter = nodeAfter ? editing.mapper.toViewElement(nodeAfter) : null;
+        const domElementAfter = viewElementAfter ? editing.view.domConverter.mapViewToDom(viewElementAfter) : null;
+        const viewElementParent = editing.mapper.toViewElement(nodeParent);
+        if (!viewElementParent) {
+            return;
+        }
+        const domElementParent = editing.view.domConverter.mapViewToDom(viewElementParent);
+        const domScrollableRect = this._getScrollableRect(viewElementParent);
+        const { scrollX, scrollY } = global.window;
+        const rectBefore = domElementBefore ? new Rect(domElementBefore) : null;
+        const rectAfter = domElementAfter ? new Rect(domElementAfter) : null;
+        const rectParent = new Rect(domElementParent).excludeScrollbarsAndBorders();
+        const above = rectBefore ? rectBefore.bottom : rectParent.top;
+        const below = rectAfter ? rectAfter.top : rectParent.bottom;
+        const parentStyle = global.window.getComputedStyle(domElementParent);
+        const top = (above <= below ? (above + below) / 2 : below);
+        if (domScrollableRect.top < top && top < domScrollableRect.bottom) {
+            const left = rectParent.left + parseFloat(parentStyle.paddingLeft);
+            const right = rectParent.right - parseFloat(parentStyle.paddingRight);
+            const leftClamped = Math.max(left + scrollX, domScrollableRect.left);
+            const rightClamped = Math.min(right + scrollX, domScrollableRect.right);
+            this._dropTargetLineView.set({
+                isVisible: true,
+                left: leftClamped,
+                top: top + scrollY,
+                width: rightClamped - leftClamped
+            });
+        }
+        else {
+            this._dropTargetLineView.isVisible = false;
+        }
+    }
+    /**
+     * Finds the closest scrollable element rect for the given view element.
+     */
+    _getScrollableRect(viewElement) {
+        const rootName = viewElement.root.rootName;
+        let domScrollable;
+        if (this._scrollables.has(rootName)) {
+            domScrollable = this._scrollables.get(rootName).domElement;
+        }
+        else {
+            const domElement = this.editor.editing.view.domConverter.mapViewToDom(viewElement);
+            domScrollable = findScrollableElement(domElement);
+            this._domEmitter.listenTo(domScrollable, 'scroll', this._reconvertMarkerThrottled, { usePassive: true });
+            const resizeObserver = new ResizeObserver(domScrollable, this._reconvertMarkerThrottled);
+            this._scrollables.set(rootName, {
+                domElement: domScrollable,
+                resizeObserver
+            });
+        }
+        return new Rect(domScrollable).excludeScrollbarsAndBorders();
+    }
+}
+/**
+ * Returns fixed selection range for given position and target element.
+ */
+function findDropTargetRange(editor, targetViewElement, targetViewRanges, clientX, clientY, blockMode, draggedRange) {
+    const model = editor.model;
+    const mapper = editor.editing.mapper;
+    const targetModelElement = getClosestMappedModelElement(editor, targetViewElement);
+    let modelElement = targetModelElement;
+    while (modelElement) {
+        if (!blockMode) {
+            if (model.schema.checkChild(modelElement, '$text')) {
+                if (targetViewRanges) {
+                    const targetViewPosition = targetViewRanges[0].start;
+                    const targetModelPosition = mapper.toModelPosition(targetViewPosition);
+                    const canDropOnPosition = !draggedRange || Array
+                        .from(draggedRange.getItems({ shallow: true }))
+                        .some(item => model.schema.checkChild(targetModelPosition, item));
+                    if (canDropOnPosition) {
+                        if (model.schema.checkChild(targetModelPosition, '$text')) {
+                            return model.createRange(targetModelPosition);
+                        }
+                        else if (targetViewPosition) {
+                            // This is the case of dropping inside a span wrapper of an inline image.
+                            return findDropTargetRangeForElement(editor, getClosestMappedModelElement(editor, targetViewPosition.parent), clientX, clientY);
+                        }
+                    }
+                }
+            }
+            else if (model.schema.isInline(modelElement)) {
+                return findDropTargetRangeForElement(editor, modelElement, clientX, clientY);
+            }
+        }
+        if (model.schema.isBlock(modelElement)) {
+            return findDropTargetRangeForElement(editor, modelElement, clientX, clientY);
+        }
+        else if (model.schema.checkChild(modelElement, '$block')) {
+            const childNodes = Array.from(modelElement.getChildren())
+                .filter((node) => node.is('element') && !shouldIgnoreElement(editor, node));
+            let startIndex = 0;
+            let endIndex = childNodes.length;
+            if (endIndex == 0) {
+                return model.createRange(model.createPositionAt(modelElement, 'end'));
+            }
+            while (startIndex < endIndex - 1) {
+                const middleIndex = Math.floor((startIndex + endIndex) / 2);
+                const side = findElementSide(editor, childNodes[middleIndex], clientX, clientY);
+                if (side == 'before') {
+                    endIndex = middleIndex;
+                }
+                else {
+                    startIndex = middleIndex;
+                }
+            }
+            return findDropTargetRangeForElement(editor, childNodes[startIndex], clientX, clientY);
+        }
+        modelElement = modelElement.parent;
+    }
+    return null;
+}
+/**
+ * Returns true for elements which should be ignored.
+ */
+function shouldIgnoreElement(editor, modelElement) {
+    const mapper = editor.editing.mapper;
+    const domConverter = editor.editing.view.domConverter;
+    const viewElement = mapper.toViewElement(modelElement);
+    if (!viewElement) {
+        return true;
+    }
+    const domElement = domConverter.mapViewToDom(viewElement);
+    return global.window.getComputedStyle(domElement).float != 'none';
+}
+/**
+ * Returns target range relative to the given element.
+ */
+function findDropTargetRangeForElement(editor, modelElement, clientX, clientY) {
+    const model = editor.model;
+    return model.createRange(model.createPositionAt(modelElement, findElementSide(editor, modelElement, clientX, clientY)));
+}
+/**
+ * Resolves whether drop marker should be before or after the given element.
+ */
+function findElementSide(editor, modelElement, clientX, clientY) {
+    const mapper = editor.editing.mapper;
+    const domConverter = editor.editing.view.domConverter;
+    const viewElement = mapper.toViewElement(modelElement);
+    const domElement = domConverter.mapViewToDom(viewElement);
+    const rect = new Rect(domElement);
+    if (editor.model.schema.isInline(modelElement)) {
+        return clientX < (rect.left + rect.right) / 2 ? 'before' : 'after';
+    }
+    else {
+        return clientY < (rect.top + rect.bottom) / 2 ? 'before' : 'after';
+    }
+}
+/**
+ * Returns the closest model element for the specified view element.
+ */
+function getClosestMappedModelElement(editor, element) {
+    const mapper = editor.editing.mapper;
+    const view = editor.editing.view;
+    const targetModelElement = mapper.toModelElement(element);
+    if (targetModelElement) {
+        return targetModelElement;
+    }
+    // Find mapped ancestor if the target is inside not mapped element (for example inline code element).
+    const viewPosition = view.createPositionBefore(element);
+    const viewElement = mapper.findMappedViewAncestor(viewPosition);
+    return mapper.toModelElement(viewElement);
+}
+/**
+ * Returns the closest scrollable ancestor DOM element.
+ *
+ * It is assumed that `domNode` is attached to the document.
+ */
+function findScrollableElement(domNode) {
+    let domElement = domNode;
+    do {
+        domElement = domElement.parentElement;
+        const overflow = global.window.getComputedStyle(domElement).overflowY;
+        if (overflow == 'auto' || overflow == 'scroll') {
+            break;
+        }
+    } while (domElement.tagName != 'BODY');
+    return domElement;
+}

package/src/index.js

@@ -0,0 +1,23 @@
+/**
+ * @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 clipboard
+ */
+export { Clipboard } from './clipboard.js';
+export { ClipboardPipeline } from './clipboardpipeline.js';
+export { ClipboardMarkersUtils } from './clipboardmarkersutils.js';
+export { plainTextToHtml } from './utils/plaintexttohtml.js';
+export { viewToPlainText } from './utils/viewtoplaintext.js';
+export { DragDrop } from './dragdrop.js';
+export { PastePlainText } from './pasteplaintext.js';
+export { DragDropTarget } from './dragdroptarget.js';
+export { DragDropBlockToolbar } from './dragdropblocktoolbar.js';
+export { ClipboardObserver } from './clipboardobserver.js';
+export { DragDrop as _DragDrop } from './dragdrop.js';
+export { DragDropBlockToolbar as _DragDropBlockToolbar } from './dragdropblocktoolbar.js';
+export { DragDropTarget as _DragDropTarget } from './dragdroptarget.js';
+export { LineView as _ClipboardLineView } from './lineview.js';
+export { normalizeClipboardData as _normalizeClipboardData } from './utils/normalizeclipboarddata.js';
+import './augmentation.js';

package/src/lineview.js

@@ -0,0 +1,46 @@
+/**
+ * @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 clipboard/lineview
+ */
+/* istanbul ignore file -- @preserve */
+import { View } from '@ckeditor/ckeditor5-ui';
+import { toUnit } from '@ckeditor/ckeditor5-utils';
+const toPx = /* #__PURE__ */ toUnit('px');
+/**
+ * The horizontal drop target line view.
+ *
+ * @internal
+ */
+export class LineView extends View {
+    /**
+     * @inheritDoc
+     */
+    constructor() {
+        super();
+        const bind = this.bindTemplate;
+        this.set({
+            isVisible: false,
+            left: null,
+            top: null,
+            width: null
+        });
+        this.setTemplate({
+            tag: 'div',
+            attributes: {
+                class: [
+                    'ck',
+                    'ck-clipboard-drop-target-line',
+                    bind.if('isVisible', 'ck-hidden', value => !value)
+                ],
+                style: {
+                    left: bind.to('left', left => toPx(left)),
+                    top: bind.to('top', top => toPx(top)),
+                    width: bind.to('width', width => toPx(width))
+                }
+            }
+        });
+    }
+}

package/src/pasteplaintext.js

@@ -0,0 +1,102 @@
+/**
+ * @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 clipboard/pasteplaintext
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import { ClipboardObserver } from './clipboardobserver.js';
+import { ClipboardPipeline } from './clipboardpipeline.js';
+/**
+ * The plugin detects the user's intention to paste plain text.
+ *
+ * For example, it detects the <kbd>Ctrl/Cmd</kbd> + <kbd>Shift</kbd> + <kbd>V</kbd> keystroke.
+ */
+export class PastePlainText extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'PastePlainText';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [ClipboardPipeline];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        const model = editor.model;
+        const view = editor.editing.view;
+        const selection = model.document.selection;
+        view.addObserver(ClipboardObserver);
+        editor.plugins.get(ClipboardPipeline).on('contentInsertion', (evt, data) => {
+            if (!isUnformattedInlineContent(data.content, model)) {
+                return;
+            }
+            model.change(writer => {
+                // Formatting attributes should be preserved.
+                const textAttributes = Array.from(selection.getAttributes())
+                    .filter(([key]) => model.schema.getAttributeProperties(key).isFormatting);
+                if (!selection.isCollapsed) {
+                    model.deleteContent(selection, { doNotAutoparagraph: true });
+                }
+                // Also preserve other attributes if they survived the content deletion (because they were not fully selected).
+                // For example linkHref is not a formatting attribute but it should be preserved if pasted text was in the middle
+                // of a link.
+                textAttributes.push(...selection.getAttributes());
+                const range = writer.createRangeIn(data.content);
+                for (const item of range.getItems()) {
+                    for (const attribute of textAttributes) {
+                        if (model.schema.checkAttribute(item, attribute[0])) {
+                            writer.setAttribute(attribute[0], attribute[1], item);
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+/**
+ * Returns true if specified `documentFragment` represents the unformatted inline content.
+ */
+function isUnformattedInlineContent(documentFragment, model) {
+    let range = model.createRangeIn(documentFragment);
+    // We consider three scenarios here. The document fragment may include:
+    //
+    // 1. Only text and inline objects. Then it could be unformatted inline content.
+    // 2. Exactly one block element on top-level, eg. <p>Foobar</p> or <h2>Title</h2>.
+    //    In this case, check this element content, it could be treated as unformatted inline content.
+    // 3. More block elements or block objects, then it is not unformatted inline content.
+    //
+    // We will check for scenario 2. specifically, and if it happens, we will unwrap it and follow with the regular algorithm.
+    //
+    if (documentFragment.childCount == 1) {
+        const child = documentFragment.getChild(0);
+        if (child.is('element') && model.schema.isBlock(child) && !model.schema.isObject(child) && !model.schema.isLimit(child)) {
+            // Scenario 2. as described above.
+            range = model.createRangeIn(child);
+        }
+    }
+    for (const child of range.getItems()) {
+        if (!model.schema.isInline(child)) {
+            return false;
+        }
+        const attributeKeys = Array.from(child.getAttributeKeys());
+        if (attributeKeys.find(key => model.schema.getAttributeProperties(key).isFormatting)) {
+            return false;
+        }
+    }
+    return true;
+}