8
0
فهرست منبع

Other: Make Range immutable.

Maciej Gołaszewski 8 سال پیش
والد
کامیت
3f97a18184

+ 3 - 2
packages/ckeditor5-engine/src/conversion/viewconversiondispatcher.js

@@ -303,10 +303,11 @@ function extractMarkersFromModelFragment( modelItem ) {
 
 		// When marker of given name is not stored it means that we have found the beginning of the range.
 		if ( !markers.has( markerName ) ) {
-			markers.set( markerName, new ModelRange( ModelPosition.createFromPosition( currentPosition ) ) );
+			markers.set( markerName, new ModelRange( currentPosition ) );
 		// Otherwise is means that we have found end of the marker range.
 		} else {
-			markers.get( markerName ).end = ModelPosition.createFromPosition( currentPosition );
+			const oldMarker = markers.get( markerName );
+			markers.set( markerName, new ModelRange( oldMarker.start, currentPosition ) );
 		}
 
 		// Remove marker element from DocumentFragment.

+ 1 - 1
packages/ckeditor5-engine/src/dev-utils/view.js

@@ -550,7 +550,7 @@ class RangeParser {
 			if ( item.bracket == ELEMENT_RANGE_START_TOKEN || item.bracket == TEXT_RANGE_START_TOKEN ) {
 				range = new Range( item.position, item.position );
 			} else {
-				range.end = item.position;
+				range = new Range( range.start, item.position );
 				ranges.push( range );
 				range = null;
 			}

+ 3 - 3
packages/ckeditor5-engine/src/model/liverange.js

@@ -7,7 +7,7 @@
  * @module engine/model/liverange
  */
 
-import Range from './range';
+import Range, { setStart, setEnd } from './range';
 import EmitterMixin from '@ckeditor/ckeditor5-utils/src/emittermixin';
 import mix from '@ckeditor/ckeditor5-utils/src/mix';
 
@@ -178,8 +178,8 @@ function transform( changeType, deltaType, batch, targetRange, sourcePosition )
 		// If range boundaries have changed, fire `change:range` event.
 		const oldRange = Range.createFromRange( this );
 
-		this.start = updated.start;
-		this.end = updated.end;
+		setStart( this, updated.start );
+		setEnd( this, updated.end );
 
 		this.fire( 'change:range', oldRange, {
 			type: changeType,

+ 38 - 23
packages/ckeditor5-engine/src/model/operation/transform.js

@@ -179,25 +179,29 @@ const ot = {
 				// Take the start and the end of the range and transform them by deletion of moved nodes.
 				// Note that if rangeB was inside AttributeOperation range, only difference.end will be transformed.
 				// This nicely covers the joining simplification we did in the previous step.
-				difference.start = difference.start._getTransformedByDeletion( b.sourcePosition, b.howMany );
-				difference.end = difference.end._getTransformedByDeletion( b.sourcePosition, b.howMany );
+				const range = new Range(
+					difference.start._getTransformedByDeletion( b.sourcePosition, b.howMany ),
+					difference.end._getTransformedByDeletion( b.sourcePosition, b.howMany )
+				);
 
 				// MoveOperation pastes nodes into target position. We acknowledge this by proper transformation.
 				// Note that since we operate on transformed difference range, we should transform by
 				// previously transformed target position.
 				// Note that we do not use Position._getTransformedByMove on range boundaries because we need to
 				// transform by insertion a range as a whole, since newTargetPosition might be inside that range.
-				ranges = difference._getTransformedByInsertion( b.getMovedRangeStart(), b.howMany, true, false ).reverse();
+				ranges = range._getTransformedByInsertion( b.getMovedRangeStart(), b.howMany, true, false ).reverse();
 			}
 
 			if ( common !== null ) {
 				// Here we do not need to worry that newTargetPosition is inside moved range, because that
 				// would mean that the MoveOperation targets into itself, and that is incorrect operation.
 				// Instead, we calculate the new position of that part of original range.
-				common.start = common.start._getCombined( b.sourcePosition, b.getMovedRangeStart() );
-				common.end = common.end._getCombined( b.sourcePosition, b.getMovedRangeStart() );
+				const range = new Range(
+					common.start._getCombined( b.sourcePosition, b.getMovedRangeStart() ),
+					common.end._getCombined( b.sourcePosition, b.getMovedRangeStart() )
+				);
 
-				ranges.push( common );
+				ranges.push( range );
 			}
 
 			// Map transformed range(s) to operations and return them.
@@ -376,7 +380,7 @@ const ot = {
 			// 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 );
+			let rangeA = Range.createFromPositionAndShift( a.sourcePosition, a.howMany );
 			const rangeB = Range.createFromPositionAndShift( b.sourcePosition, b.howMany );
 
 			// Assign `context.isStrong` to a different variable, because the value may change during execution of
@@ -428,8 +432,10 @@ const ot = {
 			if ( bTargetsToA && rangeA.containsRange( rangeB, true ) ) {
 				// There is a mini-special case here, where `rangeB` is on other level than `rangeA`. That's why
 				// we need to transform `a` operation anyway.
-				rangeA.start = rangeA.start._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !includeB );
-				rangeA.end = rangeA.end._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, includeB );
+				rangeA = new Range(
+					rangeA.start._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !includeB ),
+					rangeA.end._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, includeB )
+				);
 
 				return makeMoveOperationsFromRanges( [ rangeA ], newTargetPosition, a );
 			}
@@ -444,8 +450,10 @@ const ot = {
 			if ( aTargetsToB && rangeB.containsRange( rangeA, true ) ) {
 				// `a` operation is "moved together" with `b` operation.
 				// Here, just move `rangeA` "inside" `rangeB`.
-				rangeA.start = rangeA.start._getCombined( b.sourcePosition, b.getMovedRangeStart() );
-				rangeA.end = rangeA.end._getCombined( b.sourcePosition, b.getMovedRangeStart() );
+				rangeA = new Range(
+					rangeA.start._getCombined( b.sourcePosition, b.getMovedRangeStart() ),
+					rangeA.end._getCombined( b.sourcePosition, b.getMovedRangeStart() )
+				);
 
 				return makeMoveOperationsFromRanges( [ rangeA ], newTargetPosition, a );
 			}
@@ -466,8 +474,10 @@ const ot = {
 				// Transform `rangeA` by `b` operation and make operation out of it, and that's all.
 				// Note that this is a simplified version of default case, but here we treat the common part (whole `rangeA`)
 				// like a one difference part.
-				rangeA.start = rangeA.start._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !includeB );
-				rangeA.end = rangeA.end._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, includeB );
+				rangeA = new Range(
+					rangeA.start._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !includeB ),
+					rangeA.end._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, includeB )
+				);
 
 				return makeMoveOperationsFromRanges( [ rangeA ], newTargetPosition, a );
 			}
