@ckeditor/ckeditor5-engine 45.2.1 → 46.0.0-alpha.1

package/src/model/utils/insertcontent.js

@@ -5,12 +5,12 @@
 /**
  * @module engine/model/utils/insertcontent
  */
-import DocumentSelection from '../documentselection.js';
-import Element from '../element.js';
-import LivePosition from '../liveposition.js';
-import LiveRange from '../liverange.js';
-import Position from '../position.js';
-import Range from '../range.js';
+import { ModelDocumentSelection } from '../documentselection.js';
+import { ModelElement } from '../element.js';
+import { ModelLivePosition } from '../liveposition.js';
+import { ModelLiveRange } from '../liverange.js';
+import { ModelPosition } from '../position.js';
+import { ModelRange } from '../range.js';
 import { CKEditorError } from '@ckeditor/ckeditor5-utils';
 /**
  * Inserts content into the editor (specified selection) as one would expect the paste functionality to work.
@@ -27,7 +27,7 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * <p>x</p>[<img />]<p>z</p> + <p>y</p> => <p>x</p>^<p>z</p> + <p>y</p> => <p>x</p><p>y[]</p><p>z</p>
  * ```
  *
- * If an instance of {@link module:engine/model/selection~Selection} is passed as `selectable` it will be modified
+ * If an instance of {@link module:engine/model/selection~ModelSelection} is passed as `selectable` it will be modified
  * to the insertion selection (equal to a range to be selected after insertion).
  *
  * If `selectable` is not passed, the content will be inserted using the current selection of the model document.
@@ -42,8 +42,9 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * @returns 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 `insertContent`, returns a range collapsed
  * at the insertion position.
+ * @internal
  */
