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

package/src/view/observer/domeventdata.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/view/observer/domeventdata
- */
-import { extend } from 'es-toolkit/compat';
-/**
- * Information about a DOM event in context of the {@link module:engine/view/document~ViewDocument}.
- * It wraps the native event, which usually should not be used as the wrapper contains
- * additional data (like key code for keyboard events).
- *
- * @typeParam TEvent The type of DOM Event that this class represents.
- */
-export class ViewDocumentDomEventData {
-    /**
-     * Instance of the view controller.
-     */
-    view;
-    /**
-     * The instance of the document.
-     */
-    document;
-    /**
-     * The DOM event.
-     */
-    domEvent;
-    /**
-     * The DOM target.
-     */
-    domTarget;
-    /**
-     * @param view The instance of the view controller.
-     * @param domEvent The DOM event.
-     * @param additionalData Additional properties that the instance should contain.
-     */
-    constructor(view, domEvent, additionalData) {
-        this.view = view;
-        this.document = view.document;
-        this.domEvent = domEvent;
-        this.domTarget = domEvent.target;
-        extend(this, additionalData);
-    }
-    /**
-     * The tree view element representing the target.
-     */
-    get target() {
-        return this.view.domConverter.mapDomToView(this.domTarget);
-    }
-    /**
-     * Prevents the native's event default action.
-     */
-    preventDefault() {
-        this.domEvent.preventDefault();
-    }
-    /**
-     * Stops native event propagation.
-     */
-    stopPropagation() {
-        this.domEvent.stopPropagation();
-    }
-}

package/src/view/observer/domeventobserver.js

