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

package/src/model/operation/transform.js

@@ -5,18 +5,18 @@
 /**
  * @module engine/model/operation/transform
  */
-import InsertOperation from './insertoperation.js';
-import AttributeOperation from './attributeoperation.js';
-import RenameOperation from './renameoperation.js';
-import MarkerOperation from './markeroperation.js';
-import MoveOperation from './moveoperation.js';
-import RootAttributeOperation from './rootattributeoperation.js';
-import RootOperation from './rootoperation.js';
-import MergeOperation from './mergeoperation.js';
-import SplitOperation from './splitoperation.js';
-import NoOperation from './nooperation.js';
-import Range from '../range.js';
-import Position from '../position.js';
+import { InsertOperation } from './insertoperation.js';
+import { AttributeOperation } from './attributeoperation.js';
+import { RenameOperation } from './renameoperation.js';
+import { MarkerOperation } from './markeroperation.js';
+import { MoveOperation } from './moveoperation.js';
+import { RootAttributeOperation } from './rootattributeoperation.js';
+import { RootOperation } from './rootoperation.js';
+import { MergeOperation } from './mergeoperation.js';
+import { SplitOperation } from './splitoperation.js';
+import { NoOperation } from './nooperation.js';
+import { ModelRange } from '../range.js';
+import { ModelPosition } from '../position.js';
 import { compareArrays } from '@ckeditor/ckeditor5-utils';
 const transformations = new Map();
 /**
@@ -71,6 +71,7 @@ function noUpdateTransformation(a) {
  * @param b Operation to transform by.
  * @param context Transformation context for this transformation.
  * @returns Transformation result.
+ * @internal
  */
 export function transform(a, b, context = {}) {
     const transformationFunction = getTransformation(a.constructor, b.constructor);
@@ -97,7 +98,7 @@ export function transform(a, b, context = {}) {
  * both transformed `operationsA` and transformed `operationsB` are returned.
  *
  * Note, that the first operation in each set should base on the same document state (
- * {@link module:engine/model/document~Document#version document version}).
+ * {@link module:engine/model/document~ModelDocument#version document version}).
  *
  * It is assumed that `operationsA` are "more important" during conflict resolution between two operations.
  *
@@ -126,7 +127,7 @@ export function transform(a, b, context = {}) {
  * so the removed nodes won't end up back in the document root. When set to `true`, context data will be used.
  * @returns Transformation result.
  */
-export function transformSets(operationsA, operationsB, options) {
+export function transformOperationSets(operationsA, operationsB, options) {
     // Create new arrays so the originally passed arguments are not changed.
     // No need to clone operations, they are cloned as they are transformed.
     operationsA = operationsA.slice();
@@ -420,6 +421,12 @@ class ContextFactory {
                 else if (opA.targetPosition.isAfter(opB.sourcePosition)) {
                     this._setRelation(opA, opB, 'moveTargetAfter');
                 }
+                else if (opA.howMany > 1 && opA.sourcePosition.isEqual(opB.deletionPosition)) {
+                    this._setRelation(opA, opB, 'firstToMoveMerged');
+                }
+                else if (opA.howMany > 1 && opA.sourcePosition.getShiftedBy(opA.howMany - 1).isEqual(opB.deletionPosition)) {
+                    this._setRelation(opA, opB, 'lastToMoveMerged');
+                }
             }
             else if (opB instanceof MoveOperation) {
                 if (opA.targetPosition.isEqual(opB.sourcePosition) || opA.targetPosition.isBefore(opB.sourcePosition)) {
@@ -441,7 +448,7 @@ class ContextFactory {
                     this._setRelation(opA, opB, 'splitBefore');
                 }
                 else {
-                    const range = Range._createFromPositionAndShift(opB.sourcePosition, opB.howMany);
+                    const range = ModelRange._createFromPositionAndShift(opB.sourcePosition, opB.howMany);
                     if (opA.splitPosition.hasSameParentAs(opB.sourcePosition) && range.containsPosition(opA.splitPosition)) {
                         // TODO: Potential bug -- we are saving offset value directly and it is not later updated during OT.
                         // TODO: This may cause a bug it here was an non-undone operation that may have impacted this offset.
@@ -646,7 +653,7 @@ function handlePartialMarkerOperations(operations) {
     }
     for (const { op, ranges } of markerOps.values()) {
         if (ranges.length) {
-            op.newRange = Range._createFromRanges(ranges);
+            op.newRange = ModelRange._createFromRanges(ranges);
         }
         else {
             op.newRange = null;
@@ -769,7 +776,7 @@ function _getComplementaryAttributeOperations(insertOperation, key, newValue) {
     if (insertValue == newValue) {
         return null;
     }
-    const range = new Range(insertOperation.position, insertOperation.position.getShiftedBy(insertOperation.howMany));
+    const range = new ModelRange(insertOperation.position, insertOperation.position.getShiftedBy(insertOperation.howMany));
     return new AttributeOperation(range, key, insertValue, newValue, 0);
 }
 setTransformation(AttributeOperation, MergeOperation, (a, b) => {
@@ -781,7 +788,7 @@ setTransformation(AttributeOperation, MergeOperation, (a, b) => {
     //
     if (a.range.start.hasSameParentAs(b.deletionPosition)) {
         if (a.range.containsPosition(b.deletionPosition) || a.range.start.isEqual(b.deletionPosition)) {
-            ranges.push(Range._createFromPositionAndShift(b.graveyardPosition, 1));
+            ranges.push(ModelRange._createFromPositionAndShift(b.graveyardPosition, 1));
         }
     }
     const range = a.range._getTransformedByMergeOperation(b);
@@ -811,7 +818,7 @@ setTransformation(AttributeOperation, MoveOperation, (a, b) => {
  * track only how those nodes have been affected by `MoveOperation`.
  */
 function _breakRangeByMoveOperation(range, moveOp) {
-    const moveRange = Range._createFromPositionAndShift(moveOp.sourcePosition, moveOp.howMany);
+    const moveRange = ModelRange._createFromPositionAndShift(moveOp.sourcePosition, moveOp.howMany);
     // We are transforming `range` (original range) by `moveRange` (range moved by move operation). As usual when it comes to
     // transforming a ranges, we may have a common part of the ranges and we may have a difference part (zero to two ranges).
     let common = null;
@@ -894,7 +901,7 @@ setTransformation(AttributeOperation, SplitOperation, (a, b) => {
     //
     if (a.range.start.hasSameParentAs(b.splitPosition) && a.range.containsPosition(b.splitPosition)) {
         const secondPart = a.clone();
-        secondPart.range = new Range(b.moveTargetPosition.clone(), a.range.end._getCombined(b.splitPosition, b.moveTargetPosition));
+        secondPart.range = new ModelRange(b.moveTargetPosition.clone(), a.range.end._getCombined(b.splitPosition, b.moveTargetPosition));
         a.range.end = b.splitPosition.clone();
         a.range.end.stickiness = 'toPrevious';
         return [a, secondPart];
@@ -994,7 +1001,7 @@ setTransformation(MarkerOperation, MergeOperation, (a, b) => {
 setTransformation(MarkerOperation, MoveOperation, (a, b) => {
     const result = [a];
     if (a.oldRange) {
-        a.oldRange = Range._createFromRanges(a.oldRange._getTransformedByMoveOperation(b));
+        a.oldRange = ModelRange._createFromRanges(a.oldRange._getTransformedByMoveOperation(b));
     }
     if (a.newRange) {
         // In many simple cases the marker range will be kept integral after the transformation. For example, if some nodes
@@ -1050,7 +1057,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     // <p>Foo</p>[<p>Bar]</p>  -- merge ->  <p>Foo[Bar]</p>  -- default split ->  <p>Foo</p><p>[Bar]</p>
                     // <p>Foo</p>[<p>Bar]</p>  -- merge ->  <p>Foo[Bar]</p>  --- fixed split -->  <p>Foo</p>[<p>Bar]</p>
                     //
-                    a.newRange.start = Position._createAt(b.insertionPosition);
+                    a.newRange.start = ModelPosition._createAt(b.insertionPosition);
                 }
                 else if (context.abRelation.wasInLeftElement) {
                     // If the marker start was initially in the "left" element, keep the start position there.
@@ -1058,7 +1065,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     // <p>Foo[</p><p>Bar]</p>  -- merge ->  <p>Foo[Bar]</p>  -- default split ->  <p>Foo</p><p>[Bar]</p>
                     // <p>Foo[</p><p>Bar]</p>  -- merge ->  <p>Foo[Bar]</p>  --- fixed split -->  <p>Foo[</p><p>Bar]</p>
                     //
-                    a.newRange.start = Position._createAt(a.newRange.start);
+                    a.newRange.start = ModelPosition._createAt(a.newRange.start);
                 }
                 else {
                     // Finally, the start position must have been at the beginning of the "right" (merged) element.
@@ -1071,7 +1078,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     // <p>Foo</p><p>[]Bar</p>  -- merge ->  <p>Foo[]Bar</p>  -- default split ->  <p>Foo[]</p><p>Bar</p>
                     // <p>Foo</p><p>[]Bar</p>  -- merge ->  <p>Foo[]Bar</p>  --- fixed split -->  <p>Foo</p><p>[]Bar</p>
                     //
-                    a.newRange.start = Position._createAt(b.moveTargetPosition);
+                    a.newRange.start = ModelPosition._createAt(b.moveTargetPosition);
                 }
             }
             else {
@@ -1089,7 +1096,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     // <p>[Foo</p>]<p>Bar</p>  -- merge ->  <p>[Foo]Bar</p>  -- default split ->  <p>[Foo]</p><p>Bar</p>
                     // <p>[Foo</p>]<p>Bar</p>  -- merge ->  <p>[Foo]Bar</p>  --- fixed split -->  <p>[Foo</p>]<p>Bar</p>
                     //
-                    a.newRange.end = Position._createAt(b.insertionPosition);
+                    a.newRange.end = ModelPosition._createAt(b.insertionPosition);
                 }
                 else if (context.abRelation.wasInRightElement) {
                     // If the marker was initially in the "right" element, keep the end position there.
@@ -1097,7 +1104,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     // <p>[Foo</p><p>]Bar</p>  -- merge ->  <p>[Foo]Bar</p>  -- default split ->  <p>[Foo]</p><p>Bar</p>
                     // <p>[Foo</p><p>]Bar</p>  -- merge ->  <p>[Foo]Bar</p>  --- fixed split -->  <p>[Foo</p><p>]Bar</p>
                     //
-                    a.newRange.end = Position._createAt(b.moveTargetPosition);
+                    a.newRange.end = ModelPosition._createAt(b.moveTargetPosition);
                 }
                 else {
                     // Finally, the end position must have been at the end of the "left" (merged) element.
@@ -1105,7 +1112,7 @@ setTransformation(MarkerOperation, SplitOperation, (a, b, context) => {
                     //
                     // Note, that this is what the default transformation does, so we could use `aNewRange.end`, but this is more clear.
                     //
-                    a.newRange.end = Position._createAt(a.newRange.end);
+                    a.newRange.end = ModelPosition._createAt(a.newRange.end);
                 }
             }
             else {
@@ -1154,7 +1161,7 @@ setTransformation(MergeOperation, MergeOperation, (a, b, context) => {
         else {
             const path = b.graveyardPosition.path.slice();
             path.push(0);
-            a.sourcePosition = new Position(b.graveyardPosition.root, path);
+            a.sourcePosition = new ModelPosition(b.graveyardPosition.root, path);
             a.howMany = 0;
             return [a];
         }
@@ -1232,7 +1239,7 @@ setTransformation(MergeOperation, MoveOperation, (a, b, context) => {
     //
     // The exception to this rule would be if the remove operation was later undone.
     //
-    const removedRange = Range._createFromPositionAndShift(b.sourcePosition, b.howMany);
+    const removedRange = ModelRange._createFromPositionAndShift(b.sourcePosition, b.howMany);
     if (b.type == 'remove' && !context.bWasUndone) {
         if (a.deletionPosition.hasSameParentAs(b.sourcePosition) && removedRange.containsPosition(a.sourcePosition)) {
             return [new NoOperation(0)];
@@ -1434,7 +1441,7 @@ setTransformation(MergeOperation, SplitOperation, (a, b, context) => {
 });
 // -----------------------
 setTransformation(MoveOperation, InsertOperation, (a, b) => {
-    const moveRange = Range._createFromPositionAndShift(a.sourcePosition, a.howMany);
+    const moveRange = ModelRange._createFromPositionAndShift(a.sourcePosition, a.howMany);
     const transformed = moveRange._getTransformedByInsertOperation(b, false)[0];
     a.sourcePosition = transformed.start;
     a.howMany = transformed.end.offset - transformed.start.offset;
@@ -1454,8 +1461,8 @@ setTransformation(MoveOperation, MoveOperation, (a, b, context) => {
     // Setting and evaluating some variables that will be used in special cases and default algorithm.
     //
     // Create ranges from `MoveOperations` properties.
-    const rangeA = Range._createFromPositionAndShift(a.sourcePosition, a.howMany);
-    const rangeB = Range._createFromPositionAndShift(b.sourcePosition, b.howMany);
+    const rangeA = ModelRange._createFromPositionAndShift(a.sourcePosition, a.howMany);
+    const rangeB = ModelRange._createFromPositionAndShift(b.sourcePosition, b.howMany);
     // Assign `context.aIsStrong` to a different variable, because the value may change during execution of
     // this algorithm and we do not want to override original `context.aIsStrong` that will be used in later transformations.
     let aIsStrong = context.aIsStrong;
@@ -1614,22 +1621,31 @@ setTransformation(MoveOperation, SplitOperation, (a, b, context) => {
     }
     // Case 1:
     //
+    // Split operation brings back an element that was earlier a part of the move operation (first element of the original move operation).
+    //
+    if (a.sourcePosition.isEqual(b.insertionPosition) && context.abRelation == 'firstToMoveMerged') {
+        a.howMany++;
+        a.targetPosition = newTargetPosition;
+        return [a];
+    }
+    // Case 2:
+    //
     // Last element in the moved range got split.
     //
     // In this case the default range transformation will not work correctly as the element created by
     // split operation would be outside the range. The range to move needs to be fixed manually.
     //
-    const moveRange = Range._createFromPositionAndShift(a.sourcePosition, a.howMany);
+    const moveRange = ModelRange._createFromPositionAndShift(a.sourcePosition, a.howMany);
     if (moveRange.end.isEqual(b.insertionPosition)) {
         // Do it only if this is a "natural" split, not a one that comes from undo.
         // If this is undo split, only `targetPosition` needs to be changed (if the move is a remove).
-        if (!b.graveyardPosition) {
+        if (!b.graveyardPosition || context.abRelation == 'lastToMoveMerged') {
             a.howMany++;
         }
         a.targetPosition = newTargetPosition;
         return [a];
     }
-    // Case 2:
+    // Case 3:
     //
     // Split happened between the moved nodes. In this case two ranges to move need to be generated.
     //
@@ -1646,15 +1662,15 @@ setTransformation(MoveOperation, SplitOperation, (a, b, context) => {
     // <p>F</p><p>r</p><p>Xyzozba</p>
     //
     if (moveRange.start.hasSameParentAs(b.splitPosition) && moveRange.containsPosition(b.splitPosition)) {
-        let rightRange = new Range(b.splitPosition, moveRange.end);
+        let rightRange = new ModelRange(b.splitPosition, moveRange.end);
         rightRange = rightRange._getTransformedBySplitOperation(b);
         const ranges = [
-            new Range(moveRange.start, b.splitPosition),
+            new ModelRange(moveRange.start, b.splitPosition),
             rightRange
         ];
         return _makeMoveOperationsFromRanges(ranges, newTargetPosition);
     }
-    // Case 3:
+    // Case 4:
     //
     // Move operation targets at the split position. We need to decide if the nodes should be inserted
     // at the end of the split element or at the beginning of the new element.
@@ -1662,7 +1678,7 @@ setTransformation(MoveOperation, SplitOperation, (a, b, context) => {
     if (a.targetPosition.isEqual(b.splitPosition) && context.abRelation == 'insertAtSource') {
         newTargetPosition = b.moveTargetPosition;
     }
-    // Case 4:
+    // Case 5:
     //
     // Move operation targets just after the split element. We need to decide if the nodes should be inserted
     // between two parts of split element, or after the new element.
@@ -1690,20 +1706,20 @@ setTransformation(MoveOperation, SplitOperation, (a, b, context) => {
     //
     const transformed = moveRange._getTransformedBySplitOperation(b);
     const ranges = [transformed];
-    // Case 5:
+    // Case 6:
     //
     // Moved range contains graveyard element used by split operation. Add extra move operation to the result.
     //
     if (b.graveyardPosition) {
         const movesGraveyardElement = moveRange.start.isEqual(b.graveyardPosition) || moveRange.containsPosition(b.graveyardPosition);
         if (a.howMany > 1 && movesGraveyardElement && !context.aWasUndone) {
-            ranges.push(Range._createFromPositionAndShift(b.insertionPosition, 1));
+            ranges.push(ModelRange._createFromPositionAndShift(b.insertionPosition, 1));
         }
     }
     return _makeMoveOperationsFromRanges(ranges, newTargetPosition);
 });
 setTransformation(MoveOperation, MergeOperation, (a, b, context) => {
-    const movedRange = Range._createFromPositionAndShift(a.sourcePosition, a.howMany);
+    const movedRange = ModelRange._createFromPositionAndShift(a.sourcePosition, a.howMany);
     if (b.deletionPosition.hasSameParentAs(a.sourcePosition) && movedRange.containsPosition(b.sourcePosition)) {
         if (a.type == 'remove' && !context.forceWeakRemove) {
             // Case 1:
@@ -1730,7 +1746,7 @@ setTransformation(MoveOperation, MergeOperation, (a, b, context) => {
                 const gyMove = new MoveOperation(gyMoveSource, 1, gyMoveTarget, 0);
                 const splitNodesMoveTargetPath = gyMove.getMovedRangeStart().path.slice();
                 splitNodesMoveTargetPath.push(0);
-                const splitNodesMoveTarget = new Position(gyMove.targetPosition.root, splitNodesMoveTargetPath);
+                const splitNodesMoveTarget = new ModelPosition(gyMove.targetPosition.root, splitNodesMoveTargetPath);
                 splitNodesMoveSource = splitNodesMoveSource._getTransformedByMove(gyMoveSource, gyMoveTarget, 1);
                 const splitNodesMove = new MoveOperation(splitNodesMoveSource, b.howMany, splitNodesMoveTarget, 0);
                 results.push(gyMove);
@@ -1759,7 +1775,7 @@ setTransformation(MoveOperation, MergeOperation, (a, b, context) => {
     }
     // The default case.
     //
-    const moveRange = Range._createFromPositionAndShift(a.sourcePosition, a.howMany);
+    const moveRange = ModelRange._createFromPositionAndShift(a.sourcePosition, a.howMany);
     const transformed = moveRange._getTransformedByMergeOperation(b);
     a.sourcePosition = transformed.start;
     a.howMany = transformed.end.offset - transformed.start.offset;
@@ -1910,8 +1926,8 @@ setTransformation(SplitOperation, MergeOperation, (a, b, context) => {
     if (!a.graveyardPosition && !context.bWasUndone && a.splitPosition.hasSameParentAs(b.sourcePosition)) {
         const splitPath = b.graveyardPosition.path.slice();
         splitPath.push(0);
-        const splitPosition = new Position(b.graveyardPosition.root, splitPath);
-        const insertionPosition = SplitOperation.getInsertionPosition(new Position(b.graveyardPosition.root, splitPath));
+        const splitPosition = new ModelPosition(b.graveyardPosition.root, splitPath);
+        const insertionPosition = SplitOperation.getInsertionPosition(new ModelPosition(b.graveyardPosition.root, splitPath));
         const additionalSplit = new SplitOperation(splitPosition, 0, insertionPosition, null, 0);
         a.splitPosition = a.splitPosition._getTransformedByMergeOperation(b);
         a.insertionPosition = SplitOperation.getInsertionPosition(a.splitPosition);
@@ -1935,7 +1951,7 @@ setTransformation(SplitOperation, MergeOperation, (a, b, context) => {
     return [a];
 });
 setTransformation(SplitOperation, MoveOperation, (a, b, context) => {
-    const rangeToMove = Range._createFromPositionAndShift(b.sourcePosition, b.howMany);
+    const rangeToMove = ModelRange._createFromPositionAndShift(b.sourcePosition, b.howMany);
     if (a.graveyardPosition) {
         // Case 1:
         //
@@ -1949,7 +1965,7 @@ setTransformation(SplitOperation, MoveOperation, (a, b, context) => {
             const newParentPosition = a.graveyardPosition._getTransformedByMoveOperation(b);
             const newTargetPath = newParentPosition.path.slice();
             newTargetPath.push(0);
-            const newTargetPosition = new Position(newParentPosition.root, newTargetPath);
+            const newTargetPosition = new ModelPosition(newParentPosition.root, newTargetPath);
             const moveOp = new MoveOperation(sourcePosition, a.howMany, newTargetPosition, 0);
             return [moveOp];
         }
@@ -1973,6 +1989,7 @@ setTransformation(SplitOperation, MoveOperation, (a, b, context) => {
         const { howMany, offset } = context.abRelation;
         a.howMany += howMany;
         a.splitPosition = a.splitPosition.getShiftedBy(offset);
+        // TODO: `insertionPosition` change missing?
         return [a];
     }
     // Case 3:
@@ -2119,7 +2136,7 @@ setTransformation(SplitOperation, SplitOperation, (a, b, context) => {
     if (b.splitPosition.isEqual(a.insertionPosition) && context.baRelation == 'splitBefore') {
         const newPositionPath = b.insertionPosition.path.slice();
         newPositionPath.push(0);
-        const newPosition = new Position(b.insertionPosition.root, newPositionPath);
+        const newPosition = new ModelPosition(b.insertionPosition.root, newPositionPath);
         const moveOp = new MoveOperation(a.insertionPosition, 1, newPosition, 0);
         return [a, moveOp];
     }

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

@@ -5,12 +5,12 @@
 /**
  * @module engine/model/operation/utils
  */
-import Node from '../node.js';
-import Range from '../range.js';
-import type DocumentFragment from '../documentfragment.js';
-import type Item from '../item.js';
-import type NodeList from '../nodelist.js';
-import type Position from '../position.js';
+import { ModelNode } from '../node.js';
+import { ModelRange } from '../range.js';
+import { type ModelDocumentFragment } from '../documentfragment.js';
+import { type ModelItem } from '../item.js';
+import { type ModelNodeList } from '../nodelist.js';
+import { type ModelPosition } from '../position.js';
 /**
  * Inserts given nodes at given position.
  *
@@ -19,23 +19,23 @@ import type Position from '../position.js';
  * @param nodes Nodes to insert.
  * @returns Range spanning over inserted elements.
  */
-export declare function _insert(position: Position, nodes: NodeSet): Range;
+export declare function _insert(position: ModelPosition, nodes: ModelNodeSet): ModelRange;
 /**
- * Removed nodes in given range. Only {@link module:engine/model/range~Range#isFlat flat} ranges are accepted.
+ * Removed nodes in given range. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
  *
  * @internal
  * @param range Range containing nodes to remove.
  */
-export declare function _remove(this: any, range: Range): Array<Node>;
+export declare function _remove(this: any, range: ModelRange): Array<ModelNode>;
 /**
- * Moves nodes in given range to given target position. Only {@link module:engine/model/range~Range#isFlat flat} ranges are accepted.
+ * Moves nodes in given range to given target position. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
  *
  * @internal
  * @param sourceRange Range containing nodes to move.
  * @param targetPosition Position to which nodes should be moved.
  * @returns Range containing moved nodes.
  */
-export declare function _move(this: any, sourceRange: Range, targetPosition: Position): Range;
+export declare function _move(this: any, sourceRange: ModelRange, targetPosition: ModelPosition): ModelRange;
 /**
  * Sets given attribute on nodes in given range. The attributes are only set on top-level nodes of the range, not on its children.
  *
@@ -44,28 +44,29 @@ export declare function _move(this: any, sourceRange: Range, targetPosition: Pos
  * @param key Key of attribute to set.
  * @param value Attribute value.
  */
-export declare function _setAttribute(range: Range, key: string, value: unknown): void;
+export declare function _setAttribute(range: ModelRange, key: string, value: unknown): void;
 /**
- * Normalizes given object or an array of objects to an array of {@link module:engine/model/node~Node nodes}. See
- * {@link ~NodeSet NodeSet} for details on how normalization is performed.
+ * Normalizes given object or an array of objects to an array of {@link module:engine/model/node~ModelNode nodes}. See
+ * {@link ~ModelNodeSet NodeSet} for details on how normalization is performed.
  *
  * @internal
  * @param nodes Objects to normalize.
  * @returns Normalized nodes.
  */
-export declare function _normalizeNodes(nodes: NodeSet): Array<Node>;
+export declare function _normalizeNodes(nodes: ModelNodeSet): Array<ModelNode>;
 /**
- * Value that can be normalized to an array of {@link module:engine/model/node~Node nodes}.
+ * Value that can be normalized to an array of {@link module:engine/model/node~ModelNode nodes}.
  *
  * Non-arrays are normalized as follows:
- * * {@link module:engine/model/node~Node Node} is left as is,
- * * {@link module:engine/model/textproxy~TextProxy TextProxy} and `string` are normalized to {@link module:engine/model/text~Text Text},
- * * {@link module:engine/model/nodelist~NodeList NodeList} is normalized to an array containing all nodes that are in that node list,
- * * {@link module:engine/model/documentfragment~DocumentFragment DocumentFragment} is normalized to an array containing all of it's
- * * children.
+ * * {@link module:engine/model/node~ModelNode Node} is left as is,
+ * * {@link module:engine/model/textproxy~ModelTextProxy TextProxy} and `string` are normalized to
+ * {@link module:engine/model/text~ModelText Text},
+ * * {@link module:engine/model/nodelist~ModelNodeList NodeList} is normalized to an array containing all nodes that are in that node list,
+ * * {@link module:engine/model/documentfragment~ModelDocumentFragment ModelDocumentFragment} is normalized to an array containing all of
+ * it's children.
  *
  * Arrays are processed item by item like non-array values and flattened to one array. Normalization always results in
- * a flat array of {@link module:engine/model/node~Node nodes}. Consecutive text nodes (or items normalized to text nodes) will be
+ * a flat array of {@link module:engine/model/node~ModelNode nodes}. Consecutive text nodes (or items normalized to text nodes) will be
  * merged if they have same attributes.
  */
-export type NodeSet = Item | string | NodeList | DocumentFragment | Iterable<Item | string | NodeList | DocumentFragment>;
+export type ModelNodeSet = ModelItem | string | ModelNodeList | ModelDocumentFragment | Iterable<ModelItem | string | ModelNodeList | ModelDocumentFragment>;

package/src/model/operation/utils.js

@@ -5,10 +5,10 @@
 /**
  * @module engine/model/operation/utils
  */
-import Node from '../node.js';
-import Range from '../range.js';
-import Text from '../text.js';
-import TextProxy from '../textproxy.js';
+import { ModelNode } from '../node.js';
+import { ModelRange } from '../range.js';
+import { ModelText } from '../text.js';
+import { ModelTextProxy } from '../textproxy.js';
 import { CKEditorError, isIterable } from '@ckeditor/ckeditor5-utils';
 /**
  * Inserts given nodes at given position.
@@ -32,10 +32,10 @@ export function _insert(position, nodes) {
     // Merge text nodes, if possible. Merging is needed only at points where inserted nodes "touch" "old" nodes.
     _mergeNodesAtIndex(parent, index + normalizedNodes.length);
     _mergeNodesAtIndex(parent, index);
-    return new Range(position, position.getShiftedBy(offset));
+    return new ModelRange(position, position.getShiftedBy(offset));
 }
 /**
- * Removed nodes in given range. Only {@link module:engine/model/range~Range#isFlat flat} ranges are accepted.
+ * Removed nodes in given range. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
  *
  * @internal
  * @param range Range containing nodes to remove.
@@ -61,7 +61,7 @@ export function _remove(range) {
     return removed;
 }
 /**
- * Moves nodes in given range to given target position. Only {@link module:engine/model/range~Range#isFlat flat} ranges are accepted.
+ * Moves nodes in given range to given target position. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
  *
  * @internal
  * @param sourceRange Range containing nodes to move.
@@ -97,7 +97,7 @@ export function _setAttribute(range, key, value) {
     _splitNodeAtPosition(range.end);
     // Iterate over all items in the range.
     for (const item of range.getItems({ shallow: true })) {
-        // Iterator will return `TextProxy` instances but we know that those text proxies will
+        // Iterator will return `ModelTextProxy` instances but we know that those text proxies will
         // always represent full text nodes (this is guaranteed thanks to splitting we did before).
         // So, we can operate on those text proxies' text nodes.
         const node = item.is('$textProxy') ? item.textNode : item;
@@ -114,8 +114,8 @@ export function _setAttribute(range, key, value) {
     _mergeNodesAtIndex(range.end.parent, range.end.index);
 }
 /**
- * Normalizes given object or an array of objects to an array of {@link module:engine/model/node~Node nodes}. See
- * {@link ~NodeSet NodeSet} for details on how normalization is performed.
+ * Normalizes given object or an array of objects to an array of {@link module:engine/model/node~ModelNode nodes}. See
+ * {@link ~ModelNodeSet NodeSet} for details on how normalization is performed.
  *
  * @internal
  * @param nodes Objects to normalize.
@@ -125,12 +125,12 @@ export function _normalizeNodes(nodes) {
     const normalized = [];
     function convert(nodes) {
         if (typeof nodes == 'string') {
-            normalized.push(new Text(nodes));
+            normalized.push(new ModelText(nodes));
         }
-        else if (nodes instanceof TextProxy) {
-            normalized.push(new Text(nodes.data, nodes.getAttributes()));
+        else if (nodes instanceof ModelTextProxy) {
+            normalized.push(new ModelText(nodes.data, nodes.getAttributes()));
         }
-        else if (nodes instanceof Node) {
+        else if (nodes instanceof ModelNode) {
             normalized.push(nodes);
         }
         else if (isIterable(nodes)) {
@@ -149,16 +149,16 @@ export function _normalizeNodes(nodes) {
     for (let i = 1; i < normalized.length; i++) {
         const node = normalized[i];
         const prev = normalized[i - 1];
-        if (node instanceof Text && prev instanceof Text && _haveSameAttributes(node, prev)) {
+        if (node instanceof ModelText && prev instanceof ModelText && _haveSameAttributes(node, prev)) {
             // Doing this instead changing `prev.data` because `data` is readonly.
-            normalized.splice(i - 1, 2, new Text(prev.data + node.data, prev.getAttributes()));
+            normalized.splice(i - 1, 2, new ModelText(prev.data + node.data, prev.getAttributes()));
             i--;
         }
     }
     return normalized;
 }
 /**
- * Checks if nodes before and after given index in given element are {@link module:engine/model/text~Text text nodes} and
+ * Checks if nodes before and after given index in given element are {@link module:engine/model/text~ModelText text nodes} and
  * merges them into one node if they have same attributes.
  *
  * Merging is done by removing two text nodes and inserting a new text node containing data from both merged text nodes.
@@ -172,7 +172,7 @@ function _mergeNodesAtIndex(element, index) {
     // Check if both of those nodes are text objects with same attributes.
     if (nodeBefore && nodeAfter && nodeBefore.is('$text') && nodeAfter.is('$text') && _haveSameAttributes(nodeBefore, nodeAfter)) {
         // Append text of text node after index to the before one.
-        const mergedNode = new Text(nodeBefore.data + nodeAfter.data, nodeBefore.getAttributes());
+        const mergedNode = new ModelText(nodeBefore.data + nodeAfter.data, nodeBefore.getAttributes());
         // Remove separate text nodes.
         element._removeChildren(index - 1, 2);
         // Insert merged text node.
@@ -192,8 +192,8 @@ function _splitNodeAtPosition(position) {
         const offsetDiff = position.offset - textNode.startOffset;
         const index = textNode.index;
         element._removeChildren(index, 1);
-        const firstPart = new Text(textNode.data.substr(0, offsetDiff), textNode.getAttributes());
-        const secondPart = new Text(textNode.data.substr(offsetDiff), textNode.getAttributes());
+        const firstPart = new ModelText(textNode.data.substr(0, offsetDiff), textNode.getAttributes());
+        const secondPart = new ModelText(textNode.data.substr(offsetDiff), textNode.getAttributes());
         element._insertChild(index, [firstPart, secondPart]);
     }
 }