@@ -500,10 +510,12 @@ const ot = {
 			// This is an array with one or two ranges. Two ranges if `rangeB` is inside `rangeA`.
 			const difference = rangeA.getDifference( rangeB );
 
-			for ( const range of difference ) {
+			for ( const rangeInDiff of difference ) {
 				// Transform those ranges by `b` operation. For example if `b` moved range from before those ranges, fix those ranges.
-				range.start = range.start._getTransformedByDeletion( b.sourcePosition, b.howMany );
-				range.end = range.end._getTransformedByDeletion( b.sourcePosition, b.howMany );
+				const range = new Range(
+					rangeInDiff.start._getTransformedByDeletion( b.sourcePosition, b.howMany ),
+					rangeInDiff.end._getTransformedByDeletion( b.sourcePosition, b.howMany )
+				);
 
 				// If `b` operation targets into `rangeA` on the same level, spread `rangeA` into two ranges.
 				const shouldSpread = compareArrays( range.start.getParentPath(), b.getMovedRangeStart().getParentPath() ) == 'same';
@@ -513,12 +525,14 @@ const ot = {
 			}
 
 			// Then, we have to manage the "common part" of both move ranges.
-			const common = rangeA.getIntersection( rangeB );
+			const intersectionRange = rangeA.getIntersection( rangeB );
 
-			if ( common !== null && isStrong && !bTargetsToA ) {
+			if ( intersectionRange !== null && isStrong && !bTargetsToA ) {
 				// Calculate the new position of that part of original range.
-				common.start = common.start._getCombined( b.sourcePosition, b.getMovedRangeStart() );
-				common.end = common.end._getCombined( b.sourcePosition, b.getMovedRangeStart() );
+				const common = new Range(
+					intersectionRange.start._getCombined( b.sourcePosition, b.getMovedRangeStart() ),
+					intersectionRange.end._getCombined( b.sourcePosition, b.getMovedRangeStart() )
+				);
 
 				// Take care of proper range order.
 				//
@@ -627,9 +641,10 @@ function joinRanges( ranges ) {
 	} else if ( ranges.length == 1 ) {
 		return ranges[ 0 ];
 	} else {
-		ranges[ 0 ].end = ranges[ ranges.length - 1 ].end;
-
-		return ranges[ 0 ];
+		return new Range(
+			ranges[ 0 ].start,
+			ranges[ ranges.length - 1 ].end
+		);
 	}
 }
 

+ 65 - 24
packages/ckeditor5-engine/src/model/range.js

@@ -11,6 +11,9 @@ import Position from './position';
 import TreeWalker from './treewalker';
 import CKEditorError from '@ckeditor/ckeditor5-utils/src/ckeditorerror';
 
+const _start = Symbol( 'start' );
+const _end = Symbol( 'end' );
+
 /**
  * Range class. Range is iterable.
  */
@@ -24,21 +27,8 @@ export default class Range {
 	 * @param {module:engine/model/position~Position} [end] End position. If not set, range will be collapsed at `start` position.
 	 */
 	constructor( start, end = null ) {
-		/**
-		 * Start position.
-		 *
-		 * @readonly
-		 * @member {module:engine/model/position~Position}
-		 */
-		this.start = start;
-
-		/**
-		 * End position.
-		 *
-		 * @readonly
-		 * @member {module:engine/model/position~Position}
-		 */
-		this.end = end ? end : start;
+		setStart( this, start );
+		setEnd( this, end ? end : start );
 	}
 
 	/**
@@ -57,6 +47,26 @@ export default class Range {
 		yield* new TreeWalker( { boundaries: this, ignoreElementEnd: true } );
 	}
 
+	/**
+	 * Start position.
+	 *
+	 * @readonly
+	 * @member {module:engine/model/position~Position}
+	 */
+	get start() {
+		return this[ _start ];
+	}
+
+	/**
+	 * End position.
+	 *
+	 * @readonly
+	 * @member {module:engine/model/position~Position}
+	 */
+	get end() {
+		return this[ _end ];
+	}
+
 	/**
 	 * Returns whether the range is collapsed, that is if {@link #start} and
 	 * {@link #end} positions are equal.
@@ -465,6 +475,18 @@ export default class Range {
 		return this.start.getCommonAncestor( this.end );
 	}
 
+	/**
+	 * Converts `Range` to plain object and returns it.
+	 *
+	 * @returns {Object} `Range` converted to plain object.
+	 */
+	toJSON() {
+		return {
+			start: this.start.toJSON(),
+			end: this.end.toJSON()
+		};
+	}
+
 	/**
 	 * Returns a range that is a result of transforming this range by a change in the model document.
 	 *
@@ -612,15 +634,13 @@ export default class Range {
 				)
 			];
 		} else {
-			const range = Range.createFromRange( this );
-
 			const insertBeforeStart = !isSticky;
-			const insertBeforeEnd = range.isCollapsed ? true : isSticky;
+			const insertBeforeEnd = this.isCollapsed ? true : isSticky;
 
-			range.start = range.start._getTransformedByInsertion( insertPosition, howMany, insertBeforeStart );
-			range.end = range.end._getTransformedByInsertion( insertPosition, howMany, insertBeforeEnd );
+			const start = this.start._getTransformedByInsertion( insertPosition, howMany, insertBeforeStart );
+			const end = this.end._getTransformedByInsertion( insertPosition, howMany, insertBeforeEnd );
 
-			return [ range ];
+			return [ new Range( start, end ) ];
 		}
 	}
 
@@ -802,13 +822,13 @@ export default class Range {
 		// 4. At this moment we don't need the original range.
 		// We are going to modify the result and we need to return a new instance of Range.
 		// We have to create a copy of the reference range.
-		const result = new this( ref.start, ref.end );
+		let result = new this( ref.start, ref.end );
 
 		// 5. Ranges should be checked and glued starting from the range that is closest to the reference range.
 		// 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 = ranges[ i ].start;
+				result = new this( ranges[ i ].start, result.end );
 			} else {
 				// If ranges are not starting/ending at the same position there is no point in looking further.
 				break;
@@ -819,7 +839,7 @@ export default class Range {
 		// 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 = ranges[ i ].end;
+				result = new this( result.start, ranges[ i ].end );
 			} else {
 				// If ranges are not starting/ending at the same position there is no point in looking further.
 				break;
@@ -840,3 +860,24 @@ export default class Range {
 		return new this( Position.fromJSON( json.start, doc ), Position.fromJSON( json.end, doc ) );
 	}
 }
+
+/**
+ * Method used to expose start setter to child classes.
+ * @protected
+ * @param {module:engine/model/range~Range} range Range of which start position should be sent.
+ * @param {module:engine/model/position~Position} position Position to set as range start.
+ * See {@link module:engine/model/range~Range#start}.
+ */
+export function setStart( range, position ) {
+	range[ _start ] = position;
+}
+
+/**
+ * Method used to expose end setter to child classes.
+ * @protected
+ * @param {module:engine/model/range~Range} range Range of which end position should be sent.
+ * @param {module:engine/model/position~Position} position Position to set as range end. See {@link module:engine/model/range~Range#end}.
+ */
+export function setEnd( range, position ) {
+	range[ _end ] = position;
+}

+ 15 - 5
packages/ckeditor5-engine/tests/model/liverange.js

@@ -208,7 +208,9 @@ describe( 'LiveRange', () => {
 			} );
 
 			it( 'is at the live range start position and live range is collapsed', () => {
-				live.end = new Position( live.end.root, [ 0, 1, 4 ] );
+				live = new LiveRange( live.start, new Position( live.end.root, [ 0, 1, 4 ] ) );
+				spy = sinon.spy();
+				live.on( 'change:range', spy );
 
 				const insertRange = new Range( new Position( root, [ 0, 1, 4 ] ), new Position( root, [ 0, 1, 8 ] ) );
 
@@ -372,7 +374,9 @@ describe( 'LiveRange', () => {
 			} );
 
 			it( 'is equal to live range', () => {
-				live.end = new Position( live.end.root, [ 0, 1, 7 ] );
+				live = new LiveRange( live.start, new Position( live.end.root, [ 0, 1, 7 ] ) );
+				spy = sinon.spy();
+				live.on( 'change:range', spy );
 
 				const moveSource = new Position( root, [ 0, 1, 4 ] );
 				const moveRange = new Range( new Position( root, [ 0, 3, 0 ] ), new Position( root, [ 0, 3, 3 ] ) );
@@ -389,7 +393,9 @@ describe( 'LiveRange', () => {
 			} );
 
 			it( 'contains live range', () => {
-				live.end = new Position( live.end.root, [ 0, 1, 7 ] );
+				live = new LiveRange( live.start, new Position( live.end.root, [ 0, 1, 7 ] ) );
+				spy = sinon.spy();
+				live.on( 'change:range', spy );
 
 				const moveSource = new Position( root, [ 0, 1, 3 ] );
 				const moveRange = new Range( new Position( root, [ 0, 3, 0 ] ), new Position( root, [ 0, 3, 9 ] ) );
@@ -406,7 +412,9 @@ describe( 'LiveRange', () => {
 			} );
 
 			it( 'is intersecting with live range and points to live range', () => {
-				live.end = new Position( live.end.root, [ 0, 1, 12 ] );
+				live = new LiveRange( live.start, new Position( live.end.root, [ 0, 1, 12 ] ) );
+				spy = sinon.spy();
+				live.on( 'change:range', spy );
 
 				const moveSource = new Position( root, [ 0, 1, 2 ] );
 				const moveRange = new Range( new Position( root, [ 0, 1, 7 ] ), new Position( root, [ 0, 1, 10 ] ) );
@@ -656,7 +664,9 @@ describe( 'LiveRange', () => {
 			} );
 
 			it( 'from the range to the range', () => {
-				live.end = new Position( live.end.root, [ 0, 1, 12 ] );
+				live = new LiveRange( live.start, new Position( live.end.root, [ 0, 1, 12 ] ) );
+				spy = sinon.spy();
+				live.on( 'change:content', spy );
 
 				const moveSource = new Position( root, [ 0, 1, 6 ] );
 				const moveRange = new Range( new Position( root, [ 0, 1, 8 ] ), new Position( root, [ 0, 1, 10 ] ) );

+ 230 - 97
packages/ckeditor5-engine/tests/model/operation/transform.js

@@ -539,7 +539,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -554,7 +557,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -582,8 +588,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = getPositionMovedInPath( expected.range.start, 0, 2 );
-					expected.range.end = getPositionMovedInPath( expected.range.end, 0, 2 );
+					expected.range = new Range(
+						getPositionMovedInPath( expected.range.start, 0, 2 ),
+						getPositionMovedInPath( expected.range.end, 0, 2 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -613,12 +621,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.start = new Position( expected.range.start.root, [ 1, 3, 3 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 1, 3, 3 ] ),
+						expected.range.end
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = op.range.start;
-					expected.range.end = new Position( expected.range.end.root, [ 1, 3, 1 ] );
+					expected.range = new Range(
+						op.range.start,
+						new Position( expected.range.end.root, [ 1, 3, 1 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -730,12 +743,18 @@ describe( 'transform', () => {
 
 						expect( transOp.length ).to.equal( 2 );
 
-						expected.range.end = new Position( expected.range.end.root, [ 1, 4, 2 ] );
+						expected.range = new Range(
+							expected.range.start,
+							new Position( expected.range.end.root, [ 1, 4, 2 ] )
+						);
 
 						expectOperation( transOp[ 0 ], expected );
 
-						expected.range.start = new Position( expected.range.start.root, [ 1, 4, 2 ] );
-						expected.range.end = op.range.end;
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 1, 4, 2 ] ),
+							op.range.end
+						);
+
 						expected.oldValue = 'another';
 						expected.baseVersion++;
 
@@ -756,12 +775,17 @@ describe( 'transform', () => {
 
 						expect( transOp.length ).to.equal( 2 );
 
-						expected.range.start = new Position( expected.range.start.root, [ 2, 1 ] );
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 2, 1 ] ),
+							expected.range.end
+						);
 
 						expectOperation( transOp[ 0 ], expected );
 
-						expected.range.start = op.range.start;
-						expected.range.end = new Position( expected.range.end.root, [ 2, 1 ] );
+						expected.range = new Range(
+							op.range.start,
+							new Position( expected.range.end.root, [ 2, 1 ] )
+						);
 						expected.oldValue = null;
 						expected.baseVersion++;
 
@@ -781,18 +805,26 @@ describe( 'transform', () => {
 
 						expect( transOp.length ).to.equal( 3 );
 
-						expected.range.end = new Position( expected.range.end.root, [ 1, 4, 1 ] );
+						expected.range = new Range(
+							expected.range.start,
+							new Position( expected.range.end.root, [ 1, 4, 1 ] )
+						);
 
 						expectOperation( transOp[ 0 ], expected );
 
-						expected.range.start = new Position( expected.range.start.root, [ 2, 1 ] );
-						expected.range.end = op.range.end;
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 2, 1 ] ),
+							op.range.end
+						);
 						expected.baseVersion++;
 
 						expectOperation( transOp[ 1 ], expected );
 
-						expected.range.start = new Position( expected.range.start.root, [ 1, 4, 1 ] );
-						expected.range.end = new Position( expected.range.end.root, [ 2, 1 ] );
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 1, 4, 1 ] ),
+							new Position( expected.range.end.root, [ 2, 1 ] )
+						);
+
 						expected.oldValue = null;
 						expected.baseVersion++;
 
@@ -867,7 +899,10 @@ describe( 'transform', () => {
 
 						const transOp = transform( op, transformBy );
 
-						expected.range.end = new Position( expected.range.end.root, [ 1, 4, 2 ] );
+						expected.range = new Range(
+							expected.range.start,
+							new Position( expected.range.end.root, [ 1, 4, 2 ] )
+						);
 
 						expect( transOp.length ).to.equal( 1 );
 						expectOperation( transOp[ 0 ], expected );
@@ -885,7 +920,10 @@ describe( 'transform', () => {
 
 						const transOp = transform( op, transformBy );
 
-						expected.range.start = new Position( expected.range.start.root, [ 2, 1 ] );
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 2, 1 ] ),
+							expected.range.end
+						);
 
 						expect( transOp.length ).to.equal( 1 );
 						expectOperation( transOp[ 0 ], expected );
@@ -904,12 +942,17 @@ describe( 'transform', () => {
 
 						expect( transOp.length ).to.equal( 2 );
 
-						expected.range.end = new Position( expected.range.end.root, [ 1, 4, 1 ] );
+						expected.range = new Range(
+							expected.range.start,
+							new Position( expected.range.end.root, [ 1, 4, 1 ] )
+						);
 
 						expectOperation( transOp[ 0 ], expected );
 
-						expected.range.start = new Position( expected.range.start.root, [ 2, 1 ] );
-						expected.range.end = op.range.end;
+						expected.range = new Range(
+							new Position( expected.range.start.root, [ 2, 1 ] ),
+							op.range.end
+						);
 						expected.baseVersion++;
 
 						expectOperation( transOp[ 1 ], expected );
@@ -959,7 +1002,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( -2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( -2 ),
+						expected.range.end
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -975,7 +1021,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -991,8 +1040,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = getPositionMovedInPath( expected.range.start, 0, -1 );
-					expected.range.end = getPositionMovedInPath( expected.range.end, 0, -1 );
+					expected.range = new Range(
+						getPositionMovedInPath( expected.range.start, 0, -1 ),
+						getPositionMovedInPath( expected.range.end, 0, -1 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1022,7 +1073,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = getPositionMovedInPath( expected.range.start, 1, 2 );
+					expected.range = new Range(
+						getPositionMovedInPath( expected.range.start, 1, 2 ),
+						expected.range.end
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1054,12 +1108,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.end = new Position( expected.range.end.root, [ 2, 1 ] );
+					expected.range = new Range(
+						expected.range.start,
+						new Position( expected.range.end.root, [ 2, 1 ] )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 4 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 5, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 4 ] ),
+						new Position( expected.range.end.root, [ 5, 4 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1077,12 +1136,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.start = new Position( expected.range.start.root, [ 1, 1 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 1, 1 ] ),
+						expected.range.end
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 0, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 0, 3 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 0, 1 ] ),
+						new Position( expected.range.end.root, [ 0, 3 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1098,8 +1162,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = new Position( expected.range.start.root, [ 1, 4, 1, 2 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 1, 4, 2, 2, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 1, 4, 1, 2 ] ),
+						new Position( expected.range.end.root, [ 1, 4, 2, 2, 4 ] )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1119,8 +1185,10 @@ describe( 'transform', () => {
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 3, 2 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 3, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 3, 2 ] ),
+						new Position( expected.range.end.root, [ 3, 4 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1138,12 +1206,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.start = new Position( expected.range.start.root, [ 1, 6 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 1, 6 ] ),
+						expected.range.end
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = op.range.start;
-					expected.range.end = new Position( expected.range.end.root, [ 1, 4 ] );
+					expected.range = new Range(
+						op.range.start,
+						new Position( expected.range.end.root, [ 1, 4 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1161,19 +1234,25 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 3 );
 
-					expected.range.start = new Position( expected.range.start.root, [ 5 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 5, 2, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 5 ] ),
+						new Position( expected.range.end.root, [ 5, 2, 4 ] )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 1, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 1, 1 ] ),
+						new Position( expected.range.end.root, [ 2 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 3 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 5 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 3 ] ),
+						new Position( expected.range.end.root, [ 5 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 2 ], expected );
@@ -1241,8 +1320,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
-					expected.range.end = expected.range.end.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end.getShiftedBy( 2 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1257,8 +1338,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
-					expected.range.end = expected.range.end.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end.getShiftedBy( 2 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1276,8 +1359,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( -1 );
-					expected.range.end = expected.range.end.getShiftedBy( -1 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( -1 ),
+						expected.range.end.getShiftedBy( -1 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1293,8 +1378,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = expected.range.start.getShiftedBy( 2 );
-					expected.range.end = expected.range.end.getShiftedBy( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( 2 ),
+						expected.range.end.getShiftedBy( 2 )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1312,12 +1399,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.end = expected.range.end.getShiftedBy( -2 );
+					expected.range = new Range(
+						expected.range.start,
+						expected.range.end.getShiftedBy( -2 )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 2, 4, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2, 4, 3 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 2, 4, 1 ] ),
+						new Position( expected.range.end.root, [ 2, 4, 3 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1335,13 +1427,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.start = expected.range.start.getShiftedBy( -1 );
-					expected.range.end = expected.range.end.getShiftedBy( -2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedBy( -1 ),
+						expected.range.end.getShiftedBy( -2 )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 2, 4, 2 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2, 4, 3 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 2, 4, 2 ] ),
+						new Position( expected.range.end.root, [ 2, 4, 3 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1357,8 +1453,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = new Position( expected.range.start.root, [ 2, 4, 2, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2, 4, 2, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 2, 4, 2, 1 ] ),
+						new Position( expected.range.end.root, [ 2, 4, 2, 4 ] )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1376,12 +1474,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.end = expected.range.end.getShiftedBy( -1 );
+					expected.range = new Range(
+						expected.range.start,
+						expected.range.end.getShiftedBy( -1 )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = new Position( expected.range.start.root, [ 2, 4, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2, 4, 2 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 2, 4, 1 ] ),
+						new Position( expected.range.end.root, [ 2, 4, 2 ] )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1397,8 +1500,10 @@ describe( 'transform', () => {
 
 					const transOp = transform( op, transformBy );
 
-					expected.range.start = new Position( expected.range.start.root, [ 2, 4, 1 ] );
-					expected.range.end = new Position( expected.range.end.root, [ 2, 4, 4 ] );
+					expected.range = new Range(
+						new Position( expected.range.start.root, [ 2, 4, 1 ] ),
+						new Position( expected.range.end.root, [ 2, 4, 4 ] )
+					);
 
 					expect( transOp.length ).to.equal( 1 );
 					expectOperation( transOp[ 0 ], expected );
@@ -1416,13 +1521,17 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 2 );
 
-					expected.range.start = expected.range.start.getShiftedTo( 4 );
-					expected.range.end = expected.range.end.getShiftedTo( 6 );
+					expected.range = new Range(
+						expected.range.start.getShiftedTo( 4 ),
+						expected.range.end.getShiftedTo( 6 )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = expected.range.start.getShiftedTo( op.range.start.offset );
-					expected.range.end = expected.range.end.getShiftedTo( 2 );
+					expected.range = new Range(
+						expected.range.start.getShiftedTo( op.range.start.offset ),
+						expected.range.end.getShiftedTo( 2 )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
@@ -1440,19 +1549,25 @@ describe( 'transform', () => {
 
 					expect( transOp.length ).to.equal( 3 );
 
-					expected.range.start = expected.range.start.getShiftedTo( 3 );
-					expected.range.end = expected.range.end.getShiftedTo( 4 );
+					expected.range = new Range(
+						expected.range.start.getShiftedTo( 3 ),
+						expected.range.end.getShiftedTo( 4 )
+					);
 
 					expectOperation( transOp[ 0 ], expected );
 
-					expected.range.start = expected.range.start.getShiftedTo( 0 );
-					expected.range.end = expected.range.end.getShiftedTo( 1 );
+					expected.range = new Range(
+						expected.range.start.getShiftedTo( 0 ),
+						expected.range.end.getShiftedTo( 1 )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 1 ], expected );
 
-					expected.range.start = expected.range.start.getShiftedTo( 2 );
-					expected.range.end = expected.range.end.getShiftedTo( 3 );
+					expected.range = new Range(
+						expected.range.start.getShiftedTo( 2 ),
+						expected.range.end.getShiftedTo( 3 )
+					);
 					expected.baseVersion++;
 
 					expectOperation( transOp[ 2 ], expected );
@@ -1486,8 +1601,10 @@ describe( 'transform', () => {
 
 				expect( transOp.length ).to.equal( 1 );
 
-				expected.range.start = new Position( expected.range.start.root, [ 4, 0 ] );
-				expected.range.end = new Position( expected.range.end.root, [ 4, 4 ] );
+				expected.range = new Range(
+					new Position( expected.range.start.root, [ 4, 0 ] ),
+					new Position( expected.range.end.root, [ 4, 4 ] )
+				);
 
 				expectOperation( transOp[ 0 ], expected );
 			} );
@@ -3342,8 +3459,10 @@ describe( 'transform', () => {
 				const transOp = transform( op, transformBy );
 
 				expected.newRange = null;
-				expected.oldRange.start = expected.oldRange.start.getShiftedTo( 3 );
-				expected.oldRange.end = expected.oldRange.end.getShiftedTo( 6 );
+				expected.oldRange = new Range(
+					expected.oldRange.start.getShiftedTo( 3 ),
+					expected.oldRange.end.getShiftedTo( 6 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );
@@ -3357,8 +3476,10 @@ describe( 'transform', () => {
 				const transOp = transform( op, transformBy );
 
 				expected.oldRange = null;
-				expected.newRange.start = expected.newRange.start.getShiftedTo( 12 );
-				expected.newRange.end = expected.newRange.end.getShiftedTo( 14 );
+				expected.newRange = new Range(
+					expected.newRange.start.getShiftedTo( 12 ),
+					expected.newRange.end.getShiftedTo( 14 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );
@@ -3394,8 +3515,10 @@ describe( 'transform', () => {
 				const transOp = transform( op, transformBy );
 
 				expected.newRange = null;
-				expected.oldRange.start = expected.oldRange.start.getShiftedTo( 0 );
-				expected.oldRange.end = expected.oldRange.end.getShiftedTo( 3 );
+				expected.oldRange = new Range(
+					expected.oldRange.start.getShiftedTo( 0 ),
+					expected.oldRange.end.getShiftedTo( 3 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );
@@ -3405,10 +3528,14 @@ describe( 'transform', () => {
 				const transformBy = new MoveOperation( Position.createAt( root, 2 ), 2, Position.createAt( root, 20 ), baseVersion );
 				const transOp = transform( op, transformBy );
 
-				expected.oldRange.start = expected.oldRange.start.getShiftedTo( 1 );
-				expected.oldRange.end = expected.oldRange.end.getShiftedTo( 2 );
-				expected.newRange.start = expected.newRange.start.getShiftedTo( 8 );
-				expected.newRange.end = expected.newRange.end.getShiftedTo( 10 );
+				expected.oldRange = new Range(
+					expected.oldRange.start.getShiftedTo( 1 ),
+					expected.oldRange.end.getShiftedTo( 2 )
+				);
+				expected.newRange = new Range(
+					expected.newRange.start.getShiftedTo( 8 ),
+					expected.newRange.end.getShiftedTo( 10 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );
@@ -3422,8 +3549,10 @@ describe( 'transform', () => {
 				const transOp = transform( op, transformBy );
 
 				expected.oldRange = null;
-				expected.newRange.start = expected.newRange.start.getShiftedTo( 10 );
-				expected.newRange.end = expected.newRange.end.getShiftedTo( 14 );
+				expected.newRange = new Range(
+					expected.newRange.start.getShiftedTo( 10 ),
+					expected.newRange.end.getShiftedTo( 14 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );
@@ -3433,10 +3562,14 @@ describe( 'transform', () => {
 				const transformBy = new MoveOperation( Position.createAt( root, 20 ), 4, Position.createAt( root, 2 ), baseVersion );
 				const transOp = transform( op, transformBy );
 
-				expected.oldRange.start = expected.oldRange.start.getShiftedTo( 1 );
-				expected.oldRange.end = expected.oldRange.end.getShiftedTo( 8 );
-				expected.newRange.start = expected.newRange.start.getShiftedTo( 14 );
-				expected.newRange.end = expected.newRange.end.getShiftedTo( 16 );
+				expected.oldRange = new Range(
+					expected.oldRange.start.getShiftedTo( 1 ),
+					expected.oldRange.end.getShiftedTo( 8 )
+				);
+				expected.newRange = new Range(
+					expected.newRange.start.getShiftedTo( 14 ),
+					expected.newRange.end.getShiftedTo( 16 )
+				);
 
 				expect( transOp.length ).to.equal( 1 );
 				expectOperation( transOp[ 0 ], expected );

+ 49 - 25
packages/ckeditor5-engine/tests/model/range.js

@@ -855,7 +855,7 @@ describe( 'Range', () => {
 			} );
 
 			it( 'move inside the range', () => {
-				range.end = range.end.getShiftedTo( 6 );
+				range = new Range( range.start, range.end.getShiftedTo( 6 ) );
 
 				const start = new Position( root, [ 3 ] );
 				const target = new Position( root, [ 5 ] );
@@ -978,8 +978,10 @@ describe( 'Range', () => {
 
 		describe( 'by SplitDelta', () => {
 			it( 'split inside range', () => {
-				range.start = new Position( root, [ 0, 2 ] );
-				range.end = new Position( root, [ 0, 4 ] );
+				range = new Range(
+					new Position( root, [ 0, 2 ] ),
+					new Position( root, [ 0, 4 ] )
+				);
 
 				const delta = getSplitDelta( new Position( root, [ 0, 3 ] ), new Element( 'p' ), 3, 1 );
 
@@ -991,8 +993,10 @@ describe( 'Range', () => {
 			} );
 
 			it( 'split at the beginning of multi-element range', () => {
-				range.start = new Position( root, [ 0, 4 ] );
-				range.end = new Position( root, [ 1, 2 ] );
+				range = new Range(
+					new Position( root, [ 0, 4 ] ),
+					new Position( root, [ 1, 2 ] )
+				);
 
 				const delta = getSplitDelta( new Position( root, [ 0, 4 ] ), new Element( 'p' ), 3, 1 );
 
@@ -1004,8 +1008,10 @@ describe( 'Range', () => {
 			} );
 
 			it( 'split inside range which starts at the beginning of split element', () => {
-				range.start = new Position( root, [ 0, 0 ] );
-				range.end = new Position( root, [ 0, 4 ] );
+				range = new Range(
+					new Position( root, [ 0, 0 ] ),
+					new Position( root, [ 0, 4 ] )
+				);
 
 				const delta = getSplitDelta( new Position( root, [ 0, 3 ] ), new Element( 'p' ), 3, 1 );
 
@@ -1017,8 +1023,10 @@ describe( 'Range', () => {
 			} );
 
 			it( 'split inside range which end is at the end of split element', () => {
-				range.start = new Position( root, [ 0, 3 ] );
-				range.end = new Position( root, [ 0, 6 ] );
+				range = new Range(
+					new Position( root, [ 0, 3 ] ),
+					new Position( root, [ 0, 6 ] )
+				);
 
 				const delta = getSplitDelta( new Position( root, [ 0, 4 ] ), new Element( 'p' ), 2, 1 );
 
@@ -1030,8 +1038,10 @@ describe( 'Range', () => {
 			} );
 
 			it( 'split element which has collapsed range at the end', () => {
-				range.start = new Position( root, [ 0, 6 ] );
-				range.end = new Position( root, [ 0, 6 ] );
+				range = new Range(
+					new Position( root, [ 0, 6 ] ),
+					new Position( root, [ 0, 6 ] )
+				);
 
 				const delta = getSplitDelta( new Position( root, [ 0, 3 ] ), new Element( 'p' ), 3, 1 );
 
@@ -1045,8 +1055,10 @@ describe( 'Range', () => {
 
 		describe( 'by MergeDelta', () => {
 			it( 'merge element with collapsed range', () => {
-				range.start = new Position( root, [ 1, 0 ] );
-				range.end = new Position( root, [ 1, 0 ] );
+				range = new Range(
+					new Position( root, [ 1, 0 ] ),
+					new Position( root, [ 1, 0 ] )
+				);
 
 				const delta = getMergeDelta( new Position( root, [ 1 ] ), 3, 3, 1 );
 
@@ -1107,8 +1119,10 @@ describe( 'Range', () => {
 		describe( 'by WrapDelta', () => {
 			it( 'maintans start position when wrapping element in which the range starts and ends', () => {
 				// <p>f[o]o</p><p>bar</p>
-				range.start = new Position( root, [ 0, 1 ] );
-				range.end = new Position( root, [ 0, 2 ] );
+				range = new Range(
+					new Position( root, [ 0, 1 ] ),
+					new Position( root, [ 0, 2 ] )
+				);
 
 				const wrapRange = new Range( new Position( root, [ 0 ] ), new Position( root, [ 1 ] ) );
 				const wrapElement = new Element( 'w' );
@@ -1124,8 +1138,10 @@ describe( 'Range', () => {
 
 			it( 'maintans start position when wrapping element in which the range starts but not ends', () => {
 				// <p>f[oo</p><p>b]ar</p>
-				range.start = new Position( root, [ 0, 1 ] );
-				range.end = new Position( root, [ 1, 1 ] );
+				range = new Range(
+					new Position( root, [ 0, 1 ] ),
+					new Position( root, [ 1, 1 ] )
+				);
 
 				const wrapRange = new Range( new Position( root, [ 0 ] ), new Position( root, [ 1 ] ) );
 				const wrapElement = new Element( 'w' );
@@ -1141,8 +1157,10 @@ describe( 'Range', () => {
 
 			it( 'maintans end position when wrapping element in which the range ends but not starts', () => {
 				// <p>f[oo</p><p>b]ar</p>
-				range.start = new Position( root, [ 0, 1 ] );
-				range.end = new Position( root, [ 1, 1 ] );
+				range = new Range(
+					new Position( root, [ 0, 1 ] ),
+					new Position( root, [ 1, 1 ] )
+				);
 
 				const wrapRange = new Range( new Position( root, [ 1 ] ), new Position( root, [ 2 ] ) );
 				const wrapElement = new Element( 'w' );
@@ -1160,8 +1178,10 @@ describe( 'Range', () => {
 		describe( 'by UnwrapDelta', () => {
 			it( 'maintans start position when wrapping element in which the range starts and ends', () => {
 				// <w><p>f[o]o</p></w><p>bar</p>
-				range.start = new Position( root, [ 0, 0, 1 ] );
-				range.end = new Position( root, [ 0, 0, 2 ] );
+				range = new Range(
+					new Position( root, [ 0, 0, 1 ] ),
+					new Position( root, [ 0, 0, 2 ] )
+				);
 
 				const unwrapPosition = new Position( root, [ 0 ] );
 				const delta = getUnwrapDelta( unwrapPosition, 1, 1 );
@@ -1176,8 +1196,10 @@ describe( 'Range', () => {
 
 			it( 'maintans start position when wrapping element in which the range starts but not ends', () => {
 				// <w><p>f[oo</p></w><p>b]ar</p>
-				range.start = new Position( root, [ 0, 0, 1 ] );
-				range.end = new Position( root, [ 1, 1 ] );
+				range = new Range(
+					new Position( root, [ 0, 0, 1 ] ),
+					new Position( root, [ 1, 1 ] )
+				);
 
 				const unwrapPosition = new Position( root, [ 0 ] );
 				const delta = getUnwrapDelta( unwrapPosition, 1, 1 );
@@ -1195,8 +1217,10 @@ describe( 'Range', () => {
 
 			it( 'maintans end position when wrapping element in which the range ends but not starts', () => {
 				// <p>f[oo</p><w><p>b]ar</p></w>
-				range.start = new Position( root, [ 0, 1 ] );
-				range.end = new Position( root, [ 1, 0, 1 ] );
+				range = new Range(
+					new Position( root, [ 0, 1 ] ),
+					new Position( root, [ 1, 0, 1 ] )
+				);
 
 				const unwrapPosition = new Position( root, [ 1 ] );
 				const delta = getUnwrapDelta( unwrapPosition, 1, 1 );