@ckeditor/ckeditor5-typing 0.0.0-internal-20241017.0

package/src/deletecommand.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing/deletecommand
+ */
+import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import type { DocumentSelection, Selection } from '@ckeditor/ckeditor5-engine';
+import ChangeBuffer from './utils/changebuffer.js';
+/**
+ * The delete command. Used by the {@link module:typing/delete~Delete delete feature} to handle the <kbd>Delete</kbd> and
+ * <kbd>Backspace</kbd> keys.
+ */
+export default class DeleteCommand extends Command {
+    /**
+     * The directionality of the delete describing in what direction it should
+     * consume the content when the selection is collapsed.
+     */
+    readonly direction: 'forward' | 'backward';
+    /**
+     * Delete's change buffer used to group subsequent changes into batches.
+     */
+    private readonly _buffer;
+    /**
+     * Creates an instance of the command.
+     *
+     * @param direction The directionality of the delete describing in what direction it
+     * should consume the content when the selection is collapsed.
+     */
+    constructor(editor: Editor, direction: 'forward' | 'backward');
+    /**
+     * The current change buffer.
+     */
+    get buffer(): ChangeBuffer;
+    /**
+     * Executes the delete command. Depending on whether the selection is collapsed or not, deletes its content
+     * or a piece of content in the {@link #direction defined direction}.
+     *
+     * @fires execute
+     * @param options The command options.
+     * @param options.unit See {@link module:engine/model/utils/modifyselection~modifySelection}'s options.
+     * @param options.sequence A number describing which subsequent delete event it is without the key being released.
+     * See the {@link module:engine/view/document~Document#event:delete} event data.
+     * @param options.selection Selection to remove. If not set, current model selection will be used.
+     */
+    execute(options?: {
+        unit?: 'character' | 'codePoint' | 'word';
+        sequence?: number;
+        selection?: Selection | DocumentSelection;
+    }): void;
+    /**
+     * If the user keeps <kbd>Backspace</kbd> or <kbd>Delete</kbd> key pressed, the content of the current
+     * editable will be cleared. However, this will not yet lead to resetting the remaining block to a paragraph
+     * (which happens e.g. when the user does <kbd>Ctrl</kbd> + <kbd>A</kbd>, <kbd>Backspace</kbd>).
+     *
+     * But, if the user pressed the key in an empty editable for the first time,
+     * we want to replace the entire content with a paragraph if:
+     *
+     * * the current limit element is empty,
+     * * the paragraph is allowed in the limit element,
+     * * the limit doesn't already have a paragraph inside.
+     *
+     * See https://github.com/ckeditor/ckeditor5-typing/issues/61.
+     *
+     * @param sequence A number describing which subsequent delete event it is without the key being released.
+     */
+    private _shouldEntireContentBeReplacedWithParagraph;
+    /**
+     * The entire content is replaced with the paragraph. Selection is moved inside the paragraph.
+     *
+     * @param writer The model writer.
+     */
+    private _replaceEntireContentWithParagraph;
+    /**
+     * Checks if the selection is inside an empty element that is the first child of the limit element
+     * and should be replaced with a paragraph.
+     *
+     * @param selection The selection.
+     * @param sequence A number describing which subsequent delete event it is without the key being released.
+     */
+    private _shouldReplaceFirstBlockWithParagraph;
+}

package/src/deletecommand.js