-export default function insertContent(model, content, selectable) {
+export function insertContent(model, content, selectable) {
     return model.change(writer => {
         const selection = selectable ? selectable : model.document.selection;
         if (!selection.isCollapsed) {
@@ -105,7 +106,7 @@ export default function insertContent(model, content, selectable) {
             // After insertion was done, the selection was set but the model contains fake <$marker> elements.
             // These <$marker> elements will be now removed. Because of that, we will need to fix the selection.
             // We will create a live range that will automatically be update as <$marker> elements are removed.
-            const selectionLiveRange = newRange ? LiveRange.fromRange(newRange) : null;
+            const selectionLiveRange = newRange ? ModelLiveRange.fromRange(newRange) : null;
             // Marker name -> [ start position, end position ].
             const markersData = {};
             // Note: `fakeMarkerElements` are sorted backwards. However, now, we want to handle the markers
@@ -152,7 +153,7 @@ export default function insertContent(model, content, selectable) {
                     writer.addMarker(name, {
                         usingOperation: true,
                         affectsData: true,
-                        range: new Range(start, end)
+                        range: new ModelRange(start, end)
                     });
                 }
             }
@@ -163,7 +164,7 @@ export default function insertContent(model, content, selectable) {
         }
         /* istanbul ignore else -- @preserve */
         if (newRange) {
-            if (selection instanceof DocumentSelection) {
+            if (selection instanceof ModelDocumentSelection) {
                 writer.setSelection(newRange);
             }
             else {
@@ -213,11 +214,11 @@ class Insertion {
      */
     schema;
     /**
-     * The temporary DocumentFragment used for grouping multiple nodes for single insert operation.
+     * The temporary ModelDocumentFragment used for grouping multiple nodes for single insert operation.
      */
     _documentFragment;
     /**
-     * The current position in the temporary DocumentFragment.
+     * The current position in the temporary ModelDocumentFragment.
      */
     _documentFragmentPosition;
     /**
@@ -263,7 +264,7 @@ class Insertion {
         for (const node of Array.from(nodes)) {
             this._handleNode(node);
         }
-        // Insert nodes collected in temporary DocumentFragment.
+        // Insert nodes collected in temporary ModelDocumentFragment.
         this._insertPartialFragment();
         // If there was an auto paragraph then we might need to adjust the end of insertion.
         if (this._lastAutoParagraph) {
@@ -304,7 +305,7 @@ class Insertion {
      */
     getSelectionRange() {
         if (this._nodeToSelect) {
-            return Range._createOn(this._nodeToSelect);
+            return ModelRange._createOn(this._nodeToSelect);
         }
         return this.model.schema.getNearestSelectionRange(this.position);
     }
@@ -316,7 +317,7 @@ class Insertion {
         if (!this._affectedStart) {
             return null;
         }
-        return new Range(this._affectedStart, this._affectedEnd);
+        return new ModelRange(this._affectedStart, this._affectedEnd);
     }
     /**
      * Destroys `Insertion` instance.
@@ -342,7 +343,7 @@ class Insertion {
             }
             return;
         }
-        // Add node to the current temporary DocumentFragment.
+        // Add node to the current temporary ModelDocumentFragment.
         this._appendToFragment(node);
         // Store the first and last nodes for easy access for merging with sibling nodes.
         if (!this._firstNode) {
@@ -351,13 +352,13 @@ class Insertion {
         this._lastNode = node;
     }
     /**
-     * Inserts the temporary DocumentFragment into the model.
+     * Inserts the temporary ModelDocumentFragment into the model.
      */
     _insertPartialFragment() {
         if (this._documentFragment.isEmpty) {
             return;
         }
-        const livePosition = LivePosition.fromPosition(this.position, 'toNext');
+        const livePosition = ModelLivePosition.fromPosition(this.position, 'toNext');
         this._setAffectedBoundaries(this.position);
         // If the very first node of the whole insertion process is inserted, insert it separately for OT reasons (undo).
         // Note: there can be multiple calls to `_insertPartialFragment()` during one insertion process.
@@ -387,7 +388,7 @@ class Insertion {
         }
     }
     /**
-     * Append a node to the temporary DocumentFragment.
+     * Append a node to the temporary ModelDocumentFragment.
      *
      * @param node The node to insert.
      */
@@ -400,8 +401,8 @@ class Insertion {
              * Given node cannot be inserted on the given position.
              *
              * @error insertcontent-wrong-position
-             * @param {module:engine/model/node~Node} node Node to insert.
-             * @param {module:engine/model/position~Position} position Position to insert the node at.
+             * @param {module:engine/model/node~ModelNode} node Node to insert.
+             * @param {module:engine/model/position~ModelPosition} position Position to insert the node at.
              */
             throw new CKEditorError('insertcontent-wrong-position', this, { node, position: this.position });
         }
@@ -428,7 +429,7 @@ class Insertion {
         // <paragraph>Foo][bar</paragraph> -> <paragraph>Foo]xx[bar</paragraph>
         // This is why it cannot be a range but two separate positions.
         if (!this._affectedStart) {
-            this._affectedStart = LivePosition.fromPosition(position, 'toPrevious');
+            this._affectedStart = ModelLivePosition.fromPosition(position, 'toPrevious');
         }
         // If `_affectedEnd` is before the new boundary position, expand `_affectedEnd`. This can happen if first inserted node was
         // inserted into the parent but the next node is moved-out of that parent:
@@ -438,7 +439,7 @@ class Insertion {
             if (this._affectedEnd) {
                 this._affectedEnd.detach();
             }
-            this._affectedEnd = LivePosition.fromPosition(position, 'toNext');
+            this._affectedEnd = ModelLivePosition.fromPosition(position, 'toNext');
         }
     }
     /**
@@ -449,17 +450,17 @@ class Insertion {
      */
     _mergeOnLeft() {
         const node = this._firstNode;
-        if (!(node instanceof Element)) {
+        if (!(node instanceof ModelElement)) {
             return;
         }
         if (!this._canMergeLeft(node)) {
             return;
         }
-        const mergePosLeft = LivePosition._createBefore(node);
+        const mergePosLeft = ModelLivePosition._createBefore(node);
         mergePosLeft.stickiness = 'toNext';
-        const livePosition = LivePosition.fromPosition(this.position, 'toNext');
+        const livePosition = ModelLivePosition.fromPosition(this.position, 'toNext');
         // If `_affectedStart` is sames as merge position, it means that the element "marked" by `_affectedStart` is going to be
-        // removed and its contents will be moved. This won't transform `LivePosition` so `_affectedStart` needs to be moved
+        // removed and its contents will be moved. This won't transform `ModelLivePosition` so `_affectedStart` needs to be moved
         // by hand to properly reflect affected range. (Due to `_affectedStart` and `_affectedEnd` stickiness, the "range" is
         // shown as `][`).
         //
@@ -472,7 +473,7 @@ class Insertion {
         // Note, that if we are here then something must have been inserted, so `_affectedStart` and `_affectedEnd` have to be set.
         if (this._affectedStart.isEqual(mergePosLeft)) {
             this._affectedStart.detach();
-            this._affectedStart = LivePosition._createAt(mergePosLeft.nodeBefore, 'end', 'toPrevious');
+            this._affectedStart = ModelLivePosition._createAt(mergePosLeft.nodeBefore, 'end', 'toPrevious');
         }
         // We need to update the references to the first and last nodes if they will be merged into the previous sibling node
         // because the reference would point to the removed node.
@@ -498,7 +499,7 @@ class Insertion {
         // <paragraph>Foo]Abc[</paragraph><paragraph>Bar</paragraph>
         if (mergePosLeft.isEqual(this._affectedEnd) && this._firstNode === this._lastNode) {
             this._affectedEnd.detach();
-            this._affectedEnd = LivePosition._createAt(mergePosLeft.nodeBefore, 'end', 'toNext');
+            this._affectedEnd = ModelLivePosition._createAt(mergePosLeft.nodeBefore, 'end', 'toNext');
         }
         this.position = livePosition.toPosition();
         livePosition.detach();
@@ -515,13 +516,13 @@ class Insertion {
      */
     _mergeOnRight() {
         const node = this._lastNode;
-        if (!(node instanceof Element)) {
+        if (!(node instanceof ModelElement)) {
             return;
         }
         if (!this._canMergeRight(node)) {
             return;
         }
-        const mergePosRight = LivePosition._createAfter(node);
+        const mergePosRight = ModelLivePosition._createAfter(node);
         mergePosRight.stickiness = 'toNext';
         /* istanbul ignore if -- @preserve */
         if (!this.position.isEqual(mergePosRight)) {
@@ -541,15 +542,15 @@ class Insertion {
         }
         // Move the position to the previous node, so it isn't moved to the graveyard on merge.
         // <p>x</p>[]<p>y</p> => <p>x[]</p><p>y</p>
-        this.position = Position._createAt(mergePosRight.nodeBefore, 'end');
+        this.position = ModelPosition._createAt(mergePosRight.nodeBefore, 'end');
         // Explanation of setting position stickiness to `'toPrevious'`:
         // OK:  <p>xx[]</p> + <p>yy</p> => <p>xx[]yy</p> (when sticks to previous)
         // NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
-        const livePosition = LivePosition.fromPosition(this.position, 'toPrevious');
+        const livePosition = ModelLivePosition.fromPosition(this.position, 'toPrevious');
         // See comment in `_mergeOnLeft()` on moving `_affectedStart`.
         if (this._affectedEnd.isEqual(mergePosRight)) {
             this._affectedEnd.detach();
-            this._affectedEnd = LivePosition._createAt(mergePosRight.nodeBefore, 'end', 'toNext');
+            this._affectedEnd = ModelLivePosition._createAt(mergePosRight.nodeBefore, 'end', 'toNext');
         }
         // We need to update the references to the first and last nodes if they will be merged into the previous sibling node
         // because the reference would point to the removed node.
@@ -568,7 +569,7 @@ class Insertion {
         // See comment in `_mergeOnLeft()` on moving `_affectedStart`.
         if (mergePosRight.getShiftedBy(-1).isEqual(this._affectedStart) && this._firstNode === this._lastNode) {
             this._affectedStart.detach();
-            this._affectedStart = LivePosition._createAt(mergePosRight.nodeBefore, 0, 'toPrevious');
+            this._affectedStart = ModelLivePosition._createAt(mergePosRight.nodeBefore, 0, 'toPrevious');
         }
         this.position = livePosition.toPosition();
         livePosition.detach();
@@ -584,7 +585,7 @@ class Insertion {
      */
     _canMergeLeft(node) {
         const previousSibling = node.previousSibling;
-        return (previousSibling instanceof Element) &&
+        return (previousSibling instanceof ModelElement) &&
             this.canMergeWith.has(previousSibling) &&
             this.model.schema.checkMerge(previousSibling, node);
     }
@@ -595,7 +596,7 @@ class Insertion {
      */
     _canMergeRight(node) {
         const nextSibling = node.nextSibling;
-        return (nextSibling instanceof Element) &&
+        return (nextSibling instanceof ModelElement) &&
             this.canMergeWith.has(nextSibling) &&
             this.model.schema.checkMerge(node, nextSibling);
     }
@@ -603,7 +604,7 @@ class Insertion {
      * Inserts a paragraph and moves the insertion position into it.
      */
     _insertAutoParagraph() {
-        // Insert nodes collected in temporary DocumentFragment if the position parent needs change to process further nodes.
+        // Insert nodes collected in temporary ModelDocumentFragment if the position parent needs change to process further nodes.
         this._insertPartialFragment();
         // Insert a paragraph and move insertion position to it.
         const paragraph = this.writer.createElement('paragraph');
@@ -621,7 +622,7 @@ class Insertion {
         if (!allowedIn) {
             return false;
         }
-        // Insert nodes collected in temporary DocumentFragment if the position parent needs change to process further nodes.
+        // Insert nodes collected in temporary ModelDocumentFragment if the position parent needs change to process further nodes.
         if (allowedIn != this.position.parent) {
             this._insertPartialFragment();
         }

package/src/model/utils/insertobject.d.ts

@@ -5,11 +5,11 @@
 /**
  * @module engine/model/utils/insertobject
  */
-import type DocumentSelection from '../documentselection.js';
-import type Selection from '../selection.js';
-import type Element from '../element.js';
-import type Model from '../model.js';
-import type Range from '../range.js';
+import { type ModelDocumentSelection } from '../documentselection.js';
+import { type ModelSelection } from '../selection.js';
+import { type ModelElement } from '../element.js';
+import { type Model } from '../model.js';
+import { type ModelRange } from '../range.js';
 /**
  * Inserts an {@glink framework/deep-dive/schema#object-elements object element} at a specific position in the editor content.
  *
@@ -22,7 +22,7 @@ import type Range from '../range.js';
  * @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~Document#selection document selection} will be used instead.
+ * {@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).
@@ -32,7 +32,7 @@ import type Range from '../range.js';
  *
  * 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~Document#selection document selection} after inserting the object.
+ * {@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.
@@ -40,7 +40,7 @@ import type Range from '../range.js';
  * 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 default function insertObject(model: Model, object: Element, selectable?: Selection | DocumentSelection | null, options?: {
+export declare function insertObject(model: Model, object: ModelElement, selectable?: ModelSelection | ModelDocumentSelection | null, options?: {
     findOptimalPosition?: 'auto' | 'before' | 'after';
     setSelection?: 'on' | 'after';
-}): Range;
+}): ModelRange;

package/src/model/utils/insertobject.js

@@ -15,7 +15,7 @@ import { CKEditorError, first } from '@ckeditor/ckeditor5-utils';
  * @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~Document#selection document selection} will be used instead.
+ * {@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).
@@ -25,7 +25,7 @@ import { CKEditorError, first } from '@ckeditor/ckeditor5-utils';
  *
  * 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~Document#selection document selection} after inserting the object.
+ * {@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.
@@ -33,12 +33,12 @@ import { CKEditorError, first } from '@ckeditor/ckeditor5-utils';
  * 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 default function insertObject(model, object, selectable, options = {}) {
+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~SchemaItemDefinition#isObject `SchemaItemDefinition`}.
+         * 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

package/src/model/utils/modifyselection.d.ts

@@ -5,9 +5,9 @@
 /**
  * @module engine/model/utils/modifyselection
  */
-import DocumentSelection from '../documentselection.js';
-import type Model from '../model.js';
-import type Selection from '../selection.js';
+import { ModelDocumentSelection } from '../documentselection.js';
+import { type Model } from '../model.js';
+import { type ModelSelection } from '../selection.js';
 /**
  * Modifies the selection. Currently, the supported modifications are:
  *
@@ -40,8 +40,9 @@ import type Selection from '../selection.js';
  * @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 default function modifySelection(model: Model, selection: Selection | DocumentSelection, options?: {
+export declare function modifySelection(model: Model, selection: ModelSelection | ModelDocumentSelection, options?: {
     direction?: 'forward' | 'backward';
     unit?: 'character' | 'codePoint' | 'word';
     treatEmojiAsSingleUnit?: boolean;

package/src/model/utils/modifyselection.js

@@ -5,10 +5,10 @@
 /**
  * @module engine/model/utils/modifyselection
  */
-import DocumentSelection from '../documentselection.js';
-import Position from '../position.js';
-import Range from '../range.js';
-import TreeWalker from '../treewalker.js';
+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 = ' ,.?!:;"-()';
 /**
@@ -43,14 +43,15 @@ const wordBoundaryCharacters = ' ,.?!:;"-()';
  * @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 default function modifySelection(model, selection, options = {}) {
+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 TreeWalker({
+    const walker = new ModelTreeWalker({
         boundaries: getSearchRange(focus, isForward),
         singleCharacters: true,
         direction: isForward ? 'forward' : 'backward'
@@ -63,7 +64,7 @@ export default function modifySelection(model, selection, options = {}) {
         }
         const position = tryExtendingTo(data, next.value);
         if (position) {
-            if (selection instanceof DocumentSelection) {
+            if (selection instanceof ModelDocumentSelection) {
                 model.change(writer => {
                     writer.setSelectionFocus(position);
                 });
@@ -93,7 +94,7 @@ function tryExtendingTo(data, value) {
     if (type == (isForward ? 'elementStart' : 'elementEnd')) {
         // If it's a selectable, we can select it now.
         if (schema.isSelectable(item)) {
-            return Position._createAt(item, isForward ? 'after' : 'before');
+            return ModelPosition._createAt(item, isForward ? 'after' : 'before');
         }
         // If text allowed on this position, extend to this place.
         if (schema.checkChild(nextPosition, '$text')) {
@@ -162,12 +163,12 @@ function getCorrectWordBreakPosition(walker, isForward) {
 }
 function getSearchRange(start, isForward) {
     const root = start.root;
-    const searchEnd = Position._createAt(root, isForward ? 'end' : 0);
+    const searchEnd = ModelPosition._createAt(root, isForward ? 'end' : 0);
     if (isForward) {
-        return new Range(start, searchEnd);
+        return new ModelRange(start, searchEnd);
     }
     else {
-        return new Range(searchEnd, start);
+        return new ModelRange(searchEnd, start);
     }
 }
 /**

package/src/model/utils/selection-post-fixer.d.ts

@@ -2,9 +2,9 @@
  * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import Range from '../range.js';
-import type Model from '../model.js';
-import type Schema from '../schema.js';
+import { ModelRange } from '../range.js';
+import { type Model } from '../model.js';
+import { type ModelSchema } from '../schema.js';
 /**
  * Injects selection post-fixer to the model.
  *
@@ -13,11 +13,11 @@ import type Schema from '../schema.js';
  *
  * The correct position means that:
  *
- * * All collapsed selection ranges are in a place where the {@link module:engine/model/schema~Schema}
+ * * 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~Schema#isLimit limit element}
+ * * 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~Schema#isSelectable selectable elements} can be selected from the outside
+ * * 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>]`.
  *
@@ -55,6 +55,8 @@ import type Schema from '../schema.js';
  *
  * **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 declare function injectSelectionPostFixer(model: Model): void;
 /**
@@ -63,12 +65,14 @@ export declare function injectSelectionPostFixer(model: Model): void;
  * **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 declare function tryFixingRange(range: Range, schema: Schema): Range | null;
+export declare function tryFixingRange(range: ModelRange, schema: ModelSchema): ModelRange | null;
 /**
  * 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 declare function mergeIntersectingRanges(ranges: Array<Range>): Array<Range>;
+export declare function mergeIntersectingRanges(ranges: Array<ModelRange>): Array<ModelRange>;

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

@@ -5,8 +5,8 @@
 /**
  * @module engine/model/utils/selection-post-fixer
  */
-import Position from '../position.js';
-import Range from '../range.js';
+import { ModelPosition } from '../position.js';
+import { ModelRange } from '../range.js';
 /**
  * Injects selection post-fixer to the model.
  *
@@ -15,11 +15,11 @@ import Range from '../range.js';
  *
  * The correct position means that:
  *
- * * All collapsed selection ranges are in a place where the {@link module:engine/model/schema~Schema}
+ * * 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~Schema#isLimit limit element}
+ * * 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~Schema#isSelectable selectable elements} can be selected from the outside
+ * * 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>]`.
  *
@@ -57,6 +57,8 @@ import Range from '../range.js';
  *
  * **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));
@@ -100,6 +102,7 @@ function selectionPostFixer(writer, model) {
  * **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) {
@@ -125,7 +128,7 @@ function tryFixingCollapsedRange(range, schema) {
     if (!nearestSelectionRange) {
         const ancestorObject = originalPosition.getAncestors().reverse().find((item) => schema.isObject(item));
         if (ancestorObject) {
-            return Range._createOn(ancestorObject);
+            return ModelRange._createOn(ancestorObject);
         }
         return null;
     }
@@ -137,7 +140,7 @@ function tryFixingCollapsedRange(range, schema) {
     if (originalPosition.isEqual(fixedPosition)) {
         return null;
     }
-    return new Range(fixedPosition);
+    return new ModelRange(fixedPosition);
 }
 /**
  * Tries to fix an expanded range.
@@ -172,7 +175,7 @@ function tryFixingNonCollapsedRage(range, schema) {
             // 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 Range(rangeStart, rangeEnd);
+            return new ModelRange(rangeStart, rangeEnd);
         }
     }
     const isStartInLimit = startLimitElement && !startLimitElement.is('rootElement');
@@ -188,12 +191,12 @@ function tryFixingNonCollapsedRage(range, schema) {
         let fixedStart = start;
         let fixedEnd = end;
         if (expandStart) {
-            fixedStart = Position._createBefore(findOutermostLimitAncestor(startLimitElement, schema));
+            fixedStart = ModelPosition._createBefore(findOutermostLimitAncestor(startLimitElement, schema));
         }
         if (expandEnd) {
-            fixedEnd = Position._createAfter(findOutermostLimitAncestor(endLimitElement, schema));
+            fixedEnd = ModelPosition._createAfter(findOutermostLimitAncestor(endLimitElement, schema));
         }
-        return new Range(fixedStart, fixedEnd);
+        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;
@@ -225,6 +228,7 @@ function checkSelectionOnNonLimitElements(start, end, schema) {
  *
  * @param ranges Ranges to merge.
  * @returns Array of unique and non-intersecting ranges.
+ * @internal
  */
 export function mergeIntersectingRanges(ranges) {
     const rangesToMerge = [...ranges];