@ckeditor/ckeditor5-clipboard 0.0.0-nightly-20260108.0 → 0.0.0-nightly-next-20260108.0

package/src/dragdropblocktoolbar.js

@@ -1,124 +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 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

@@ -1,390 +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 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

@@ -1,23 +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 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

@@ -1,46 +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 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

@@ -1,102 +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 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;
-}