@@ -0,0 +1,201 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing/deletecommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+import { count } from '@ckeditor/ckeditor5-utils';
+import ChangeBuffer from './utils/changebuffer.js';
+/**
+ * The delete command. Used by the {@link module:typing/delete~Delete delete feature} to handle the <kbd>Delete</kbd> and
+ * <kbd>Backspace</kbd> keys.
+ */
+export default class DeleteCommand extends Command {
+    /**
+     * Creates an instance of the command.
+     *
+     * @param direction The directionality of the delete describing in what direction it
+     * should consume the content when the selection is collapsed.
+     */
+    constructor(editor, direction) {
+        super(editor);
+        this.direction = direction;
+        this._buffer = new ChangeBuffer(editor.model, editor.config.get('typing.undoStep'));
+        // Since this command may execute on different selectable than selection, it should be checked directly in execute block.
+        this._isEnabledBasedOnSelection = false;
+    }
+    /**
+     * The current change buffer.
+     */
+    get buffer() {
+        return this._buffer;
+    }
+    /**
+     * Executes the delete command. Depending on whether the selection is collapsed or not, deletes its content
+     * or a piece of content in the {@link #direction defined direction}.
+     *
+     * @fires execute
+     * @param options The command options.
+     * @param options.unit See {@link module:engine/model/utils/modifyselection~modifySelection}'s options.
+     * @param options.sequence A number describing which subsequent delete event it is without the key being released.
+     * See the {@link module:engine/view/document~Document#event:delete} event data.
+     * @param options.selection Selection to remove. If not set, current model selection will be used.
+     */
+    execute(options = {}) {
+        const model = this.editor.model;
+        const doc = model.document;
+        model.enqueueChange(this._buffer.batch, writer => {
+            this._buffer.lock();
+            const selection = writer.createSelection(options.selection || doc.selection);
+            // Don't execute command when selection is in non-editable place.
+            if (!model.canEditAt(selection)) {
+                return;
+            }
+            const sequence = options.sequence || 1;
+            // Do not replace the whole selected content if selection was collapsed.
+            // This prevents such situation:
+            //
+            // <h1></h1><p>[]</p>	-->  <h1>[</h1><p>]</p> 		-->  <p></p>
+            // starting content		-->   after `modifySelection`	-->  after `deleteContent`.
+            const doNotResetEntireContent = selection.isCollapsed;
+            // Try to extend the selection in the specified direction.
+            if (selection.isCollapsed) {
+                model.modifySelection(selection, {
+                    direction: this.direction,
+                    unit: options.unit,
+                    treatEmojiAsSingleUnit: true
+                });
+            }
+            // Check if deleting in an empty editor. See #61.
+            if (this._shouldEntireContentBeReplacedWithParagraph(sequence)) {
+                this._replaceEntireContentWithParagraph(writer);
+                return;
+            }
+            // Check if deleting in the first empty block.
+            // See https://github.com/ckeditor/ckeditor5/issues/8137.
+            if (this._shouldReplaceFirstBlockWithParagraph(selection, sequence)) {
+                this.editor.execute('paragraph', { selection });
+                return;
+            }
+            // If selection is still collapsed, then there's nothing to delete.
+            if (selection.isCollapsed) {
+                return;
+            }
+            let changeCount = 0;
+            selection.getFirstRange().getMinimalFlatRanges().forEach(range => {
+                changeCount += count(range.getWalker({ singleCharacters: true, ignoreElementEnd: true, shallow: true }));
+            });
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.log( '%c[DeleteCommand]%c Delete content',
+            // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green;', '',
+            // @if CK_DEBUG_TYPING // 		`[${ selection.getFirstPosition()!.path }]-[${ selection.getLastPosition()!.path }]`, options
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+            model.deleteContent(selection, {
+                doNotResetEntireContent,
+                direction: this.direction
+            });
+            this._buffer.input(changeCount);
+            writer.setSelection(selection);
+            this._buffer.unlock();
+        });
+    }
+    /**
+     * If the user keeps <kbd>Backspace</kbd> or <kbd>Delete</kbd> key pressed, the content of the current
+     * editable will be cleared. However, this will not yet lead to resetting the remaining block to a paragraph
+     * (which happens e.g. when the user does <kbd>Ctrl</kbd> + <kbd>A</kbd>, <kbd>Backspace</kbd>).
+     *
+     * But, if the user pressed the key in an empty editable for the first time,
+     * we want to replace the entire content with a paragraph if:
+     *
+     * * the current limit element is empty,
+     * * the paragraph is allowed in the limit element,
+     * * the limit doesn't already have a paragraph inside.
+     *
+     * See https://github.com/ckeditor/ckeditor5-typing/issues/61.
+     *
+     * @param sequence A number describing which subsequent delete event it is without the key being released.
+     */
+    _shouldEntireContentBeReplacedWithParagraph(sequence) {
+        // Does nothing if user pressed and held the "Backspace" or "Delete" key.
+        if (sequence > 1) {
+            return false;
+        }
+        const model = this.editor.model;
+        const doc = model.document;
+        const selection = doc.selection;
+        const limitElement = model.schema.getLimitElement(selection);
+        // If a collapsed selection contains the whole content it means that the content is empty
+        // (from the user perspective).
+        const limitElementIsEmpty = selection.isCollapsed && selection.containsEntireContent(limitElement);
+        if (!limitElementIsEmpty) {
+            return false;
+        }
+        if (!model.schema.checkChild(limitElement, 'paragraph')) {
+            return false;
+        }
+        const limitElementFirstChild = limitElement.getChild(0);
+        // Does nothing if the limit element already contains only a paragraph.
+        // We ignore the case when paragraph might have some inline elements (<p><inlineWidget>[]</inlineWidget></p>)
+        // because we don't support such cases yet and it's unclear whether inlineWidget shouldn't be a limit itself.
+        if (limitElementFirstChild && limitElementFirstChild.is('element', 'paragraph')) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * The entire content is replaced with the paragraph. Selection is moved inside the paragraph.
+     *
+     * @param writer The model writer.
+     */
+    _replaceEntireContentWithParagraph(writer) {
+        const model = this.editor.model;
+        const doc = model.document;
+        const selection = doc.selection;
+        const limitElement = model.schema.getLimitElement(selection);
+        const paragraph = writer.createElement('paragraph');
+        writer.remove(writer.createRangeIn(limitElement));
+        writer.insert(paragraph, limitElement);
+        writer.setSelection(paragraph, 0);
+    }
+    /**
+     * Checks if the selection is inside an empty element that is the first child of the limit element
+     * and should be replaced with a paragraph.
+     *
+     * @param selection The selection.
+     * @param sequence A number describing which subsequent delete event it is without the key being released.
+     */
+    _shouldReplaceFirstBlockWithParagraph(selection, sequence) {
+        const model = this.editor.model;
+        // Does nothing if user pressed and held the "Backspace" key or it was a "Delete" button.
+        if (sequence > 1 || this.direction != 'backward') {
+            return false;
+        }
+        if (!selection.isCollapsed) {
+            return false;
+        }
+        const position = selection.getFirstPosition();
+        const limitElement = model.schema.getLimitElement(position);
+        const limitElementFirstChild = limitElement.getChild(0);
+        // Only elements that are direct children of the limit element can be replaced.
+        // Unwrapping from a block quote should be handled in a dedicated feature.
+        if (position.parent != limitElementFirstChild) {
+            return false;
+        }
+        // A block should be replaced only if it was empty.
+        if (!selection.containsEntireContent(limitElementFirstChild)) {
+            return false;
+        }
+        // Replace with a paragraph only if it's allowed there.
+        if (!model.schema.checkChild(limitElement, 'paragraph')) {
+            return false;
+        }
+        // Does nothing if the limit element already contains only a paragraph.
+        if (limitElementFirstChild.name == 'paragraph') {
+            return false;
+        }
+        return true;
+    }
+}

package/src/deleteobserver.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { DomEventData, Observer, type BubblingEvent, type ViewDocumentSelection, type ViewSelection, type EditingView } from '@ckeditor/ckeditor5-engine';
+/**
+ * Delete observer introduces the {@link module:engine/view/document~Document#event:delete} event.
+ */
+export default class DeleteObserver extends Observer {
+    /**
+     * @inheritDoc
+     */
+    constructor(view: EditingView);
+    /**
+     * @inheritDoc
+     */
+    observe(): void;
+    /**
+     * @inheritDoc
+     */
+    stopObserving(): void;
+}
+/**
+ * Event fired when the user tries to delete content (e.g. presses <kbd>Delete</kbd> or <kbd>Backspace</kbd>).
+ *
+ * Note: This event is fired by the {@link module:typing/deleteobserver~DeleteObserver delete observer}
+ * (usually registered by the {@link module:typing/delete~Delete delete feature}).
+ *
+ * @eventName module:engine/view/document~Document#delete
+ * @param data The event data.
+ */
+export type ViewDocumentDeleteEvent = BubblingEvent<{
+    name: 'delete';
+    args: [data: DeleteEventData];
+}>;
+export interface DeleteEventData extends DomEventData<InputEvent> {
+    /**
+     * The direction in which the deletion should happen.
+     */
+    direction: 'backward' | 'forward';
+    /**
+     * The "amount" of content that should be deleted.
+     */
+    unit: 'selection' | 'codePoint' | 'character' | 'word';
+    /**
+     * A number describing which subsequent delete event it is without the key being released.
+     * If it's 2 or more it means that the key was pressed and hold.
+     */
+    sequence: number;
+    /**
+     * View selection which content should be removed. If not set,
+     * current selection should be used.
+     */
+    selectionToRemove?: ViewSelection | ViewDocumentSelection;
+}

package/src/deleteobserver.js

@@ -0,0 +1,260 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing/deleteobserver
+ */
+import { env, keyCodes, isInsideCombinedSymbol, isInsideEmojiSequence, isInsideSurrogatePair } from '@ckeditor/ckeditor5-utils';
+import { BubblingEventInfo, DomEventData, Observer } from '@ckeditor/ckeditor5-engine';
+const DELETE_CHARACTER = 'character';
+const DELETE_WORD = 'word';
+const DELETE_CODE_POINT = 'codePoint';
+const DELETE_SELECTION = 'selection';
+const DELETE_BACKWARD = 'backward';
+const DELETE_FORWARD = 'forward';
+const DELETE_EVENT_TYPES = {
+    // --------------------------------------- Backward delete types -----------------------------------------------------
+    // This happens in Safari on Mac when some content is selected and Ctrl + K is pressed.
+    deleteContent: {
+        unit: DELETE_SELECTION,
+        // According to the Input Events Level 2 spec, this delete type has no direction
+        // but to keep things simple, let's default to backward.
+        direction: DELETE_BACKWARD
+    },
+    // Chrome and Safari on Mac: Backspace or Ctrl + H
+    deleteContentBackward: {
+        // This kind of deletions must be done on the code point-level instead of target range provided by the DOM beforeinput event.
+        // Take for instance "👨‍👩‍👧‍👧", it equals:
+        //
+        //	* [ "👨", "ZERO WIDTH JOINER", "👩", "ZERO WIDTH JOINER", "👧", "ZERO WIDTH JOINER", "👧" ]
+        //	* or simply "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}"
+        //
+        // The range provided by the browser would cause the entire multi-byte grapheme to disappear while the user
+        // intention when deleting backwards ("👨‍👩‍👧‍👧[]", then backspace) is gradual "decomposition" (first to "👨‍👩‍👧‍[]",
+        // then to "👨‍👩‍[]", etc.).
+        //
+        //	* "👨‍👩‍👧‍👧[]" + backward delete (by code point)  -> results in "👨‍👩‍👧[]", removed the last "👧" 👍
+        //	* "👨‍👩‍👧‍👧[]" + backward delete (by character)  -> results in "[]", removed the whole grapheme 👎
+        //
+        // Deleting by code-point is simply a better UX. See "deleteContentForward" to learn more.
+        unit: DELETE_CODE_POINT,
+        direction: DELETE_BACKWARD
+    },
+    // On Mac: Option + Backspace.
+    // On iOS: Hold the backspace for a while and the whole words will start to disappear.
+    deleteWordBackward: {
+        unit: DELETE_WORD,
+        direction: DELETE_BACKWARD
+    },
+    // Safari on Mac: Cmd + Backspace
+    deleteHardLineBackward: {
+        unit: DELETE_SELECTION,
+        direction: DELETE_BACKWARD
+    },
+    // Chrome on Mac: Cmd + Backspace.
+    deleteSoftLineBackward: {
+        unit: DELETE_SELECTION,
+        direction: DELETE_BACKWARD
+    },
+    // --------------------------------------- Forward delete types -----------------------------------------------------
+    // Chrome on Mac: Fn + Backspace or Ctrl + D
+    // Safari on Mac: Ctrl + K or Ctrl + D
+    deleteContentForward: {
+        // Unlike backward delete, this delete must be performed by character instead of by code point, which
+        // provides the best UX for working with accented letters.
+        // Take, for example "b̂" ("\u0062\u0302", or [ "LATIN SMALL LETTER B", "COMBINING CIRCUMFLEX ACCENT" ]):
+        //
+        //	* "b̂[]" + backward delete (by code point)  -> results in "b[]", removed the combining mark 👍
+        //	* "[]b̂" + forward delete (by code point)   -> results in "[]^", a bare combining mark does that not make sense when alone 👎
+        //	* "[]b̂" + forward delete (by character)    -> results in "[]", removed both "b" and the combining mark 👍
+        //
+        // See: "deleteContentBackward" to learn more.
+        unit: DELETE_CHARACTER,
+        direction: DELETE_FORWARD
+    },
+    // On Mac: Fn + Option + Backspace.
+    deleteWordForward: {
+        unit: DELETE_WORD,
+        direction: DELETE_FORWARD
+    },
+    // Chrome on Mac: Ctrl + K (you have to disable the Link plugin first, though, because it uses the same keystroke)
+    // This is weird that it does not work in Safari on Mac despite being listed in the official shortcuts listing
+    // on Apple's webpage.
+    deleteHardLineForward: {
+        unit: DELETE_SELECTION,
+        direction: DELETE_FORWARD
+    },
+    // At this moment there is no known way to trigger this event type but let's keep it for the symmetry with
+    // deleteSoftLineBackward.
+    deleteSoftLineForward: {
+        unit: DELETE_SELECTION,
+        direction: DELETE_FORWARD
+    }
+};
+/**
+ * Delete observer introduces the {@link module:engine/view/document~Document#event:delete} event.
+ */
+export default class DeleteObserver extends Observer {
+    /**
+     * @inheritDoc
+     */
+    constructor(view) {
+        super(view);
+        const document = view.document;
+        // It matters how many subsequent deletions were made, e.g. when the backspace key was pressed and held
+        // by the user for some time. For instance, if such scenario ocurred and the heading the selection was
+        // anchored to was the only content of the editor, it will not be converted into a paragraph (the user
+        // wanted to clean it up, not remove it, it's about UX). Check out the DeleteCommand implementation to learn more.
+        //
+        // Fun fact: Safari on Mac won't fire beforeinput for backspace in an empty heading (only content).
+        let sequence = 0;
+        document.on('keydown', () => {
+            sequence++;
+        });
+        document.on('keyup', () => {
+            sequence = 0;
+        });
+        document.on('beforeinput', (evt, data) => {
+            if (!this.isEnabled) {
+                return;
+            }
+            const { targetRanges, domEvent, inputType } = data;
+            const deleteEventSpec = DELETE_EVENT_TYPES[inputType];
+            if (!deleteEventSpec) {
+                return;
+            }
+            const deleteData = {
+                direction: deleteEventSpec.direction,
+                unit: deleteEventSpec.unit,
+                sequence
+            };
+            if (deleteData.unit == DELETE_SELECTION) {
+                deleteData.selectionToRemove = view.createSelection(targetRanges[0]);
+            }
+            // The default deletion unit for deleteContentBackward is a single code point
+            // but if the browser provides a wider target range then we should use it.
+            if (inputType === 'deleteContentBackward') {
+                // On Android, deleteContentBackward has sequence 1 by default.
+                if (env.isAndroid) {
+                    deleteData.sequence = 1;
+                }
+                // The beforeInput event wants more than a single character to be removed.
+                if (shouldUseTargetRanges(targetRanges)) {
+                    deleteData.unit = DELETE_SELECTION;
+                    deleteData.selectionToRemove = view.createSelection(targetRanges);
+                }
+            }
+            const eventInfo = new BubblingEventInfo(document, 'delete', targetRanges[0]);
+            document.fire(eventInfo, new DomEventData(view, domEvent, deleteData));
+            // Stop the beforeinput event if `delete` event was stopped.
+            // https://github.com/ckeditor/ckeditor5/issues/753
+            if (eventInfo.stop.called) {
+                evt.stop();
+            }
+        });
+        // TODO: to be removed when https://bugs.chromium.org/p/chromium/issues/detail?id=1365311 is solved.
+        if (env.isBlink) {
+            enableChromeWorkaround(this);
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    observe() { }
+    /**
+     * @inheritDoc
+     */
+    stopObserving() { }
+}
+/**
+ * Enables workaround for the issue https://github.com/ckeditor/ckeditor5/issues/11904.
+ */
+function enableChromeWorkaround(observer) {
+    const view = observer.view;
+    const document = view.document;
+    let pressedKeyCode = null;
+    let beforeInputReceived = false;
+    document.on('keydown', (evt, { keyCode }) => {
+        pressedKeyCode = keyCode;
+        beforeInputReceived = false;
+    });
+    document.on('keyup', (evt, { keyCode, domEvent }) => {
+        const selection = document.selection;
+        const shouldFireDeleteEvent = observer.isEnabled &&
+            keyCode == pressedKeyCode &&
+            isDeleteKeyCode(keyCode) &&
+            !selection.isCollapsed &&
+            !beforeInputReceived;
+        pressedKeyCode = null;
+        if (shouldFireDeleteEvent) {
+            const targetRange = selection.getFirstRange();
+            const eventInfo = new BubblingEventInfo(document, 'delete', targetRange);
+            const deleteData = {
+                unit: DELETE_SELECTION,
+                direction: getDeleteDirection(keyCode),
+                selectionToRemove: selection
+            };
+            document.fire(eventInfo, new DomEventData(view, domEvent, deleteData));
+        }
+    });
+    document.on('beforeinput', (evt, { inputType }) => {
+        const deleteEventSpec = DELETE_EVENT_TYPES[inputType];
+        const isMatchingBeforeInput = isDeleteKeyCode(pressedKeyCode) &&
+            deleteEventSpec &&
+            deleteEventSpec.direction == getDeleteDirection(pressedKeyCode);
+        if (isMatchingBeforeInput) {
+            beforeInputReceived = true;
+        }
+    }, { priority: 'high' });
+    document.on('beforeinput', (evt, { inputType, data }) => {
+        const shouldIgnoreBeforeInput = pressedKeyCode == keyCodes.delete &&
+            inputType == 'insertText' &&
+            data == '\x7f'; // Delete character :P
+        if (shouldIgnoreBeforeInput) {
+            evt.stop();
+        }
+    }, { priority: 'high' });
+    function isDeleteKeyCode(keyCode) {
+        return keyCode == keyCodes.backspace || keyCode == keyCodes.delete;
+    }
+    function getDeleteDirection(keyCode) {
+        return keyCode == keyCodes.backspace ? DELETE_BACKWARD : DELETE_FORWARD;
+    }
+}
+/**
+ * Verifies whether the given target ranges cover more than a single character and should be used instead of a single code-point deletion.
+ */
+function shouldUseTargetRanges(targetRanges) {
+    // The collapsed target range could happen for example while deleting inside an inline filler
+    // (it's mapped to collapsed position before an inline filler).
+    if (targetRanges.length != 1 || targetRanges[0].isCollapsed) {
+        return false;
+    }
+    const walker = targetRanges[0].getWalker({
+        direction: 'backward',
+        singleCharacters: true,
+        ignoreElementEnd: true
+    });
+    let count = 0;
+    for (const { nextPosition, item } of walker) {
+        if (nextPosition.parent.is('$text')) {
+            const data = nextPosition.parent.data;
+            const offset = nextPosition.offset;
+            // Count combined symbols and emoji sequences as a single character.
+            if (isInsideSurrogatePair(data, offset) ||
+                isInsideCombinedSymbol(data, offset) ||
+                isInsideEmojiSequence(data, offset)) {
+                continue;
+            }
+            count++;
+        }
+        else if (item.is('containerElement') || item.is('emptyElement')) {
+            count++;
+        }
+        if (count > 1) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing
+ */
+export { default as Typing } from './typing.js';
+export { default as Input } from './input.js';
+export { default as Delete } from './delete.js';
+export { default as TextWatcher } from './textwatcher.js';
+export { default as TwoStepCaretMovement } from './twostepcaretmovement.js';
+export { default as TextTransformation } from './texttransformation.js';
+export type { TextTransformationConfig } from './typingconfig.js';
+export { default as inlineHighlight } from './utils/inlinehighlight.js';
+export { default as findAttributeRange, findAttributeRangeBound } from './utils/findattributerange.js';
+export { default as getLastTextLine, type LastTextLineData } from './utils/getlasttextline.js';
+export { default as InsertTextCommand, type InsertTextCommandExecuteEvent } from './inserttextcommand.js';
+export type { default as DeleteCommand } from './deletecommand.js';
+export type { TypingConfig } from './typingconfig.js';
+export type { ViewDocumentDeleteEvent } from './deleteobserver.js';
+export type { ViewDocumentInsertTextEvent, InsertTextEventData } from './inserttextobserver.js';
+export type { TextWatcherMatchedEvent } from './textwatcher.js';
+export type { TextWatcherMatchedDataEvent } from './textwatcher.js';
+import './augmentation.js';

package/src/index.js

@@ -0,0 +1,18 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing
+ */
+export { default as Typing } from './typing.js';
+export { default as Input } from './input.js';
+export { default as Delete } from './delete.js';
+export { default as TextWatcher } from './textwatcher.js';
+export { default as TwoStepCaretMovement } from './twostepcaretmovement.js';
+export { default as TextTransformation } from './texttransformation.js';
+export { default as inlineHighlight } from './utils/inlinehighlight.js';
+export { default as findAttributeRange, findAttributeRangeBound } from './utils/findattributerange.js';
+export { default as getLastTextLine } from './utils/getlasttextline.js';
+export { default as InsertTextCommand } from './inserttextcommand.js';
+import './augmentation.js';

package/src/input.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module typing/input
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * Handles text input coming from the keyboard or other input methods.
+ */
+export default class Input extends Plugin {
+    /**
+     * The queue of `insertText` command executions that are waiting for the DOM to get updated after beforeinput event.
+     */
+    private _compositionQueue;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "Input";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+}