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

package/src/model/utils/insertobject.js

@@ -1,135 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { CKEditorError, first } from '@ckeditor/ckeditor5-utils';
-/**
- * Inserts an {@glink framework/deep-dive/schema#object-elements object element} at a specific position in the editor content.
- *
- * **Note:** Use {@link module:engine/model/model~Model#insertObject} instead of this function.
- * This function is only exposed to be reusable in algorithms which change the {@link module:engine/model/model~Model#insertObject}
- * method's behavior.
- *
- * **Note**: For more documentation and examples, see {@link module:engine/model/model~Model#insertObject}.
- *
- * @param model The model in context of which the insertion should be performed.
- * @param object An object to be inserted into the model document.
- * @param selectable A selectable where the content should be inserted. If not specified, the current
- * {@link module:engine/model/document~ModelDocument#selection document selection} will be used instead.
- * @param options Additional options.
- * @param options.findOptimalPosition An option that, when set, adjusts the insertion position (relative to
- * `selectable` and `placeOrOffset`) so that the content of `selectable` is not split upon insertion (a.k.a. non-destructive insertion).
- * * When `'auto'`, the algorithm will decide whether to insert the object before or after `selectable` to avoid content splitting.
- * * When `'before'`, the closest position before `selectable` will be used that will not result in content splitting.
- * * When `'after'`, the closest position after `selectable` will be used that will not result in content splitting.
- *
- * Note that this option works only for block objects. Inline objects are inserted into text and do not split blocks.
- * @param options.setSelection An option that, when set, moves the
- * {@link module:engine/model/document~ModelDocument#selection document selection} after inserting the object.
- * * When `'on'`, the document selection will be set on the inserted object.
- * * When `'after'`, the document selection will move to the closest text node after the inserted object. If there is no
- * such text node, a paragraph will be created and the document selection will be moved inside it.
- * @returns A range which contains all the performed changes. This is a range that, if removed,
- * would return the model to the state before the insertion. If no changes were preformed by `insertObject()`, returns a range collapsed
- * at the insertion position.
- */
-export function insertObject(model, object, selectable, options = {}) {
-    if (!model.schema.isObject(object)) {
-        /**
-         * Tried to insert an element with {@link module:engine/model/utils/insertobject insertObject()} function
-         * that is not defined as an object in schema.
-         * See {@link module:engine/model/schema~ModelSchemaItemDefinition#isObject `SchemaItemDefinition`}.
-         * If you want to insert content that is not an object you might want to use
-         * {@link module:engine/model/utils/insertcontent insertContent()} function.
-         * @error insertobject-element-not-an-object
-         */
-        throw new CKEditorError('insertobject-element-not-an-object', model, { object });
-    }
-    // Normalize selectable to a selection instance.
-    const originalSelection = selectable ? selectable : model.document.selection;
-    // Adjust the insertion selection.
-    let insertionSelection = originalSelection;
-    if (options.findOptimalPosition && model.schema.isBlock(object)) {
-        insertionSelection = model.createSelection(model.schema.findOptimalInsertionRange(originalSelection, options.findOptimalPosition));
-    }
-    // Collect attributes to be copied on the inserted object.
-    const firstSelectedBlock = first(originalSelection.getSelectedBlocks());
-    const attributesToCopy = {};
-    if (firstSelectedBlock) {
-        Object.assign(attributesToCopy, model.schema.getAttributesWithProperty(firstSelectedBlock, 'copyOnReplace', true));
-    }
-    return model.change(writer => {
-        // Remove the selected content to find out what the parent of the inserted object would be.
-        // It would be removed inside model.insertContent() anyway.
-        if (!insertionSelection.isCollapsed) {
-            model.deleteContent(insertionSelection, { doNotAutoparagraph: true });
-        }
-        let elementToInsert = object;
-        const insertionPositionParent = insertionSelection.anchor.parent;
-        const context = model.schema.createContext(insertionPositionParent);
-        // Auto-paragraphing of an inline objects.
-        if (!model.schema.checkChild(context, object) &&
-            model.schema.checkChild(context, 'paragraph') &&
-            model.schema.checkChild(context.push('paragraph'), object)) {
-            elementToInsert = writer.createElement('paragraph');
-            writer.insert(object, elementToInsert);
-        }
-        // Apply attributes that are allowed on the inserted object (or paragraph if autoparagraphed).
-        model.schema.setAllowedAttributes(elementToInsert, attributesToCopy, writer);
-        // Insert the prepared content at the optionally adjusted selection.
-        const affectedRange = model.insertContent(elementToInsert, insertionSelection);
-        // Nothing got inserted.
-        if (affectedRange.isCollapsed) {
-            return affectedRange;
-        }
-        if (options.setSelection) {
-            updateSelection(writer, object, options.setSelection, attributesToCopy);
-        }
-        return affectedRange;
-    });
-}
-/**
- * Updates document selection based on given `place` parameter in relation to `contextElement` element.
- *
- * @param writer An instance of the model writer.
- * @param contextElement An element to set the attributes on.
- * @param place The place where selection should be set in relation to the `contextElement` element.
- * Value `on` will set selection on the passed `contextElement`. Value `after` will set selection after `contextElement`.
- * @param attributes Attributes keys and values to set on a paragraph that this function can create when
- * `place` parameter is equal to `after` but there is no element with `$text` node to set selection in.
- */
-function updateSelection(writer, contextElement, place, paragraphAttributes) {
-    const model = writer.model;
-    if (place == 'on') {
-        writer.setSelection(contextElement, 'on');
-        return;
-    }
-    if (place != 'after') {
-        /**
-         * The unsupported `options.setSelection` parameter was passed
-         * to the {@link module:engine/model/utils/insertobject insertObject()} function.
-         * Check the {@link module:engine/model/utils/insertobject insertObject()} API documentation for allowed
-         * `options.setSelection` parameter values.
-         *
-         * @error insertobject-invalid-place-parameter-value
-         */
-        throw new CKEditorError('insertobject-invalid-place-parameter-value', model);
-    }
-    let nextElement = contextElement.nextSibling;
-    if (model.schema.isInline(contextElement)) {
-        writer.setSelection(contextElement, 'after');
-        return;
-    }
-    // Check whether an element next to the inserted element is defined and can contain a text.
-    const canSetSelection = nextElement && model.schema.checkChild(nextElement, '$text');
-    // If the element is missing, but a paragraph could be inserted next to the element, let's add it.
-    if (!canSetSelection && model.schema.checkChild(contextElement.parent, 'paragraph')) {
-        nextElement = writer.createElement('paragraph');
-        model.schema.setAllowedAttributes(nextElement, paragraphAttributes, writer);
-        model.insertContent(nextElement, writer.createPositionAfter(contextElement));
-    }
-    // Put the selection inside the element, at the beginning.
-    if (nextElement) {
-        writer.setSelection(nextElement, 0);
-    }
-}

