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

package/src/model/element.js

@@ -5,19 +5,19 @@
 /**
  * @module engine/model/element
  */
-import Node from './node.js';
-import NodeList from './nodelist.js';
-import Text from './text.js';
-import TextProxy from './textproxy.js';
+import { ModelNode } from './node.js';
+import { ModelNodeList } from './nodelist.js';
+import { ModelText } from './text.js';
+import { ModelTextProxy } from './textproxy.js';
 import { isIterable } from '@ckeditor/ckeditor5-utils';
 // @if CK_DEBUG_ENGINE // const { stringifyMap, convertMapToStringifiedObject, convertMapToTags } = require( '../dev-utils/utils' );
 /**
- * Model element. Type of {@link module:engine/model/node~Node node} that has a {@link module:engine/model/element~Element#name name} and
- * {@link module:engine/model/element~Element#getChildren child nodes}.
+ * Model element. Type of {@link module:engine/model/node~ModelNode node} that has a
+ * {@link module:engine/model/element~ModelElement#name name} and {@link module:engine/model/element~ModelElement#getChildren child nodes}.
  *
- * **Important**: see {@link module:engine/model/node~Node} to read about restrictions using `Element` and `Node` API.
+ * **Important**: see {@link module:engine/model/node~ModelNode} to read about restrictions using `Element` and `Node` API.
  */