@@ -1,81 +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/view/observer/domeventobserver
- */
-import { Observer } from './observer.js';
-import { ViewDocumentDomEventData } from './domeventdata.js';
-/**
- * Base class for DOM event observers. This class handles
- * {@link module:engine/view/observer/observer~Observer#observe adding} listeners to DOM elements,
- * {@link module:engine/view/observer/observer~Observer#disable disabling} and
- * {@link module:engine/view/observer/observer~Observer#enable re-enabling} events.
- * Child class needs to define
- * {@link module:engine/view/observer/domeventobserver~DomEventObserver#domEventType DOM event type} and
- * {@link module:engine/view/observer/domeventobserver~DomEventObserver#onDomEvent callback}.
- *
- * For instance:
- *
- * ```ts
- * class ClickObserver extends DomEventObserver<'click'> {
- * 	// It can also be defined as a normal property in the constructor.
- * 	get domEventType(): 'click' {
- * 		return 'click';
- * 	}
- *
- * 	onDomEvent( domEvent: MouseEvent ): void {
- * 		this.fire( 'click', domEvent );
- * 	}
- * }
- * ```
- *
- * @typeParam EventType DOM Event type name or an union of those.
- * @typeParam AdditionalData Additional data passed along with the event.
- */
-export class DomEventObserver extends Observer {
-    /**
-     * If set to `true` DOM events will be listened on the capturing phase.
-     * Default value is `false`.
-     */
-    useCapture = false;
-    /**
-     * If set to `true`, indicates that the function specified by listener will never call `preventDefault()`.
-     * Default value is `false`.
-     */
-    usePassive = false;
-    /**
-     * @inheritDoc
-     */
-    observe(domElement) {
-        const types = typeof this.domEventType == 'string' ? [this.domEventType] : this.domEventType;
-        types.forEach(type => {
-            this.listenTo(domElement, type, (eventInfo, domEvent) => {
-                if (this.isEnabled && !this.checkShouldIgnoreEventFromTarget(domEvent.target)) {
-                    this.onDomEvent(domEvent);
-                }
-            }, { useCapture: this.useCapture, usePassive: this.usePassive });
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    stopObserving(domElement) {
-        this.stopListening(domElement);
-    }
-    /**
-     * Calls `Document#fire()` if observer {@link #isEnabled is enabled}.
-     *
-     * @see module:utils/emittermixin~Emitter#fire
-     * @param eventType The event type (name).
-     * @param domEvent The DOM event.
-     * @param additionalData The additional data which should extend the
-     * {@link module:engine/view/observer/domeventdata~ViewDocumentDomEventData event data} object.
-     */
-    fire(eventType, domEvent, additionalData) {
-        if (this.isEnabled) {
-            this.document.fire(eventType, new ViewDocumentDomEventData(this.view, domEvent, additionalData));
-        }
-    }
-}

package/src/view/observer/fakeselectionobserver.js

@@ -1,95 +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/view/observer/fakeselectionobserver
- */
-import { Observer } from './observer.js';
-import { ViewSelection } from '../selection.js';
-import { keyCodes } from '@ckeditor/ckeditor5-utils';
-import { debounce } from 'es-toolkit/compat';
-/**
- * Fake selection observer class. If view selection is fake it is placed in dummy DOM container. This observer listens
- * on {@link module:engine/view/document~ViewDocument#event:keydown keydown} events and handles moving
- * fake view selection to the correct place if arrow keys are pressed.
- * Fires {@link module:engine/view/document~ViewDocument#event:selectionChange selectionChange event} simulating natural behaviour of
- * {@link module:engine/view/observer/selectionobserver~SelectionObserver SelectionObserver}.
- */
-export class FakeSelectionObserver extends Observer {
-    /**
-     * Fires debounced event `selectionChangeDone`. It uses `es-toolkit#debounce` method to delay function call.
-     */
-    _fireSelectionChangeDoneDebounced;
-    /**
-     * Creates new FakeSelectionObserver instance.
-     */
-    constructor(view) {
-        super(view);
-        this._fireSelectionChangeDoneDebounced = debounce(data => {
-            this.document.fire('selectionChangeDone', data);
-        }, 200);
-    }
-    /**
-     * @inheritDoc
-     */
-    observe() {
-        const document = this.document;
-        document.on('arrowKey', (eventInfo, data) => {
-            const selection = document.selection;
-            if (selection.isFake && this.isEnabled) {
-                // Prevents default key down handling - no selection change will occur.
-                data.preventDefault();
-            }
-        }, { context: '$capture' });
-        document.on('arrowKey', (eventInfo, data) => {
-            const selection = document.selection;
-            if (selection.isFake && this.isEnabled) {
-                this._handleSelectionMove(data.keyCode);
-            }
-        }, { priority: 'lowest' });
-    }
-    /**
-     * @inheritDoc
-     */
-    stopObserving() { }
-    /**
-     * @inheritDoc
-     */
-    destroy() {
-        super.destroy();
-        this._fireSelectionChangeDoneDebounced.cancel();
-    }
-    /**
-     * Handles collapsing view selection according to given key code. If left or up key is provided - new selection will be
-     * collapsed to left. If right or down key is pressed - new selection will be collapsed to right.
-     *
-     * This method fires {@link module:engine/view/document~ViewDocument#event:selectionChange} and
-     * {@link module:engine/view/document~ViewDocument#event:selectionChangeDone} events imitating behaviour of
-     * {@link module:engine/view/observer/selectionobserver~SelectionObserver}.
-     */
-    _handleSelectionMove(keyCode) {
-        const selection = this.document.selection;
-        const newSelection = new ViewSelection(selection.getRanges(), { backward: selection.isBackward, fake: false });
-        // Left or up arrow pressed - move selection to start.
-        if (keyCode == keyCodes.arrowleft || keyCode == keyCodes.arrowup) {
-            newSelection.setTo(newSelection.getFirstPosition());
-        }
-        // Right or down arrow pressed - move selection to end.
-        if (keyCode == keyCodes.arrowright || keyCode == keyCodes.arrowdown) {
-            newSelection.setTo(newSelection.getLastPosition());
-        }
-        const data = {
-            oldSelection: selection,
-            newSelection,
-            domSelection: null
-        };
-        // Fire dummy selection change event.
-        this.document.fire('selectionChange', data);
-        // Call` #_fireSelectionChangeDoneDebounced` every time when `selectionChange` event is fired.
-        // This function is debounced what means that `selectionChangeDone` event will be fired only when
-        // defined int the function time will elapse since the last time the function was called.
-        // So `selectionChangeDone` will be fired when selection will stop changing.
-        this._fireSelectionChangeDoneDebounced(data);
-    }
-}

package/src/view/observer/focusobserver.js

@@ -1,166 +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/view/observer/focusobserver
- */
-import { DomEventObserver } from './domeventobserver.js';
-// @if CK_DEBUG_TYPING // const { _debouncedLine, _buildLogMessage } = require( '../../dev-utils/utils.js' );
-/**
- * {@link module:engine/view/document~ViewDocument#event:focus Focus}
- * and {@link module:engine/view/document~ViewDocument#event:blur blur} events observer.
- * Focus observer handle also {@link module:engine/view/rooteditableelement~ViewRootEditableElement#isFocused isFocused} property of the
- * {@link module:engine/view/rooteditableelement~ViewRootEditableElement root elements}.
- *
- * Note that this observer is attached by the {@link module:engine/view/view~EditingView} and is available by default.
- */
-export class FocusObserver extends DomEventObserver {
-    /**
-     * Identifier of the timeout currently used by focus listener to delay rendering execution.
-     */
-    _renderTimeoutId = null;
-    /**
-     * Set to `true` if the document is in the process of setting the focus.
-     *
-     * The flag is used to indicate that setting the focus is in progress.
-     */
-    _isFocusChanging = false;
-    /**
-     * @inheritDoc
-     */
-    domEventType = ['focus', 'blur'];
-    /**
-     * @inheritDoc
-     */
-    constructor(view) {
-        super(view);
-        this.useCapture = true;
-        const document = this.document;
-        document.on('focus', () => this._handleFocus());
-        document.on('blur', (evt, data) => this._handleBlur(data));
-        // Focus the editor in cases where browser dispatches `beforeinput` event to a not-focused editable element.
-        // This is flushed by the beforeinput listener in the `InsertTextObserver`.
-        // Note that focus is set only if the document is not focused yet.
-        // See https://github.com/ckeditor/ckeditor5/issues/14702.
-        document.on('beforeinput', () => {
-            if (!document.isFocused) {
-                this._handleFocus();
-            }
-        }, { priority: 'highest' });
-    }
-    /**
-     * Finishes setting the document focus state.
-     */
-    flush() {
-        if (this._isFocusChanging) {
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	_debouncedLine();
-            // @if CK_DEBUG_TYPING // 	console.group( ..._buildLogMessage( this, 'FocusObserver',
-            // @if CK_DEBUG_TYPING // 		'flush focus'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-            this._isFocusChanging = false;
-            this.document.isFocused = true;
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    onDomEvent(domEvent) {
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	_debouncedLine();
-        // @if CK_DEBUG_TYPING // 	console.group( ..._buildLogMessage( this, 'FocusObserver',
-        // @if CK_DEBUG_TYPING // 		`${ domEvent.type } event`
-        // @if CK_DEBUG_TYPING // 	) );
-        // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'FocusObserver',
-        // @if CK_DEBUG_TYPING // 		'DOM target:',
-        // @if CK_DEBUG_TYPING // 		{ target: domEvent.target, relatedTarget: domEvent.relatedTarget }
-        // @if CK_DEBUG_TYPING // 	) );
-        // @if CK_DEBUG_TYPING // 	const domSelection = window.getSelection();
-        // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'FocusObserver',
-        // @if CK_DEBUG_TYPING // 		'DOM Selection:',
-        // @if CK_DEBUG_TYPING // 		{ node: domSelection!.anchorNode, offset: domSelection!.anchorOffset },
-        // @if CK_DEBUG_TYPING // 		{ node: domSelection!.focusNode, offset: domSelection!.focusOffset }
-        // @if CK_DEBUG_TYPING // 	) );
-        // @if CK_DEBUG_TYPING // }
-        this.fire(domEvent.type, domEvent);
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	console.groupEnd();
-        // @if CK_DEBUG_TYPING // }
-    }
-    /**
-     * @inheritDoc
-     */
-    destroy() {
-        this._clearTimeout();
-        super.destroy();
-    }
-    /**
-     * The `focus` event handler.
-     */
-    _handleFocus() {
-        this._clearTimeout();
-        this._isFocusChanging = true;
-        // Unfortunately native `selectionchange` event is fired asynchronously.
-        // We need to wait until `SelectionObserver` handle the event and then render. Otherwise rendering will
-        // overwrite new DOM selection with selection from the view.
-        // See https://github.com/ckeditor/ckeditor5-engine/issues/795 for more details.
-        // Long timeout is needed to solve #676 and https://github.com/ckeditor/ckeditor5-engine/issues/1157 issues.
-        //
-        // Using `view.change()` instead of `view.forceRender()` to prevent double rendering
-        // in a situation where `selectionchange` already caused selection change.
-        this._renderTimeoutId = setTimeout(() => {
-            this._renderTimeoutId = null;
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.group( ..._buildLogMessage( this, 'FocusObserver',
-            // @if CK_DEBUG_TYPING // 		'flush on timeout'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-            this.flush();
-            this.view.change(() => { });
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
-        }, 50);
-    }
-    /**
-     * The `blur` event handler.
-     */
-    _handleBlur(data) {
-        const selectedEditable = this.document.selection.editableElement;
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'FocusObserver',
-        // @if CK_DEBUG_TYPING // 		'selectedEditable:',
-        // @if CK_DEBUG_TYPING // 		{ selectedEditable }
-        // @if CK_DEBUG_TYPING // 	) );
-        // @if CK_DEBUG_TYPING // }
-        if (selectedEditable === null || selectedEditable === data.target) {
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.group( ..._buildLogMessage( this, 'FocusObserver',
-            // @if CK_DEBUG_TYPING // 		'document no longer focused'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-            this.document.isFocused = false;
-            this._isFocusChanging = false;
-            // Re-render the document to update view elements
-            // (changing document.isFocused already marked view as changed since last rendering).
-            this.view.change(() => { });
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
-        }
-    }
-    /**
-     * Clears timeout.
-     */
-    _clearTimeout() {
-        if (this._renderTimeoutId) {
-            clearTimeout(this._renderTimeoutId);
-            this._renderTimeoutId = null;
-        }
-    }
-}

package/src/view/observer/inputobserver.js

@@ -1,236 +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/view/observer/inputobserver
- */
-import { DomEventObserver } from './domeventobserver.js';
-import { ViewDataTransfer } from '../datatransfer.js';
-import { env, isText, indexOf } from '@ckeditor/ckeditor5-utils';
-import { INLINE_FILLER_LENGTH, startsWithFiller } from '../filler.js';
-// @if CK_DEBUG_TYPING // const { _debouncedLine, _buildLogMessage } = require( '../../dev-utils/utils.js' );
-/**
- * Observer for events connected with data input.
- *
- * **Note**: This observer is attached by {@link module:engine/view/view~EditingView} and available by default in all
- * editor instances.
- */
-export class InputObserver extends DomEventObserver {
-    /**
-     * @inheritDoc
-     */
-    domEventType = 'beforeinput';
-    /**
-     * @inheritDoc
-     */
-    onDomEvent(domEvent) {
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	_debouncedLine();
-        // @if CK_DEBUG_TYPING // 	console.group( ..._buildLogMessage( this, 'InputObserver',
-        // @if CK_DEBUG_TYPING // 		`${ domEvent.type }: ${ domEvent.inputType } - ${ domEvent.isComposing ? 'is' : 'not' } composing`,
-        // @if CK_DEBUG_TYPING // 	) );
-        // @if CK_DEBUG_TYPING // }
-        const domTargetRanges = domEvent.getTargetRanges();
-        const view = this.view;
-        const viewDocument = view.document;
-        let dataTransfer = null;
-        let data = null;
-        let targetRanges = [];
-        if (domEvent.dataTransfer) {
-            dataTransfer = new ViewDataTransfer(domEvent.dataTransfer);
-        }
-        if (domEvent.data !== null) {
-            data = domEvent.data;
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-            // @if CK_DEBUG_TYPING // 		`%cevent data: %c${ JSON.stringify( data ) }`,
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-            // @if CK_DEBUG_TYPING // 		'color: blue;'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-        }
-        else if (dataTransfer) {
-            data = dataTransfer.getData('text/plain');
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-            // @if CK_DEBUG_TYPING // 		`%cevent data transfer: %c${ JSON.stringify( data ) }`,
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-            // @if CK_DEBUG_TYPING // 		'color: blue;'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-        }
-        // If the editor selection is fake (an object is selected), the DOM range does not make sense because it is anchored
-        // in the fake selection container.
-        if (viewDocument.selection.isFake) {
-            // Future-proof: in case of multi-range fake selections being possible.
-            targetRanges = Array.from(viewDocument.selection.getRanges());
-            // Do not allow typing inside a fake selection container, we will handle it manually.
-            domEvent.preventDefault();
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-            // @if CK_DEBUG_TYPING // 		'%cusing fake selection:',
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-            // @if CK_DEBUG_TYPING // 		targetRanges,
-            // @if CK_DEBUG_TYPING // 		viewDocument.selection.isFake ? 'fake view selection' : 'fake DOM parent'
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-        }
-        else if (domTargetRanges.length) {
-            targetRanges = domTargetRanges.map(domRange => {
-                // Sometimes browser provides range that starts before editable node.
-                // We try to fall back to collapsed range at the valid end position.
-                // See https://github.com/ckeditor/ckeditor5/issues/14411.
-                // See https://github.com/ckeditor/ckeditor5/issues/14050.
-                let viewStart = view.domConverter.domPositionToView(domRange.startContainer, domRange.startOffset);
-                const viewEnd = view.domConverter.domPositionToView(domRange.endContainer, domRange.endOffset);
-                // When text replacement is enabled and browser tries to replace double space with dot, and space,
-                // but the first space is no longer where browser put it (it was moved to an attribute element),
-                // then we must extend the target range so it does not include a part of an inline filler.
-                if (viewStart && startsWithFiller(domRange.startContainer) && domRange.startOffset < INLINE_FILLER_LENGTH) {
-                    // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                    // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-                    // @if CK_DEBUG_TYPING // 		'%cTarget range starts in an inline filler - adjusting it',
-                    // @if CK_DEBUG_TYPING // 		'font-style: italic'
-                    // @if CK_DEBUG_TYPING // 	) );
-                    // @if CK_DEBUG_TYPING // }
-                    domEvent.preventDefault();
-                    let count = INLINE_FILLER_LENGTH - domRange.startOffset;
-                    viewStart = viewStart.getLastMatchingPosition(value => {
-                        // Ignore attribute and UI elements but stop on container elements.
-                        if (value.item.is('attributeElement') || value.item.is('uiElement')) {
-                            return true;
-                        }
-                        // Skip as many characters as inline filler was overlapped.
-                        if (value.item.is('$textProxy') && count--) {
-                            return true;
-                        }
-                        return false;
-                    }, { direction: 'backward', singleCharacters: true });
-                }
-                // Check if there is no an inline filler just after the target range.
-                if (isFollowedByInlineFiller(domRange.endContainer, domRange.endOffset)) {
-                    // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                    // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-                    // @if CK_DEBUG_TYPING // 		'%cTarget range ends just before an inline filler - prevent default behavior',
-                    // @if CK_DEBUG_TYPING // 		'font-style: italic'
-                    // @if CK_DEBUG_TYPING // 	) );
-                    // @if CK_DEBUG_TYPING // }
-                    domEvent.preventDefault();
-                }
-                if (viewStart) {
-                    return view.createRange(viewStart, viewEnd);
-                }
-                else if (viewEnd) {
-                    return view.createRange(viewEnd);
-                }
-            }).filter((range) => !!range);
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-            // @if CK_DEBUG_TYPING // 		'%cusing target ranges:',
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-            // @if CK_DEBUG_TYPING // 		targetRanges
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-        }
-        // For Android devices we use a fallback to the current DOM selection, Android modifies it according
-        // to the expected target ranges of input event.
-        else if (env.isAndroid) {
-            const domSelection = domEvent.target.ownerDocument.defaultView.getSelection();
-            targetRanges = Array.from(view.domConverter.domSelectionToView(domSelection).getRanges());
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.info( ..._buildLogMessage( this, 'InputObserver',
-            // @if CK_DEBUG_TYPING // 		'%cusing selection ranges:',
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-            // @if CK_DEBUG_TYPING // 		targetRanges
-            // @if CK_DEBUG_TYPING // 	) );
-            // @if CK_DEBUG_TYPING // }
-        }
-        // Android sometimes fires insertCompositionText with a new-line character at the end of the data
-        // instead of firing insertParagraph beforeInput event.
-        // Fire the correct type of beforeInput event and ignore the replaced fragment of text because
-        // it wants to replace "test" with "test\n".
-        // https://github.com/ckeditor/ckeditor5/issues/12368.
-        if (env.isAndroid && domEvent.inputType == 'insertCompositionText' && data && data.endsWith('\n')) {
-            this.fire(domEvent.type, domEvent, {
-                inputType: 'insertParagraph',
-                targetRanges: [view.createRange(targetRanges[0].end)]
-            });
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
-            return;
-        }
-        // Normalize the insertText data that includes new-line characters.
-        // https://github.com/ckeditor/ckeditor5/issues/2045.
-        if (['insertText', 'insertReplacementText'].includes(domEvent.inputType) && data && data.includes('\n')) {
-            // There might be a single new-line or double for new paragraph, but we translate
-            // it to paragraphs as it is our default action for enter handling.
-            const parts = data.split(/\n{1,2}/g);
-            let partTargetRanges = targetRanges;
-            // Handle all parts on our side as we rely on paragraph inserting and synchronously updated view selection.
-            domEvent.preventDefault();
-            for (let i = 0; i < parts.length; i++) {
-                const dataPart = parts[i];
-                if (dataPart != '') {
-                    this.fire(domEvent.type, domEvent, {
-                        data: dataPart,
-                        dataTransfer,
-                        targetRanges: partTargetRanges,
-                        inputType: domEvent.inputType,
-                        isComposing: domEvent.isComposing
-                    });
-                    // Use the result view selection so following events will be added one after another.
-                    partTargetRanges = [viewDocument.selection.getFirstRange()];
-                }
-                if (i + 1 < parts.length) {
-                    this.fire(domEvent.type, domEvent, {
-                        inputType: 'insertParagraph',
-                        targetRanges: partTargetRanges
-                    });
-                    // Use the result view selection so following events will be added one after another.
-                    partTargetRanges = [viewDocument.selection.getFirstRange()];
-                }
-            }
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.groupEnd();
-            // @if CK_DEBUG_TYPING // }
-            return;
-        }
-        // Fire the normalized beforeInput event.
-        this.fire(domEvent.type, domEvent, {
-            data,
-            dataTransfer,
-            targetRanges,
-            inputType: domEvent.inputType,
-            isComposing: domEvent.isComposing
-        });
-        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-        // @if CK_DEBUG_TYPING // 	console.groupEnd();
-        // @if CK_DEBUG_TYPING // }
-    }
-}
-/**
- * Returns `true` if there is an inline filler just after the position in DOM.
- * It walks up the DOM tree if the offset is at the end of the node.
- */
-function isFollowedByInlineFiller(node, offset) {
-    while (node.parentNode) {
-        if (isText(node)) {
-            if (offset != node.data.length) {
-                return false;
-            }
-        }
-        else {
-            if (offset != node.childNodes.length) {
-                return false;
-            }
-        }
-        offset = indexOf(node) + 1;
-        node = node.parentNode;
-        if (offset < node.childNodes.length && startsWithFiller(node.childNodes[offset])) {
-            return true;
-        }
-    }
-    return false;
-}