package/src/model/utils/modifyselection.js

@@ -1,187 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/model/utils/modifyselection
- */
-import { ModelDocumentSelection } from '../documentselection.js';
-import { ModelPosition } from '../position.js';
-import { ModelRange } from '../range.js';
-import { ModelTreeWalker } from '../treewalker.js';
-import { isInsideSurrogatePair, isInsideCombinedSymbol, isInsideEmojiSequence } from '@ckeditor/ckeditor5-utils';
-const wordBoundaryCharacters = ' ,.?!:;"-()';
-/**
- * Modifies the selection. Currently, the supported modifications are:
- *
- * * Extending. The selection focus is moved in the specified `options.direction` with a step specified in `options.unit`.
- * Possible values for `unit` are:
- *  * `'character'` (default) - moves selection by one user-perceived character. In most cases this means moving by one
- *  character in `String` sense. However, unicode also defines "combing marks". These are special symbols, that combines
- *  with a symbol before it ("base character") to create one user-perceived character. For example, `q̣̇` is a normal
- *  letter `q` with two "combining marks": upper dot (`Ux0307`) and lower dot (`Ux0323`). For most actions, i.e. extending
- *  selection by one position, it is correct to include both "base character" and all of it's "combining marks". That is
- *  why `'character'` value is most natural and common method of modifying selection.
- *  * `'codePoint'` - moves selection by one unicode code point. In contrary to, `'character'` unit, this will insert
- *  selection between "base character" and "combining mark", because "combining marks" have their own unicode code points.
- *  However, for technical reasons, unicode code points with values above `UxFFFF` are represented in native `String` by
- *  two characters, called "surrogate pairs". Halves of "surrogate pairs" have a meaning only when placed next to each other.
- *  For example `𨭎` is represented in `String` by `\uD862\uDF4E`. Both `\uD862` and `\uDF4E` do not have any meaning
- *  outside the pair (are rendered as ? when alone). Position between them would be incorrect. In this case, selection
- *  extension will include whole "surrogate pair".
- *  * `'word'` - moves selection by a whole word.
- *
- * **Note:** if you extend a forward selection in a backward direction you will in fact shrink it.
- *
- * **Note:** Use {@link module:engine/model/model~Model#modifySelection} instead of this function.
- * This function is only exposed to be reusable in algorithms
- * which change the {@link module:engine/model/model~Model#modifySelection}
- * method's behavior.
- *
- * @param model The model in context of which the selection modification should be performed.
- * @param selection The selection to modify.
- * @param options.direction The direction in which the selection should be modified. Default 'forward'.
- * @param options.unit The unit by which selection should be modified. Default 'character'.
- * @param options.treatEmojiAsSingleUnit Whether multi-characer emoji sequences should be handled as single unit.
- * @internal
- */
-export function modifySelection(model, selection, options = {}) {
-    const schema = model.schema;
-    const isForward = options.direction != 'backward';
-    const unit = options.unit ? options.unit : 'character';
-    const treatEmojiAsSingleUnit = !!options.treatEmojiAsSingleUnit;
-    const focus = selection.focus;
-    const walker = new ModelTreeWalker({
-        boundaries: getSearchRange(focus, isForward),
-        singleCharacters: true,
-        direction: isForward ? 'forward' : 'backward'
-    });
-    const data = { walker, schema, isForward, unit, treatEmojiAsSingleUnit };
-    let next;
-    while ((next = walker.next())) {
-        if (next.done) {
-            return;
-        }
-        const position = tryExtendingTo(data, next.value);
-        if (position) {
-            if (selection instanceof ModelDocumentSelection) {
-                model.change(writer => {
-                    writer.setSelectionFocus(position);
-                });
-            }
-            else {
-                selection.setFocus(position);
-            }
-            return;
-        }
-    }
-}
-/**
- * Checks whether the selection can be extended to the the walker's next value (next position).
- */
-function tryExtendingTo(data, value) {
-    const { isForward, walker, unit, schema, treatEmojiAsSingleUnit } = data;
-    const { type, item, nextPosition } = value;
-    // If found text, we can certainly put the focus in it. Let's just find a correct position
-    // based on the unit.
-    if (type == 'text') {
-        if (data.unit === 'word') {
-            return getCorrectWordBreakPosition(walker, isForward);
-        }
-        return getCorrectPosition(walker, unit, treatEmojiAsSingleUnit);
-    }
-    // Entering an element.
-    if (type == (isForward ? 'elementStart' : 'elementEnd')) {
-        // If it's a selectable, we can select it now.
-        if (schema.isSelectable(item)) {
-            return ModelPosition._createAt(item, isForward ? 'after' : 'before');
-        }
-        // If text allowed on this position, extend to this place.
-        if (schema.checkChild(nextPosition, '$text')) {
-            return nextPosition;
-        }
-    }
-    // Leaving an element.
-    else {
-        // If leaving a limit element, stop.
-        if (schema.isLimit(item)) {
-            // NOTE: Fast-forward the walker until the end.
-            walker.skip(() => true);
-            return;
-        }
-        // If text allowed on this position, extend to this place.
-        if (schema.checkChild(nextPosition, '$text')) {
-            return nextPosition;
-        }
-    }
-}
-/**
- * Finds a correct position by walking in a text node and checking whether selection can be extended to given position
- * or should be extended further.
- */
-function getCorrectPosition(walker, unit, treatEmojiAsSingleUnit) {
-    const textNode = walker.position.textNode;
-    if (textNode) {
-        const data = textNode.data;
-        let offset = walker.position.offset - textNode.startOffset;
-        while (isInsideSurrogatePair(data, offset) ||
-            (unit == 'character' && isInsideCombinedSymbol(data, offset)) ||
-            (treatEmojiAsSingleUnit && isInsideEmojiSequence(data, offset))) {
-            walker.next();
-            offset = walker.position.offset - textNode.startOffset;
-        }
-    }
-    return walker.position;
-}
-/**
- * Finds a correct position of a word break by walking in a text node and checking whether selection can be extended to given position
- * or should be extended further.
- */
-function getCorrectWordBreakPosition(walker, isForward) {
-    let textNode = walker.position.textNode;
-    if (!textNode) {
-        textNode = isForward ? walker.position.nodeAfter : walker.position.nodeBefore;
-    }
-    while (textNode && textNode.is('$text')) {
-        const offset = walker.position.offset - textNode.startOffset;
-        // Check of adjacent text nodes with different attributes (like BOLD).
-        // Example          : 'foofoo []bar<$text bold="true">bar</$text> bazbaz'
-        // should expand to : 'foofoo [bar<$text bold="true">bar</$text>] bazbaz'.
-        if (isAtNodeBoundary(textNode, offset, isForward)) {
-            textNode = isForward ? walker.position.nodeAfter : walker.position.nodeBefore;
-        }
-        // Check if this is a word boundary.
-        else if (isAtWordBoundary(textNode.data, offset, isForward)) {
-            break;
-        }
-        // Maybe one more character.
-        else {
-            walker.next();
-        }
-    }
-    return walker.position;
-}
-function getSearchRange(start, isForward) {
-    const root = start.root;
-    const searchEnd = ModelPosition._createAt(root, isForward ? 'end' : 0);
-    if (isForward) {
-        return new ModelRange(start, searchEnd);
-    }
-    else {
-        return new ModelRange(searchEnd, start);
-    }
-}
-/**
- * Checks if selection is on word boundary.
- */
-function isAtWordBoundary(data, offset, isForward) {
-    // The offset to check depends on direction.
-    const offsetToCheck = offset + (isForward ? 0 : -1);
-    return wordBoundaryCharacters.includes(data.charAt(offsetToCheck));
-}
-/**
- * Checks if selection is on node boundary.
- */
-function isAtNodeBoundary(textNode, offset, isForward) {
-    return offset === (isForward ? textNode.offsetSize : 0);
-}