-export default class Element extends Node {
+export class ModelElement extends ModelNode {
     /**
      * Element name.
      */
@@ -25,12 +25,12 @@ export default class Element extends Node {
     /**
      * List of children nodes.
      */
-    _children = new NodeList();
+    _children = new ModelNodeList();
     /**
      * Creates a model element.
      *
      * **Note:** Constructor of this class shouldn't be used directly in the code.
-     * Use the {@link module:engine/model/writer~Writer#createElement} method instead.
+     * Use the {@link module:engine/model/writer~ModelWriter#createElement} method instead.
      *
      * @internal
      * @param name Element's name.
@@ -51,7 +51,7 @@ export default class Element extends Node {
         return this._children.length;
     }
     /**
-     * Sum of {@link module:engine/model/node~Node#offsetSize offset sizes} of all of this element's children.
+     * Sum of {@link module:engine/model/node~ModelNode#offsetSize offset sizes} of all of this element's children.
      */
     get maxOffset() {
         return this._children.maxOffset;
@@ -97,7 +97,7 @@ export default class Element extends Node {
     }
     /**
      * Returns the starting offset of given child. Starting offset is equal to the sum of
-     * {@link module:engine/model/node~Node#offsetSize offset sizes} of all node's siblings that are before it. Returns `null` if
+     * {@link module:engine/model/node~ModelNode#offsetSize offset sizes} of all node's siblings that are before it. Returns `null` if
      * given node is not a child of this element.
      *
      * @param node Child node to look for.
@@ -108,7 +108,7 @@ export default class Element extends Node {
     }
     /**
      * Returns index of a node that occupies given offset. If given offset is too low, returns `0`. If given offset is
-     * too high, returns {@link module:engine/model/element~Element#getChildIndex index after last child}.
+     * too high, returns {@link module:engine/model/element~ModelElement#getChildIndex index after last child}.
      *
      * ```ts
      * const textNode = new Text( 'foo' );
@@ -188,12 +188,12 @@ export default class Element extends Node {
      */
     _clone(deep = false) {
         const children = deep ? cloneNodes(this._children) : undefined;
-        return new Element(this.name, this.getAttributes(), children);
+        return new ModelElement(this.name, this.getAttributes(), children);
     }
     /**
-     * {@link module:engine/model/element~Element#_insertChild Inserts} one or more nodes at the end of this element.
+     * {@link module:engine/model/element~ModelElement#_insertChild Inserts} one or more nodes at the end of this element.
      *
-     * @see module:engine/model/writer~Writer#append
+     * @see module:engine/model/writer~ModelWriter#append
      * @internal
      * @param nodes Nodes to be inserted.
      */
@@ -201,10 +201,10 @@ export default class Element extends Node {
         this._insertChild(this.childCount, nodes);
     }
     /**
-     * Inserts one or more nodes at the given index and sets {@link module:engine/model/node~Node#parent parent} of these nodes
+     * Inserts one or more nodes at the given index and sets {@link module:engine/model/node~ModelNode#parent parent} of these nodes
      * to this element.
      *
-     * @see module:engine/model/writer~Writer#insert
+     * @see module:engine/model/writer~ModelWriter#insert
      * @internal
      * @param index Index at which nodes should be inserted.
      * @param items Items to be inserted.
@@ -222,9 +222,9 @@ export default class Element extends Node {
     }
     /**
      * Removes one or more nodes starting at the given index and sets
-     * {@link module:engine/model/node~Node#parent parent} of these nodes to `null`.
+     * {@link module:engine/model/node~ModelNode#parent parent} of these nodes to `null`.
      *
-     * @see module:engine/model/writer~Writer#remove
+     * @see module:engine/model/writer~ModelWriter#remove
      * @internal
      * @param index Index of the first node to remove.
      * @param howMany Number of nodes to remove.
@@ -239,7 +239,7 @@ export default class Element extends Node {
     }
     /**
      * Removes children nodes provided as an array and sets
-     * the {@link module:engine/model/node~Node#parent parent} of these nodes to `null`.
+     * the {@link module:engine/model/node~ModelNode#parent parent} of these nodes to `null`.
      *
      * These nodes do not need to be direct siblings.
      *
@@ -268,20 +268,20 @@ export default class Element extends Node {
             for (const child of json.children) {
                 if (child.name) {
                     // If child has name property, it is an Element.
-                    children.push(Element.fromJSON(child));
+                    children.push(ModelElement.fromJSON(child));
                 }
                 else {
                     // Otherwise, it is a Text node.
-                    children.push(Text.fromJSON(child));
+                    children.push(ModelText.fromJSON(child));
                 }
             }
         }
-        return new Element(json.name, json.attributes, children);
+        return new ModelElement(json.name, json.attributes, children);
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-Element.prototype.is = function (type, name) {
+ModelElement.prototype.is = function (type, name) {
     if (!name) {
         return type === 'element' || type === 'model:element' ||
             // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
@@ -295,7 +295,7 @@ Element.prototype.is = function (type, name) {
 function normalize(nodes) {
     // Separate condition because string is iterable.
     if (typeof nodes == 'string') {
-        return [new Text(nodes)];
+        return [new ModelText(nodes)];
     }
     if (!isIterable(nodes)) {
         nodes = [nodes];
@@ -303,10 +303,10 @@ function normalize(nodes) {
     const normalizedNodes = [];
     for (const node of nodes) {
         if (typeof node == 'string') {
-            normalizedNodes.push(new Text(node));
+            normalizedNodes.push(new ModelText(node));
         }
-        else if (node instanceof TextProxy) {
-            normalizedNodes.push(new Text(node.data, node.getAttributes()));
+        else if (node instanceof ModelTextProxy) {
+            normalizedNodes.push(new ModelText(node.data, node.getAttributes()));
         }
         else {
             normalizedNodes.push(node);

package/src/model/history.d.ts

@@ -2,14 +2,14 @@
  * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import type Operation from './operation/operation.js';
+import { type Operation } from './operation/operation.js';
 /**
  * @module engine/model/history
  */
 /**
- * `History` keeps the track of all the operations applied to the {@link module:engine/model/document~Document document}.
+ * `History` keeps the track of all the operations applied to the {@link module:engine/model/document~ModelDocument document}.
  */
-export default class History {
+export declare class History {
     /**
      * Operations added to the history.
      */

package/src/model/history.js

@@ -7,9 +7,9 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * @module engine/model/history
  */
 /**
- * `History` keeps the track of all the operations applied to the {@link module:engine/model/document~Document document}.
+ * `History` keeps the track of all the operations applied to the {@link module:engine/model/document~ModelDocument document}.
  */
-export default class History {
+export class History {
     /**
      * Operations added to the history.
      */

package/src/model/item.d.ts

@@ -2,13 +2,12 @@
  * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import type Node from './node.js';
-import type TextProxy from './textproxy.js';
+import { type ModelNode } from './node.js';
+import { type ModelTextProxy } from './textproxy.js';
 /**
  * @module engine/model/item
  */
 /**
- * Item is a {@link module:engine/model/node~Node} or {@link module:engine/model/textproxy~TextProxy}.
+ * Item is a {@link module:engine/model/node~ModelNode} or {@link module:engine/model/textproxy~ModelTextProxy}.
  */
-type Item = Node | TextProxy;
-export default Item;
+export type ModelItem = ModelNode | ModelTextProxy;

package/src/model/liveposition.d.ts

@@ -5,73 +5,73 @@
 /**
  * @module engine/model/liveposition
  */
-import Position, { type PositionOffset, type PositionStickiness } from './position.js';
-import type DocumentFragment from './documentfragment.js';
-import type Item from './item.js';
-import type RootElement from './rootelement.js';
-declare const LivePosition_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Position, import("@ckeditor/ckeditor5-utils").Emitter>;
+import { ModelPosition, type ModelPositionOffset, type ModelPositionStickiness } from './position.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelItem } from './item.js';
+import { type ModelRootElement } from './rootelement.js';
+declare const ModelLivePosition_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof ModelPosition, import("@ckeditor/ckeditor5-utils").Emitter>;
 /**
- * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
- * that updates itself as {@link module:engine/model/document~Document document}
+ * `ModelLivePosition` is a type of {@link module:engine/model/position~ModelPosition Position}
+ * that updates itself as {@link module:engine/model/document~ModelDocument document}
  * is changed through operations. It may be used as a bookmark.
  *
- * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
- * {@link module:engine/model/rootelement~RootElement}.
- * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
+ * **Note:** Contrary to {@link module:engine/model/position~ModelPosition}, `ModelLivePosition` works only in roots that are
+ * {@link module:engine/model/rootelement~ModelRootElement}.
+ * If {@link module:engine/model/documentfragment~ModelDocumentFragment} is passed, error will be thrown.
  *
- * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
+ * **Note:** Be very careful when dealing with `ModelLivePosition`. Each `ModelLivePosition` instance bind events that might
  * have to be unbound.
- * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
+ * Use {@link module:engine/model/liveposition~ModelLivePosition#detach} whenever you don't need `ModelLivePosition` anymore.
  */
-export default class LivePosition extends /* #__PURE__ */ LivePosition_base {
+export declare class ModelLivePosition extends /* #__PURE__ */ ModelLivePosition_base {
     /**
      * Root of the position path.
      */
-    readonly root: RootElement;
+    readonly root: ModelRootElement;
     /**
      * Creates a live position.
      *
-     * @see module:engine/model/position~Position
+     * @see module:engine/model/position~ModelPosition
      */
-    constructor(root: RootElement, path: Array<number>, stickiness?: PositionStickiness);
+    constructor(root: ModelRootElement, path: Array<number>, stickiness?: ModelPositionStickiness);
     /**
-     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
+     * Unbinds all events previously bound by `ModelLivePosition`. Use it whenever you don't need `ModelLivePosition` instance
      * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
      * referring to it).
      */
     detach(): void;
     /**
-     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
+     * Creates a {@link module:engine/model/position~ModelPosition position instance}, which is equal to this live position.
      */
-    toPosition(): Position;
+    toPosition(): ModelPosition;
     /**
-     * Creates a `LivePosition` instance that is equal to position.
+     * Creates a `ModelLivePosition` instance that is equal to position.
      */
-    static fromPosition(position: Position, stickiness?: PositionStickiness): LivePosition;
+    static fromPosition(position: ModelPosition, stickiness?: ModelPositionStickiness): ModelLivePosition;
     /**
      * @internal
-     * @see module:engine/model/position~Position._createAfter
+     * @see module:engine/model/position~ModelPosition._createAfter
      */
-    static readonly _createAfter: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
+    static readonly _createAfter: (item: ModelItem | ModelDocumentFragment, stickiness?: ModelPositionStickiness) => ModelLivePosition;
     /**
      * @internal
-     * @see module:engine/model/position~Position._createBefore
+     * @see module:engine/model/position~ModelPosition._createBefore
      */
-    static readonly _createBefore: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
+    static readonly _createBefore: (item: ModelItem | ModelDocumentFragment, stickiness?: ModelPositionStickiness) => ModelLivePosition;
     /**
      * @internal
-     * @see module:engine/model/position~Position._createAt
+     * @see module:engine/model/position~ModelPosition._createAt
      */
-    static readonly _createAt: (itemOrPosition: Item | Position | DocumentFragment, offset?: PositionOffset, stickiness?: PositionStickiness) => LivePosition;
+    static readonly _createAt: (itemOrPosition: ModelItem | ModelPosition | ModelDocumentFragment, offset?: ModelPositionOffset, stickiness?: ModelPositionStickiness) => ModelLivePosition;
 }
 /**
- * Fired when `LivePosition` instance is changed due to changes on {@link module:engine/model/document~Document}.
+ * Fired when `ModelLivePosition` instance is changed due to changes on {@link module:engine/model/document~ModelDocument}.
  *
- * @eventName ~LivePosition#change
+ * @eventName ~ModelLivePosition#change
  * @param oldPosition Position equal to this live position before it got changed.
  */
-export type LivePositionChangeEvent = {
+export type ModelLivePositionChangeEvent = {
     name: 'change';
-    args: [oldPosition: Position];
+    args: [oldPosition: ModelPosition];
 };
 export {};

package/src/model/liveposition.js

@@ -5,32 +5,32 @@
 /**
  * @module engine/model/liveposition
  */
-import Position from './position.js';
+import { ModelPosition } from './position.js';
 import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
 /**
- * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
- * that updates itself as {@link module:engine/model/document~Document document}
+ * `ModelLivePosition` is a type of {@link module:engine/model/position~ModelPosition Position}
+ * that updates itself as {@link module:engine/model/document~ModelDocument document}
  * is changed through operations. It may be used as a bookmark.
  *
- * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
- * {@link module:engine/model/rootelement~RootElement}.
- * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
+ * **Note:** Contrary to {@link module:engine/model/position~ModelPosition}, `ModelLivePosition` works only in roots that are
+ * {@link module:engine/model/rootelement~ModelRootElement}.
+ * If {@link module:engine/model/documentfragment~ModelDocumentFragment} is passed, error will be thrown.
  *
- * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
+ * **Note:** Be very careful when dealing with `ModelLivePosition`. Each `ModelLivePosition` instance bind events that might
  * have to be unbound.
- * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
+ * Use {@link module:engine/model/liveposition~ModelLivePosition#detach} whenever you don't need `ModelLivePosition` anymore.
  */
-export default class LivePosition extends /* #__PURE__ */ EmitterMixin(Position) {
+export class ModelLivePosition extends /* #__PURE__ */ EmitterMixin(ModelPosition) {
     /**
      * Creates a live position.
      *
-     * @see module:engine/model/position~Position
+     * @see module:engine/model/position~ModelPosition
      */
     constructor(root, path, stickiness = 'toNone') {
         super(root, path, stickiness);
         if (!this.root.is('rootElement')) {
             /**
-             * LivePosition's root has to be an instance of RootElement.
+             * LivePosition's root has to be an instance of ModelRootElement.
              *
              * @error model-liveposition-root-not-rootelement
              */
@@ -39,7 +39,7 @@ export default class LivePosition extends /* #__PURE__ */ EmitterMixin(Position)
         bindWithDocument.call(this);
     }
     /**
-     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
+     * Unbinds all events previously bound by `ModelLivePosition`. Use it whenever you don't need `ModelLivePosition` instance
      * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
      * referring to it).
      */
@@ -47,13 +47,13 @@ export default class LivePosition extends /* #__PURE__ */ EmitterMixin(Position)
         this.stopListening();
     }
     /**
-     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
+     * Creates a {@link module:engine/model/position~ModelPosition position instance}, which is equal to this live position.
      */
     toPosition() {
-        return new Position(this.root, this.path.slice(), this.stickiness);
+        return new ModelPosition(this.root, this.path.slice(), this.stickiness);
     }
     /**
-     * Creates a `LivePosition` instance that is equal to position.
+     * Creates a `ModelLivePosition` instance that is equal to position.
      */
     static fromPosition(position, stickiness) {
         return new this(position.root, position.path.slice(), stickiness ? stickiness : position.stickiness);
@@ -61,14 +61,14 @@ export default class LivePosition extends /* #__PURE__ */ EmitterMixin(Position)
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-LivePosition.prototype.is = function (type) {
+ModelLivePosition.prototype.is = function (type) {
     return type === 'livePosition' || type === 'model:livePosition' ||
         // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
         type == 'position' || type === 'model:position';
 };
 /**
- * Binds this `LivePosition` to the {@link module:engine/model/document~Document document} that owns
- * this position's {@link module:engine/model/position~Position#root root}.
+ * Binds this `ModelLivePosition` to the {@link module:engine/model/document~ModelDocument document} that owns
+ * this position's {@link module:engine/model/position~ModelPosition#root root}.
  */
 function bindWithDocument() {
     this.listenTo(this.root.document.model, 'applyOperation', (event, args) => {

package/src/model/liverange.d.ts

@@ -5,98 +5,102 @@
 /**
  * @module engine/model/liverange
  */
-import Range from './range.js';
-import type DocumentFragment from './documentfragment.js';
-import type Element from './element.js';
-import type Item from './item.js';
-import type Position from './position.js';
-declare const LiveRange_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Range, import("@ckeditor/ckeditor5-utils").Emitter>;
+import { ModelRange } from './range.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelElement } from './element.js';
+import { type ModelItem } from './item.js';
+import { type ModelPosition } from './position.js';
+declare const ModelLiveRange_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof ModelRange, import("@ckeditor/ckeditor5-utils").Emitter>;
 /**
- * `LiveRange` is a type of {@link module:engine/model/range~Range Range}
- * that updates itself as {@link module:engine/model/document~Document document}
+ * `ModelLiveRange` is a type of {@link module:engine/model/range~ModelRange Range}
+ * that updates itself as {@link module:engine/model/document~ModelDocument document}
  * is changed through operations. It may be used as a bookmark.
  *
- * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
- * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
+ * **Note:** Be very careful when dealing with `ModelLiveRange`. Each `ModelLiveRange` instance bind events that might
+ * have to be unbound. Use {@link module:engine/model/liverange~ModelLiveRange#detach detach} whenever you don't need
+ * `ModelLiveRange` anymore.
  */
-export default class LiveRange extends /* #__PURE__ */ LiveRange_base {
+export declare class ModelLiveRange extends /* #__PURE__ */ ModelLiveRange_base {
     /**
      * Creates a live range.
      *
-     * @see module:engine/model/range~Range
+     * @see module:engine/model/range~ModelRange
      */
-    constructor(start: Position, end?: Position | null);
+    constructor(start: ModelPosition, end?: ModelPosition | null);
     /**
-     * Unbinds all events previously bound by `LiveRange`. Use it whenever you don't need `LiveRange` instance
+     * Unbinds all events previously bound by `ModelLiveRange`. Use it whenever you don't need `ModelLiveRange` instance
      * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
      * referring to it).
      */
     detach(): void;
     /**
-     * Creates a {@link module:engine/model/range~Range range instance} that is equal to this live range.
+     * Creates a {@link module:engine/model/range~ModelRange range instance} that is equal to this live range.
      */
-    toRange(): Range;
+    toRange(): ModelRange;
     /**
-     * Creates a `LiveRange` instance that is equal to the given range.
+     * Creates a `ModelLiveRange` instance that is equal to the given range.
      */
-    static fromRange(range: Range): LiveRange;
+    static fromRange(range: ModelRange): ModelLiveRange;
     /**
-     * @see module:engine/model/range~Range._createIn
+     * @see module:engine/model/range~ModelRange._createIn
      * @internal
      */
-    static readonly _createIn: (element: Element | DocumentFragment) => LiveRange;
+    static readonly _createIn: (element: ModelElement | ModelDocumentFragment) => ModelLiveRange;
     /**
-     * @see module:engine/model/range~Range._createOn
+     * @see module:engine/model/range~ModelRange._createOn
      * @internal
      */
-    static readonly _createOn: (element: Item | DocumentFragment) => LiveRange;
+    static readonly _createOn: (element: ModelItem | ModelDocumentFragment) => ModelLiveRange;
     /**
-     * @see module:engine/model/range~Range._createFromPositionAndShift
+     * @see module:engine/model/range~ModelRange._createFromPositionAndShift
      * @internal
      */
-    static readonly _createFromPositionAndShift: (position: Position, shift: number) => LiveRange;
+    static readonly _createFromPositionAndShift: (position: ModelPosition, shift: number) => ModelLiveRange;
 }
 /**
- * Fired when `LiveRange` instance boundaries have changed due to changes in the
- * {@link module:engine/model/document~Document document}.
+ * Fired when `ModelLiveRange` instance boundaries have changed due to changes in the
+ * {@link module:engine/model/document~ModelDocument document}.
  *
- * @eventName ~LiveRange#change:range
+ * @eventName ~ModelLiveRange#change:range
  * @param oldRange Range with start and end position equal to start and end position of this live
  * range before it got changed.
  * @param data Object with additional information about the change.
  * @param data.deletionPosition Source position for remove and merge changes.
  * Available if the range was moved to the graveyard root, `null` otherwise.
  */
-export type LiveRangeChangeRangeEvent = {
+export type ModelLiveRangeChangeRangeEvent = {
     name: 'change' | 'change:range';
-    args: [range: Range, data: {
-        deletionPosition: Position | null;
+    args: [range: ModelRange, data: {
+        deletionPosition: ModelPosition | null;
     }];
 };
 /**
- * Fired when `LiveRange` instance boundaries have not changed after a change in {@link module:engine/model/document~Document document}
+ * Fired when `ModelLiveRange` instance boundaries have not changed after
+ * a change in {@link module:engine/model/document~ModelDocument document}
  * but the change took place inside the range, effectively changing its content.
  *
- * @eventName ~LiveRange#change:content
+ * @eventName ~ModelLiveRange#change:content
  * @param range Range with start and end position equal to start and end position of
  * change range.
  * @param data Object with additional information about the change.
  * @param data.deletionPosition Due to the nature of this event, this property is always set to `null`. It is passed
- * for compatibility with the {@link module:engine/model/liverange~LiveRange#event:change:range} event.
+ * for compatibility with the {@link module:engine/model/liverange~ModelLiveRange#event:change:range} event.
  */
-export type LiveRangeChangeContentEvent = {
+export type ModelLiveRangeChangeContentEvent = {
     name: 'change' | 'change:content';
-    args: [range: Range, data: {
+    args: [range: ModelRange, data: {
         deletionPosition: null;
     }];
 };
 /**
  * Describes `change:range` or `change:content` event.
+ *
+ * @eventName ~ModelLiveRange#change
  */
-export type LiveRangeChangeEvent = {
+export type ModelLiveRangeChangeEvent = {
     name: 'change' | 'change:range' | 'change:content';
-    args: [range: Range, data: {
-        deletionPosition: Position | null;
+    args: [range: ModelRange, data: {
+        deletionPosition: ModelPosition | null;
     }];
 };
 export {};

package/src/model/liverange.js

@@ -5,28 +5,29 @@
 /**
  * @module engine/model/liverange
  */
-import Range from './range.js';
+import { ModelRange } from './range.js';
 import { EmitterMixin } from '@ckeditor/ckeditor5-utils';
 /**
- * `LiveRange` is a type of {@link module:engine/model/range~Range Range}
- * that updates itself as {@link module:engine/model/document~Document document}
+ * `ModelLiveRange` is a type of {@link module:engine/model/range~ModelRange Range}
+ * that updates itself as {@link module:engine/model/document~ModelDocument document}
  * is changed through operations. It may be used as a bookmark.
  *
- * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
- * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
+ * **Note:** Be very careful when dealing with `ModelLiveRange`. Each `ModelLiveRange` instance bind events that might
+ * have to be unbound. Use {@link module:engine/model/liverange~ModelLiveRange#detach detach} whenever you don't need
+ * `ModelLiveRange` anymore.
  */
-export default class LiveRange extends /* #__PURE__ */ EmitterMixin(Range) {
+export class ModelLiveRange extends /* #__PURE__ */ EmitterMixin(ModelRange) {
     /**
      * Creates a live range.
      *
-     * @see module:engine/model/range~Range
+     * @see module:engine/model/range~ModelRange
      */
     constructor(start, end) {
         super(start, end);
         bindWithDocument.call(this);
     }
     /**
-     * Unbinds all events previously bound by `LiveRange`. Use it whenever you don't need `LiveRange` instance
+     * Unbinds all events previously bound by `ModelLiveRange`. Use it whenever you don't need `ModelLiveRange` instance
      * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
      * referring to it).
      */
@@ -34,28 +35,28 @@ export default class LiveRange extends /* #__PURE__ */ EmitterMixin(Range) {
         this.stopListening();
     }
     /**
-     * Creates a {@link module:engine/model/range~Range range instance} that is equal to this live range.
+     * Creates a {@link module:engine/model/range~ModelRange range instance} that is equal to this live range.
      */
     toRange() {
-        return new Range(this.start, this.end);
+        return new ModelRange(this.start, this.end);
     }
     /**
-     * Creates a `LiveRange` instance that is equal to the given range.
+     * Creates a `ModelLiveRange` instance that is equal to the given range.
      */
     static fromRange(range) {
-        return new LiveRange(range.start, range.end);
+        return new ModelLiveRange(range.start, range.end);
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-LiveRange.prototype.is = function (type) {
+ModelLiveRange.prototype.is = function (type) {
     return type === 'liveRange' || type === 'model:liveRange' ||
         // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
         type == 'range' || type === 'model:range';
 };
 /**
- * Binds this `LiveRange` to the {@link module:engine/model/document~Document document}
- * that owns this range's {@link module:engine/model/range~Range#root root}.
+ * Binds this `ModelLiveRange` to the {@link module:engine/model/document~ModelDocument document}
+ * that owns this range's {@link module:engine/model/range~ModelRange#root root}.
  */
 function bindWithDocument() {
     this.listenTo(this.root.document.model, 'applyOperation', (event, args) => {
@@ -72,7 +73,7 @@ function bindWithDocument() {
 function transform(operation) {
     // Transform the range by the operation. Join the result ranges if needed.
     const ranges = this.getTransformedByOperation(operation);
-    const result = Range._createFromRanges(ranges);
+    const result = ModelRange._createFromRanges(ranges);
     const boundariesChanged = !result.isEqual(this);
     const contentChanged = doesOperationChangeRangeContent(this, operation);
     let deletionPosition = null;