@ckeditor/ckeditor5-engine 45.2.1-alpha.9 → 46.0.0-alpha.0

package/src/model/range.js

@@ -5,20 +5,20 @@
 /**
  * @module engine/model/range
  */
-import TypeCheckable from './typecheckable.js';
-import Position from './position.js';
-import TreeWalker from './treewalker.js';
+import { ModelTypeCheckable } from './typecheckable.js';
+import { ModelPosition } from './position.js';
+import { ModelTreeWalker } from './treewalker.js';
 import { CKEditorError, compareArrays } from '@ckeditor/ckeditor5-utils';
 /**
  * Represents a range in the model tree.
  *
- * A range is defined by its {@link module:engine/model/range~Range#start} and {@link module:engine/model/range~Range#end}
+ * A range is defined by its {@link module:engine/model/range~ModelRange#start} and {@link module:engine/model/range~ModelRange#end}
  * positions.
  *
  * You can create range instances via its constructor or the `createRange*()` factory methods of
- * {@link module:engine/model/model~Model} and {@link module:engine/model/writer~Writer}.
+ * {@link module:engine/model/model~Model} and {@link module:engine/model/writer~ModelWriter}.
  */
-export default class Range extends TypeCheckable {
+export class ModelRange extends ModelTypeCheckable {
     /**
      * Start position.
      */
@@ -35,8 +35,8 @@ export default class Range extends TypeCheckable {
      */
     constructor(start, end) {
         super();
-        this.start = Position._createAt(start);
-        this.end = end ? Position._createAt(end) : Position._createAt(start);
+        this.start = ModelPosition._createAt(start);
+        this.end = end ? ModelPosition._createAt(end) : ModelPosition._createAt(start);
         // If the range is collapsed, treat in a similar way as a position and set its boundaries stickiness to 'toNone'.
         // In other case, make the boundaries stick to the "inside" of the range.
         this.start.stickiness = this.isCollapsed ? 'toNone' : 'toNext';
@@ -45,17 +45,17 @@ export default class Range extends TypeCheckable {
     /**
      * Iterable interface.
      *
-     * Iterates over all {@link module:engine/model/item~Item items} that are in this range and returns
-     * them together with additional information like length or {@link module:engine/model/position~Position positions},
-     * grouped as {@link module:engine/model/treewalker~TreeWalkerValue}.
-     * It iterates over all {@link module:engine/model/textproxy~TextProxy text contents} that are inside the range
-     * and all the {@link module:engine/model/element~Element}s that are entered into when iterating over this range.
+     * Iterates over all {@link module:engine/model/item~ModelItem items} that are in this range and returns
+     * them together with additional information like length or {@link module:engine/model/position~ModelPosition positions},
+     * grouped as {@link module:engine/model/treewalker~ModelTreeWalkerValue}.
+     * It iterates over all {@link module:engine/model/textproxy~ModelTextProxy text contents} that are inside the range
+     * and all the {@link module:engine/model/element~ModelElement}s that are entered into when iterating over this range.
      *
-     * This iterator uses {@link module:engine/model/treewalker~TreeWalker} with `boundaries` set to this range
+     * This iterator uses {@link module:engine/model/treewalker~ModelTreeWalker} with `boundaries` set to this range
      * and `ignoreElementEnd` option set to `true`.
      */
     *[Symbol.iterator]() {
-        yield* new TreeWalker({ boundaries: this, ignoreElementEnd: true });
+        yield* new ModelTreeWalker({ boundaries: this, ignoreElementEnd: true });
     }
     /**
      * Describes whether the range is collapsed, that is if {@link #start} and
@@ -66,7 +66,7 @@ export default class Range extends TypeCheckable {
     }
     /**
      * Describes whether this range is flat, that is if {@link #start} position and
-     * {@link #end} position are in the same {@link module:engine/model/position~Position#parent}.
+     * {@link #end} position are in the same {@link module:engine/model/position~ModelPosition#parent}.
      */
     get isFlat() {
         const startParentPath = this.start.getParentPath();
@@ -80,23 +80,23 @@ export default class Range extends TypeCheckable {
         return this.start.root;
     }
     /**
-     * Checks whether this range contains given {@link module:engine/model/position~Position position}.
+     * Checks whether this range contains given {@link module:engine/model/position~ModelPosition position}.
      *
      * @param position Position to check.
-     * @returns `true` if given {@link module:engine/model/position~Position position} is contained
+     * @returns `true` if given {@link module:engine/model/position~ModelPosition position} is contained
      * in this range,`false` otherwise.
      */
     containsPosition(position) {
         return position.isAfter(this.start) && position.isBefore(this.end);
     }
     /**
-     * Checks whether this range contains given {@link ~Range range}.
+     * Checks whether this range contains given {@link ~ModelRange range}.
      *
      * @param otherRange Range to check.
      * @param loose Whether the check is loose or strict. If the check is strict (`false`), compared range cannot
      * start or end at the same position as this range boundaries. If the check is loose (`true`), compared range can start, end or
      * even be equal to this range. Note that collapsed ranges are always compared in strict mode.
-     * @returns {Boolean} `true` if given {@link ~Range range} boundaries are contained by this range, `false` otherwise.
+     * @returns {Boolean} `true` if given {@link ~ModelRange range} boundaries are contained by this range, `false` otherwise.
      */
     containsRange(otherRange, loose = false) {
         if (otherRange.isCollapsed) {
@@ -107,10 +107,10 @@ export default class Range extends TypeCheckable {
         return containsStart && containsEnd;
     }
     /**
-     * Checks whether given {@link module:engine/model/item~Item} is inside this range.
+     * Checks whether given {@link module:engine/model/item~ModelItem} is inside this range.
      */
     containsItem(item) {
-        const pos = Position._createBefore(item);
+        const pos = ModelPosition._createBefore(item);
         return this.containsPosition(pos) || this.start.isEqual(pos);
     }
     /**
@@ -132,8 +132,8 @@ export default class Range extends TypeCheckable {
         return this.start.isBefore(otherRange.end) && this.end.isAfter(otherRange.start);
     }
     /**
-     * Computes which part(s) of this {@link ~Range range} is not a part of given {@link ~Range range}.
-     * Returned array contains zero, one or two {@link ~Range ranges}.
+     * Computes which part(s) of this {@link ~ModelRange range} is not a part of given {@link ~ModelRange range}.
+     * Returned array contains zero, one or two {@link ~ModelRange ranges}.
      *
      * Examples:
      *
@@ -165,22 +165,22 @@ export default class Range extends TypeCheckable {
             if (this.containsPosition(otherRange.start)) {
                 // Given range start is inside this range. This means that we have to
                 // add shrunken range - from the start to the middle of this range.
-                ranges.push(new Range(this.start, otherRange.start));
+                ranges.push(new ModelRange(this.start, otherRange.start));
             }
             if (this.containsPosition(otherRange.end)) {
                 // Given range end is inside this range. This means that we have to
                 // add shrunken range - from the middle of this range to the end.
-                ranges.push(new Range(otherRange.end, this.end));
+                ranges.push(new ModelRange(otherRange.end, this.end));
             }
         }
         else {
             // Ranges do not intersect, return the original range.
-            ranges.push(new Range(this.start, this.end));
+            ranges.push(new ModelRange(this.start, this.end));
         }
         return ranges;
     }
     /**
-     * Returns an intersection of this {@link ~Range range} and given {@link ~Range range}.
+     * Returns an intersection of this {@link ~ModelRange range} and given {@link ~ModelRange range}.
      * Intersection is a common part of both of those ranges. If ranges has no common part, returns `null`.
      *
      * Examples:
@@ -216,13 +216,13 @@ export default class Range extends TypeCheckable {
                 // shrink common range to the given range end.
                 commonRangeEnd = otherRange.end;
             }
-            return new Range(commonRangeStart, commonRangeEnd);
+            return new ModelRange(commonRangeStart, commonRangeEnd);
         }
         // Ranges do not intersect, so they do not have common part.
         return null;
     }
     /**
-     * Returns a range created by joining this {@link ~Range range} with the given {@link ~Range range}.
+     * Returns a range created by joining this {@link ~ModelRange range} with the given {@link ~ModelRange range}.
      * If ranges have no common part, returns `null`.
      *
      * Examples:
@@ -248,7 +248,7 @@ export default class Range extends TypeCheckable {
      * @param otherRange Range to be joined.
      * @param loose Whether the intersection check is loose or strict. If the check is strict (`false`),
      * ranges are tested for intersection or whether start/end positions are equal. If the check is loose (`true`),
-     * compared range is also checked if it's {@link module:engine/model/position~Position#isTouching touching} current range.
+     * compared range is also checked if it's {@link module:engine/model/position~ModelPosition#isTouching touching} current range.
      * @returns A sum of given ranges or `null` if ranges have no common part.
      */
     getJoined(otherRange, loose = false) {
@@ -272,7 +272,7 @@ export default class Range extends TypeCheckable {
         if (otherRange.end.isAfter(endPosition)) {
             endPosition = otherRange.end;
         }
-        return new Range(startPosition, endPosition);
+        return new ModelRange(startPosition, endPosition);
     }
     /**
      * Computes and returns the smallest set of {@link #isFlat flat} ranges, that covers this range in whole.
@@ -309,7 +309,7 @@ export default class Range extends TypeCheckable {
      * ( [ 3, 0, 0 ], [ 3, 0, 2 ] ) = "se"
      * ```
      *
-     * **Note:** if an {@link module:engine/model/element~Element element} is not wholly contained in this range, it won't be returned
+     * **Note:** if an {@link module:engine/model/element~ModelElement element} is not wholly contained in this range, it won't be returned
      * in any of the returned flat ranges. See in the example how `H` elements at the beginning and at the end of the range
      * were omitted. Only their parts that were wholly in the range were returned.
      *
@@ -320,13 +320,13 @@ export default class Range extends TypeCheckable {
     getMinimalFlatRanges() {
         const ranges = [];
         const diffAt = this.start.getCommonPath(this.end).length;
-        const pos = Position._createAt(this.start);
+        const pos = ModelPosition._createAt(this.start);
         let posParent = pos.parent;
         // Go up.
         while (pos.path.length > diffAt + 1) {
             const howMany = posParent.maxOffset - pos.offset;
             if (howMany !== 0) {
-                ranges.push(new Range(pos, pos.getShiftedBy(howMany)));
+                ranges.push(new ModelRange(pos, pos.getShiftedBy(howMany)));
             }
             pos.path = pos.path.slice(0, -1);
             pos.offset++;
@@ -337,7 +337,7 @@ export default class Range extends TypeCheckable {
             const offset = this.end.path[pos.path.length - 1];
             const howMany = offset - pos.offset;
             if (howMany !== 0) {
-                ranges.push(new Range(pos, pos.getShiftedBy(howMany)));
+                ranges.push(new ModelRange(pos, pos.getShiftedBy(howMany)));
             }
             pos.offset = offset;
             pos.path.push(0);
@@ -345,7 +345,7 @@ export default class Range extends TypeCheckable {
         return ranges;
     }
     /**
-     * Creates a {@link module:engine/model/treewalker~TreeWalker TreeWalker} instance with this range as a boundary.
+     * Creates a {@link module:engine/model/treewalker~ModelTreeWalker TreeWalker} instance with this range as a boundary.
      *
      * For example, to iterate over all items in the entire document root:
      *
@@ -359,48 +359,48 @@ export default class Range extends TypeCheckable {
      * }
      * ```
      *
-     * @param options Object with configuration options. See {@link module:engine/model/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/model/treewalker~ModelTreeWalker}.
      */
     getWalker(options = {}) {
         options.boundaries = this;
-        return new TreeWalker(options);
+        return new ModelTreeWalker(options);
     }
     /**
-     * Returns an iterator that iterates over all {@link module:engine/model/item~Item items} that are in this range and returns
+     * Returns an iterator that iterates over all {@link module:engine/model/item~ModelItem items} that are in this range and returns
      * them.
      *
-     * This method uses {@link module:engine/model/treewalker~TreeWalker} with `boundaries` set to this range and `ignoreElementEnd` option
-     * set to `true`. However it returns only {@link module:engine/model/item~Item model items},
-     * not {@link module:engine/model/treewalker~TreeWalkerValue}.
+     * This method uses {@link module:engine/model/treewalker~ModelTreeWalker} with `boundaries` set to this range and
+     * `ignoreElementEnd` option set to `true`. However it returns only {@link module:engine/model/item~ModelItem model items},
+     * not {@link module:engine/model/treewalker~ModelTreeWalkerValue}.
      *
-     * You may specify additional options for the tree walker. See {@link module:engine/model/treewalker~TreeWalker} for
+     * You may specify additional options for the tree walker. See {@link module:engine/model/treewalker~ModelTreeWalker} for
      * a full list of available options.
      *
-     * @param options Object with configuration options. See {@link module:engine/model/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/model/treewalker~ModelTreeWalker}.
      */
     *getItems(options = {}) {
         options.boundaries = this;
         options.ignoreElementEnd = true;
-        const treeWalker = new TreeWalker(options);
+        const treeWalker = new ModelTreeWalker(options);
         for (const value of treeWalker) {
             yield value.item;
         }
     }
     /**
-     * Returns an iterator that iterates over all {@link module:engine/model/position~Position positions} that are boundaries or
+     * Returns an iterator that iterates over all {@link module:engine/model/position~ModelPosition positions} that are boundaries or
      * contained in this range.
      *
-     * This method uses {@link module:engine/model/treewalker~TreeWalker} with `boundaries` set to this range. However it returns only
-     * {@link module:engine/model/position~Position positions}, not {@link module:engine/model/treewalker~TreeWalkerValue}.
+     * This method uses {@link module:engine/model/treewalker~ModelTreeWalker} with `boundaries` set to this range. However it returns only
+     * {@link module:engine/model/position~ModelPosition positions}, not {@link module:engine/model/treewalker~ModelTreeWalkerValue}.
      *
-     * You may specify additional options for the tree walker. See {@link module:engine/model/treewalker~TreeWalker} for
+     * You may specify additional options for the tree walker. See {@link module:engine/model/treewalker~ModelTreeWalker} for
      * a full list of available options.
      *
-     * @param options Object with configuration options. See {@link module:engine/model/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/model/treewalker~ModelTreeWalker}.
      */
     *getPositions(options = {}) {
         options.boundaries = this;
-        const treeWalker = new TreeWalker(options);
+        const treeWalker = new ModelTreeWalker(options);
         yield treeWalker.position;
         for (const value of treeWalker) {
             yield value.nextPosition;
@@ -429,17 +429,17 @@ export default class Range extends TypeCheckable {
             case 'merge':
                 return [this._getTransformedByMergeOperation(operation)];
         }
-        return [new Range(this.start, this.end)];
+        return [new ModelRange(this.start, this.end)];
     }
     /**
      * Returns a range that is a result of transforming this range by multiple `operations`.
      *
-     * @see ~Range#getTransformedByOperation
+     * @see ~ModelRange#getTransformedByOperation
      * @param operations Operations to transform the range by.
      * @returns Range which is the result of transformation.
      */
     getTransformedByOperations(operations) {
-        const ranges = [new Range(this.start, this.end)];
+        const ranges = [new ModelRange(this.start, this.end)];
         for (const operation of operations) {
             for (let i = 0; i < ranges.length; i++) {
                 const result = ranges[i].getTransformedByOperation(operation);
@@ -463,14 +463,14 @@ export default class Range extends TypeCheckable {
         return ranges;
     }
     /**
-     * Returns an {@link module:engine/model/element~Element} or {@link module:engine/model/documentfragment~DocumentFragment}
+     * Returns an {@link module:engine/model/element~ModelElement} or {@link module:engine/model/documentfragment~ModelDocumentFragment}
      * which is a common ancestor of the range's both ends (in which the entire range is contained).
      */
     getCommonAncestor() {
         return this.start.getCommonAncestor(this.end);
     }
     /**
-     * Returns an {@link module:engine/model/element~Element Element} contained by the range.
+     * Returns an {@link module:engine/model/element~ModelElement Element} contained by the range.
      * The element will be returned when it is the **only** node within the range and **fully–contained**
      * at the same time.
      */
@@ -544,7 +544,7 @@ export default class Range extends TypeCheckable {
             // Fix it by using old `end` which has proper `root`.
             end = this.end.getShiftedBy(-1);
         }
-        return new Range(start, end);
+        return new ModelRange(start, end);
     }
     /**
      * Returns a result of transforming a copy of this range by merge operation.
@@ -566,7 +566,7 @@ export default class Range extends TypeCheckable {
         // <p>F{}z</p>
         //
         if (this.start.isEqual(operation.targetPosition) && this.end.isEqual(operation.deletionPosition)) {
-            return new Range(this.start);
+            return new ModelRange(this.start);
         }
         let start = this.start._getTransformedByMergeOperation(operation);
         let end = this.end._getTransformedByMergeOperation(operation);
@@ -604,7 +604,7 @@ export default class Range extends TypeCheckable {
             //
             if (operation.sourcePosition.isBefore(operation.targetPosition)) {
                 // Case 1.
-                start = Position._createAt(end);
+                start = ModelPosition._createAt(end);
                 start.offset = 0;
             }
             else {
@@ -615,14 +615,14 @@ export default class Range extends TypeCheckable {
                 // In both case 2 and 3 start is at the end of the merge-to element.
                 start = operation.targetPosition;
             }
-            return new Range(start, end);
+            return new ModelRange(start, end);
         }
-        return new Range(start, end);
+        return new ModelRange(start, end);
     }
     /**
-     * Returns an array containing one or two {@link ~Range ranges} that are a result of transforming this
-     * {@link ~Range range} by inserting `howMany` nodes at `insertPosition`. Two {@link ~Range ranges} are
-     * returned if the insertion was inside this {@link ~Range range} and `spread` is set to `true`.
+     * Returns an array containing one or two {@link ~ModelRange ranges} that are a result of transforming this
+     * {@link ~ModelRange range} by inserting `howMany` nodes at `insertPosition`. Two {@link ~ModelRange ranges} are
+     * returned if the insertion was inside this {@link ~ModelRange range} and `spread` is set to `true`.
      *
      * Examples:
      *
@@ -657,20 +657,20 @@ export default class Range extends TypeCheckable {
             // The other part is from spread point to the original end, but transformed by
             // insertion to reflect insertion changes.
             return [
-                new Range(this.start, insertPosition),
-                new Range(insertPosition.getShiftedBy(howMany), this.end._getTransformedByInsertion(insertPosition, howMany))
+                new ModelRange(this.start, insertPosition),
+                new ModelRange(insertPosition.getShiftedBy(howMany), this.end._getTransformedByInsertion(insertPosition, howMany))
             ];
         }
         else {
-            const range = new Range(this.start, this.end);
+            const range = new ModelRange(this.start, this.end);
             range.start = range.start._getTransformedByInsertion(insertPosition, howMany);
             range.end = range.end._getTransformedByInsertion(insertPosition, howMany);
             return [range];
         }
     }
     /**
-     * Returns an array containing {@link ~Range ranges} that are a result of transforming this
-     * {@link ~Range range} by moving `howMany` nodes from `sourcePosition` to `targetPosition`.
+     * Returns an array containing {@link ~ModelRange ranges} that are a result of transforming this
+     * {@link ~ModelRange range} by moving `howMany` nodes from `sourcePosition` to `targetPosition`.
      *
      * @internal
      * @param sourcePosition Position from which nodes are moved.
@@ -683,7 +683,7 @@ export default class Range extends TypeCheckable {
         // Special case for transforming a collapsed range. Just transform it like a position.
         if (this.isCollapsed) {
             const newPos = this.start._getTransformedByMove(sourcePosition, targetPosition, howMany);
-            return [new Range(newPos)];
+            return [new ModelRange(newPos)];
         }
         // Special case for transformation when a part of the range is moved towards the range.
         //
@@ -697,13 +697,13 @@ export default class Range extends TypeCheckable {
         // <div><p>ab</p><p>c[d</p></div><p>e]f</p> --> <div><p>ab</p>{</div>}<p>c[d</p><p>e]f</p>
         //
         // This special case is applied only if the range is to be kept together (not spread).
-        const moveRange = Range._createFromPositionAndShift(sourcePosition, howMany);
+        const moveRange = ModelRange._createFromPositionAndShift(sourcePosition, howMany);
         const insertPosition = targetPosition._getTransformedByDeletion(sourcePosition, howMany);
         if (this.containsPosition(targetPosition) && !spread) {
             if (moveRange.containsPosition(this.start) || moveRange.containsPosition(this.end)) {
                 const start = this.start._getTransformedByMove(sourcePosition, targetPosition, howMany);
                 const end = this.end._getTransformedByMove(sourcePosition, targetPosition, howMany);
-                return [new Range(start, end)];
+                return [new ModelRange(start, end)];
             }
         }
         // Default algorithm.
@@ -713,11 +713,11 @@ export default class Range extends TypeCheckable {
         const common = this.getIntersection(moveRange);
         if (differenceSet.length == 1) {
             // `moveRange` and this range may intersect but may be separate.
-            difference = new Range(differenceSet[0].start._getTransformedByDeletion(sourcePosition, howMany), differenceSet[0].end._getTransformedByDeletion(sourcePosition, howMany));
+            difference = new ModelRange(differenceSet[0].start._getTransformedByDeletion(sourcePosition, howMany), differenceSet[0].end._getTransformedByDeletion(sourcePosition, howMany));
         }
         else if (differenceSet.length == 2) {
             // `moveRange` is inside this range.
-            difference = new Range(this.start, this.end._getTransformedByDeletion(sourcePosition, howMany));
+            difference = new ModelRange(this.start, this.end._getTransformedByDeletion(sourcePosition, howMany));
         } // else, `moveRange` contains this range.
         if (difference) {
             result = difference._getTransformedByInsertion(insertPosition, howMany, common !== null || spread);
@@ -726,7 +726,7 @@ export default class Range extends TypeCheckable {
             result = [];
         }
         if (common) {
-            const transformedCommon = new Range(common.start._getCombined(moveRange.start, insertPosition), common.end._getCombined(moveRange.start, insertPosition));
+            const transformedCommon = new ModelRange(common.start._getCombined(moveRange.start, insertPosition), common.end._getCombined(moveRange.start, insertPosition));
             if (result.length == 2) {
                 result.splice(1, 0, transformedCommon);
             }
@@ -760,10 +760,10 @@ export default class Range extends TypeCheckable {
         if (newEnd == null) {
             newEnd = deletePosition;
         }
-        return new Range(newStart, newEnd);
+        return new ModelRange(newStart, newEnd);
     }
     /**
-     * Creates a new range, spreading from specified {@link module:engine/model/position~Position position} to a position moved by
+     * Creates a new range, spreading from specified {@link module:engine/model/position~ModelPosition position} to a position moved by
      * given `shift`. If `shift` is a negative value, shifted position is treated as the beginning of the range.
      *
      * @internal
@@ -776,22 +776,22 @@ export default class Range extends TypeCheckable {
         return shift > 0 ? new this(start, end) : new this(end, start);
     }
     /**
-     * Creates a range inside an {@link module:engine/model/element~Element element} which starts before the first child of
+     * Creates a range inside an {@link module:engine/model/element~ModelElement element} which starts before the first child of
      * that element and ends after the last child of that element.
      *
      * @internal
      * @param element Element which is a parent for the range.
      */
     static _createIn(element) {
-        return new this(Position._createAt(element, 0), Position._createAt(element, element.maxOffset));
+        return new this(ModelPosition._createAt(element, 0), ModelPosition._createAt(element, element.maxOffset));
     }
     /**
-     * Creates a range that starts before given {@link module:engine/model/item~Item model item} and ends after it.
+     * Creates a range that starts before given {@link module:engine/model/item~ModelItem model item} and ends after it.
      *
      * @internal
      */
     static _createOn(item) {
-        return this._createFromPositionAndShift(Position._createBefore(item), item.offsetSize);
+        return this._createFromPositionAndShift(ModelPosition._createBefore(item), item.offsetSize);
     }
     /**
      * Combines all ranges from the passed array into a one range. At least one range has to be passed.
@@ -815,7 +815,7 @@ export default class Range extends TypeCheckable {
         if (ranges.length === 0) {
             /**
              * At least one range has to be passed to
-             * {@link module:engine/model/range~Range._createFromRanges `Range._createFromRanges()`}.
+             * {@link module:engine/model/range~ModelRange._createFromRanges `Range._createFromRanges()`}.
              *
              * @error range-create-from-ranges-empty-array
              */
@@ -842,7 +842,7 @@ export default class Range extends TypeCheckable {
         // Since ranges are sorted, start with the range with index that is closest to reference range index.
         for (let i = refIndex - 1; i >= 0; i--) {
             if (ranges[i].end.isEqual(result.start)) {
-                result.start = Position._createAt(ranges[i].start);
+                result.start = ModelPosition._createAt(ranges[i].start);
             }
             else {
                 // If ranges are not starting/ending at the same position there is no point in looking further.
@@ -853,7 +853,7 @@ export default class Range extends TypeCheckable {
         // Since ranges are sorted, start with the range with index that is closest to reference range index.
         for (let i = refIndex + 1; i < ranges.length; i++) {
             if (ranges[i].start.isEqual(result.end)) {
-                result.end = Position._createAt(ranges[i].end);
+                result.end = ModelPosition._createAt(ranges[i].end);
             }
             else {
                 // If ranges are not starting/ending at the same position there is no point in looking further.
@@ -870,11 +870,11 @@ export default class Range extends TypeCheckable {
      * @returns `Range` instance created using given plain object.
      */
     static fromJSON(json, doc) {
-        return new this(Position.fromJSON(json.start, doc), Position.fromJSON(json.end, doc));
+        return new this(ModelPosition.fromJSON(json.start, doc), ModelPosition.fromJSON(json.end, doc));
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-Range.prototype.is = function (type) {
+ModelRange.prototype.is = function (type) {
     return type === 'range' || type === 'model:range';
 };

package/src/model/rootelement.d.ts

@@ -5,14 +5,14 @@
 /**
  * @module engine/model/rootelement
  */
-import Element from './element.js';
-import type Document from './document.js';
+import { ModelElement } from './element.js';
+import { type ModelDocument } from './document.js';
 /**
- * Type of {@link module:engine/model/element~Element} that is a root of a model tree.
+ * Type of {@link module:engine/model/element~ModelElement} that is a root of a model tree.
  */
-export default class RootElement extends Element {
+export declare class ModelRootElement extends ModelElement {
     /**
-     * Unique root name used to identify this root element by {@link module:engine/model/document~Document}.
+     * Unique root name used to identify this root element by {@link module:engine/model/document~ModelDocument}.
      */
     readonly rootName: string;
     /**
@@ -34,21 +34,21 @@ export default class RootElement extends Element {
      *
      * @param document Document that is an owner of this root.
      * @param name Node name.
-     * @param rootName Unique root name used to identify this root element by {@link module:engine/model/document~Document}.
+     * @param rootName Unique root name used to identify this root element by {@link module:engine/model/document~ModelDocument}.
      */
-    constructor(document: Document, name: string, rootName?: string);
+    constructor(document: ModelDocument, name: string, rootName?: string);
     /**
-     * {@link module:engine/model/document~Document Document} that owns this root element.
+     * {@link module:engine/model/document~ModelDocument Document} that owns this root element.
      */
-    get document(): Document;
+    get document(): ModelDocument;
     /**
      * Informs if the root element is currently attached to the document, or not.
      *
      * A detached root is equivalent to being removed and cannot contain any children or markers.
      *
      * By default, a newly added root is attached. It can be detached using
-     * {@link module:engine/model/writer~Writer#detachRoot `Writer#detachRoot`}. A detached root can be re-attached again using
-     * {@link module:engine/model/writer~Writer#addRoot `Writer#addRoot`}.
+     * {@link module:engine/model/writer~ModelWriter#detachRoot `Writer#detachRoot`}. A detached root can be re-attached again using
+     * {@link module:engine/model/writer~ModelWriter#addRoot `Writer#addRoot`}.
      */
     isAttached(): boolean;
     /**

package/src/model/rootelement.js

@@ -5,13 +5,13 @@
 /**
  * @module engine/model/rootelement
  */
-import Element from './element.js';
+import { ModelElement } from './element.js';
 /**
- * Type of {@link module:engine/model/element~Element} that is a root of a model tree.
+ * Type of {@link module:engine/model/element~ModelElement} that is a root of a model tree.
  */
-export default class RootElement extends Element {
+export class ModelRootElement extends ModelElement {
     /**
-     * Unique root name used to identify this root element by {@link module:engine/model/document~Document}.
+     * Unique root name used to identify this root element by {@link module:engine/model/document~ModelDocument}.
      */
     rootName;
     /**
@@ -33,7 +33,7 @@ export default class RootElement extends Element {
      *
      * @param document Document that is an owner of this root.
      * @param name Node name.
-     * @param rootName Unique root name used to identify this root element by {@link module:engine/model/document~Document}.
+     * @param rootName Unique root name used to identify this root element by {@link module:engine/model/document~ModelDocument}.
      */
     constructor(document, name, rootName = 'main') {
         super(name);
@@ -41,7 +41,7 @@ export default class RootElement extends Element {
         this.rootName = rootName;
     }
     /**
-     * {@link module:engine/model/document~Document Document} that owns this root element.
+     * {@link module:engine/model/document~ModelDocument Document} that owns this root element.
      */
     get document() {
         return this._document;
@@ -52,8 +52,8 @@ export default class RootElement extends Element {
      * A detached root is equivalent to being removed and cannot contain any children or markers.
      *
      * By default, a newly added root is attached. It can be detached using
-     * {@link module:engine/model/writer~Writer#detachRoot `Writer#detachRoot`}. A detached root can be re-attached again using
-     * {@link module:engine/model/writer~Writer#addRoot `Writer#addRoot`}.
+     * {@link module:engine/model/writer~ModelWriter#detachRoot `Writer#detachRoot`}. A detached root can be re-attached again using
+     * {@link module:engine/model/writer~ModelWriter#addRoot `Writer#addRoot`}.
      */
     isAttached() {
         return this._isAttached;
@@ -69,7 +69,7 @@ export default class RootElement extends Element {
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-RootElement.prototype.is = function (type, name) {
+ModelRootElement.prototype.is = function (type, name) {
     if (!name) {
         return type === 'rootElement' || type === 'model:rootElement' ||
             // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.