package/src/model/utils/selection-post-fixer.js

@@ -1,264 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/model/utils/selection-post-fixer
- */
-import { ModelPosition } from '../position.js';
-import { ModelRange } from '../range.js';
-/**
- * Injects selection post-fixer to the model.
- *
- * The role of the selection post-fixer is to ensure that the selection is in a correct place
- * after a {@link module:engine/model/model~Model#change `change()`} block was executed.
- *
- * The correct position means that:
- *
- * * All collapsed selection ranges are in a place where the {@link module:engine/model/schema~ModelSchema}
- * allows a `$text`.
- * * None of the selection's non-collapsed ranges crosses a {@link module:engine/model/schema~ModelSchema#isLimit limit element}
- * boundary (a range must be rooted within one limit element).
- * * Only {@link module:engine/model/schema~ModelSchema#isSelectable selectable elements} can be selected from the outside
- * (e.g. `[<paragraph>foo</paragraph>]` is invalid). This rule applies independently to both selection ends, so this
- * selection is correct: `<paragraph>f[oo</paragraph><imageBlock></imageBlock>]`.
- *
- * If the position is not correct, the post-fixer will automatically correct it.
- *
- * ## Fixing a non-collapsed selection
- *
- * See as an example a selection that starts in a P1 element and ends inside the text of a TD element
- * (`[` and `]` are range boundaries and `(l)` denotes an element defined as `isLimit=true`):
- *
- * ```
- * root
- *  |- element P1
- *  |   |- "foo"                                      root
- *  |- element TABLE (l)                   P1         TABLE             P2
- *  |   |- element TR (l)                 f o[o     TR      TR         b a r
- *  |   |   |- element TD (l)                       TD      TD
- *  |   |       |- "aaa"                          a]a a    b b b
- *  |   |- element TR (l)
- *  |   |   |- element TD (l)                           ||
- *  |   |       |- "bbb"                                ||
- *  |- element P2                                       VV
- *  |   |- "bar"
- *                                                    root
- *                                         P1         TABLE]            P2
- *                                        f o[o     TR      TR         b a r
- *                                                  TD      TD
- *                                                a a a    b b b
- * ```
- *
- * In the example above, the TABLE, TR and TD are defined as `isLimit=true` in the schema. The range which is not contained within
- * a single limit element must be expanded to select the outermost limit element. The range end is inside the text node of the TD element.
- * As the TD element is a child of the TR and TABLE elements, where both are defined as `isLimit=true` in the schema, the range must be
- * expanded to select the whole TABLE element.
- *
- * **Note** If the selection contains multiple ranges, the method returns a minimal set of ranges that are not intersecting after expanding
- * them to select `isLimit=true` elements.
- *
- * @internal
- */
-export function injectSelectionPostFixer(model) {
-    model.document.registerPostFixer(writer => selectionPostFixer(writer, model));
-}
-/**
- * The selection post-fixer.
- */
-function selectionPostFixer(writer, model) {
-    const selection = model.document.selection;
-    const schema = model.schema;
-    const ranges = [];
-    let wasFixed = false;
-    for (const modelRange of selection.getRanges()) {
-        // Go through all ranges in selection and try fixing each of them.
-        // Those ranges might overlap but will be corrected later.
-        const correctedRange = tryFixingRange(modelRange, schema);
-        // "Selection fixing" algorithms sometimes get lost. In consequence, it may happen
-        // that a new range is returned but, in fact, it has the same positions as the original
-        // range anyway. If this range is not discarded, a new selection will be set and that,
-        // for instance, would destroy the selection attributes. Let's make sure that the post-fixer
-        // actually worked first before setting a new selection.
-        //
-        // https://github.com/ckeditor/ckeditor5/issues/6693
-        if (correctedRange && !correctedRange.isEqual(modelRange)) {
-            ranges.push(correctedRange);
-            wasFixed = true;
-        }
-        else {
-            ranges.push(modelRange);
-        }
-    }
-    // If any of ranges were corrected update the selection.
-    if (wasFixed) {
-        writer.setSelection(mergeIntersectingRanges(ranges), { backward: selection.isBackward });
-    }
-    return false;
-}
-/**
- * Tries fixing a range if it's incorrect.
- *
- * **Note:** This helper is used by the selection post-fixer and to fix the `beforeinput` target ranges.
- *
- * @returns Returns fixed range or null if range is valid.
- * @internal
- */
-export function tryFixingRange(range, schema) {
-    if (range.isCollapsed) {
-        return tryFixingCollapsedRange(range, schema);
-    }
-    return tryFixingNonCollapsedRage(range, schema);
-}
-/**
- * Tries to fix collapsed ranges.
- *
- * * Fixes situation when a range is in a place where $text is not allowed
- *
- * @param range Collapsed range to fix.
- * @returns Returns fixed range or null if range is valid.
- */
-function tryFixingCollapsedRange(range, schema) {
-    const originalPosition = range.start;
-    const nearestSelectionRange = schema.getNearestSelectionRange(originalPosition);
-    // This might be null, i.e. when the editor data is empty or the selection is inside a limit element
-    // that doesn't allow text inside.
-    // In the first case, there is no need to fix the selection range.
-    // In the second, let's go up to the outer selectable element
-    if (!nearestSelectionRange) {
-        const ancestorObject = originalPosition.getAncestors().reverse().find((item) => schema.isObject(item));
-        if (ancestorObject) {
-            return ModelRange._createOn(ancestorObject);
-        }
-        return null;
-    }
-    if (!nearestSelectionRange.isCollapsed) {
-        return nearestSelectionRange;
-    }
-    const fixedPosition = nearestSelectionRange.start;
-    // Fixed position is the same as original - no need to return corrected range.
-    if (originalPosition.isEqual(fixedPosition)) {
-        return null;
-    }
-    return new ModelRange(fixedPosition);
-}
-/**
- * Tries to fix an expanded range.
- *
- * @param range Expanded range to fix.
- * @returns Returns fixed range or null if range is valid.
- */
-function tryFixingNonCollapsedRage(range, schema) {
-    const { start, end } = range;
-    const isTextAllowedOnStart = schema.checkChild(start, '$text');
-    const isTextAllowedOnEnd = schema.checkChild(end, '$text');
-    const startLimitElement = schema.getLimitElement(start);
-    const endLimitElement = schema.getLimitElement(end);
-    // Ranges which both end are inside the same limit element (or root) might needs only minor fix.
-    if (startLimitElement === endLimitElement) {
-        // Range is valid when both position allows to place a text:
-        // - <block>f[oobarba]z</block>
-        // This would be "fixed" by a next check but as it will be the same it's better to return null so the selection stays the same.
-        if (isTextAllowedOnStart && isTextAllowedOnEnd) {
-            return null;
-        }
-        // Range that is on non-limit element (or is partially) must be fixed so it is placed inside the block around $text:
-        // - [<block>foo</block>]    ->    <block>[foo]</block>
-        // - [<block>foo]</block>    ->    <block>[foo]</block>
-        // - <block>f[oo</block>]    ->    <block>f[oo]</block>
-        // - [<block>foo</block><selectable></selectable>]    ->    <block>[foo</block><selectable></selectable>]
-        if (checkSelectionOnNonLimitElements(start, end, schema)) {
-            const isStartBeforeSelectable = start.nodeAfter && schema.isSelectable(start.nodeAfter);
-            const fixedStart = isStartBeforeSelectable ? null : schema.getNearestSelectionRange(start, 'forward');
-            const isEndAfterSelectable = end.nodeBefore && schema.isSelectable(end.nodeBefore);
-            const fixedEnd = isEndAfterSelectable ? null : schema.getNearestSelectionRange(end, 'backward');
-            // The schema.getNearestSelectionRange might return null - if that happens use original position.
-            const rangeStart = fixedStart ? fixedStart.start : start;
-            const rangeEnd = fixedEnd ? fixedEnd.end : end;
-            return new ModelRange(rangeStart, rangeEnd);
-        }
-    }
-    const isStartInLimit = startLimitElement && !startLimitElement.is('rootElement');
-    const isEndInLimit = endLimitElement && !endLimitElement.is('rootElement');
-    // At this point we eliminated valid positions on text nodes so if one of range positions is placed inside a limit element
-    // then the range crossed limit element boundaries and needs to be fixed.
-    if (isStartInLimit || isEndInLimit) {
-        const bothInSameParent = (start.nodeAfter && end.nodeBefore) && start.nodeAfter.parent === end.nodeBefore.parent;
-        const expandStart = isStartInLimit && (!bothInSameParent || !isSelectable(start.nodeAfter, schema));
-        const expandEnd = isEndInLimit && (!bothInSameParent || !isSelectable(end.nodeBefore, schema));
-        // Although we've already found limit element on start/end positions we must find the outer-most limit element.
-        // as limit elements might be nested directly inside (ie table > tableRow > tableCell).
-        let fixedStart = start;
-        let fixedEnd = end;
-        if (expandStart) {
-            fixedStart = ModelPosition._createBefore(findOutermostLimitAncestor(startLimitElement, schema));
-        }
-        if (expandEnd) {
-            fixedEnd = ModelPosition._createAfter(findOutermostLimitAncestor(endLimitElement, schema));
-        }
-        return new ModelRange(fixedStart, fixedEnd);
-    }
-    // Range was not fixed at this point so it is valid - ie it was placed around limit element already.
-    return null;
-}
-/**
- * Finds the outer-most ancestor.
- */
-function findOutermostLimitAncestor(startingNode, schema) {
-    let isLimitNode = startingNode;
-    let parent = isLimitNode;
-    // Find outer most isLimit block as such blocks might be nested (ie. in tables).
-    while (schema.isLimit(parent) && parent.parent) {
-        isLimitNode = parent;
-        parent = parent.parent;
-    }
-    return isLimitNode;
-}
-/**
- * Checks whether any of range boundaries is placed around non-limit elements.
- */
-function checkSelectionOnNonLimitElements(start, end, schema) {
-    const startIsOnBlock = (start.nodeAfter && !schema.isLimit(start.nodeAfter)) || schema.checkChild(start, '$text');
-    const endIsOnBlock = (end.nodeBefore && !schema.isLimit(end.nodeBefore)) || schema.checkChild(end, '$text');
-    // We should fix such selection when one of those nodes needs fixing.
-    return startIsOnBlock || endIsOnBlock;
-}
-/**
- * Returns a minimal non-intersecting array of ranges without duplicates.
- *
- * @param ranges Ranges to merge.
- * @returns Array of unique and non-intersecting ranges.
- * @internal
- */
-export function mergeIntersectingRanges(ranges) {
-    const rangesToMerge = [...ranges];
-    const rangeIndexesToRemove = new Set();
-    let currentRangeIndex = 1;
-    while (currentRangeIndex < rangesToMerge.length) {
-        const currentRange = rangesToMerge[currentRangeIndex];
-        const previousRanges = rangesToMerge.slice(0, currentRangeIndex);
-        for (const [previousRangeIndex, previousRange] of previousRanges.entries()) {
-            if (rangeIndexesToRemove.has(previousRangeIndex)) {
-                continue;
-            }
-            if (currentRange.isEqual(previousRange)) {
-                rangeIndexesToRemove.add(previousRangeIndex);
-            }
-            else if (currentRange.isIntersecting(previousRange)) {
-                rangeIndexesToRemove.add(previousRangeIndex);
-                rangeIndexesToRemove.add(currentRangeIndex);
-                const mergedRange = currentRange.getJoined(previousRange);
-                rangesToMerge.push(mergedRange);
-            }
-        }
-        currentRangeIndex++;
-    }
-    const nonIntersectingRanges = rangesToMerge.filter((_, index) => !rangeIndexesToRemove.has(index));
-    return nonIntersectingRanges;
-}
-/**
- * Checks if node exists and if it's a selectable.
- */
-function isSelectable(node, schema) {
-    return node && schema.isSelectable(node);
-}