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

package/src/view/range.js

@@ -5,19 +5,19 @@
 /**
  * @module engine/view/range
  */
-import TypeCheckable from './typecheckable.js';
-import Position from './position.js';
-import { default as TreeWalker } from './treewalker.js';
+import { ViewTypeCheckable } from './typecheckable.js';
+import { ViewPosition } from './position.js';
+import { ViewTreeWalker } from './treewalker.js';
 /**
- * Range in the view tree. A range is represented by its start and end {@link module:engine/view/position~Position positions}.
+ * Range in the view tree. A range is represented by its start and end {@link module:engine/view/position~ViewPosition positions}.
  *
  * In order to create a new position instance use the `createPosition*()` factory methods available in:
  *
- * * {@link module:engine/view/view~View}
- * * {@link module:engine/view/downcastwriter~DowncastWriter}
- * * {@link module:engine/view/upcastwriter~UpcastWriter}
+ * * {@link module:engine/view/view~EditingView}
+ * * {@link module:engine/view/downcastwriter~ViewDowncastWriter}
+ * * {@link module:engine/view/upcastwriter~ViewUpcastWriter}
  */
-export default class Range extends TypeCheckable {
+export class ViewRange extends ViewTypeCheckable {
     /**
      * Start position.
      */
@@ -29,7 +29,7 @@ export default class Range extends TypeCheckable {
     /**
      * Creates a range spanning from `start` position to `end` position.
      *
-     * **Note:** Constructor creates it's own {@link module:engine/view/position~Position} instances basing on passed values.
+     * **Note:** Constructor creates it's own {@link module:engine/view/position~ViewPosition} instances basing on passed values.
      *
      * @param start Start position.
      * @param end End position. If not set, range will be collapsed at the `start` position.
@@ -42,16 +42,16 @@ export default class Range extends TypeCheckable {
     /**
      * Iterable interface.
      *
-     * Iterates over all {@link module:engine/view/item~Item view items} that are in this range and returns
-     * them together with additional information like length or {@link module:engine/view/position~Position positions},
-     * grouped as {@link module:engine/view/treewalker~TreeWalkerValue}.
+     * Iterates over all {@link module:engine/view/item~ViewItem view items} that are in this range and returns
+     * them together with additional information like length or {@link module:engine/view/position~ViewPosition positions},
+     * grouped as {@link module:engine/view/treewalker~ViewTreeWalkerValue}.
      *
-     * This iterator uses {@link module:engine/view/treewalker~TreeWalker TreeWalker} with `boundaries` set to this range and
+     * This iterator uses {@link module:engine/view/treewalker~ViewTreeWalker TreeWalker} with `boundaries` set to this range and
      * `ignoreElementEnd` option
      * set to `true`.
      */
     *[Symbol.iterator]() {
-        yield* new TreeWalker({ boundaries: this, ignoreElementEnd: true });
+        yield* new ViewTreeWalker({ boundaries: this, ignoreElementEnd: true });
     }
     /**
      * Returns whether the range is collapsed, that is it start and end positions are equal.
@@ -60,8 +60,9 @@ export default class Range extends TypeCheckable {
         return this.start.isEqual(this.end);
     }
     /**
-     * Returns whether this range is flat, that is if {@link module:engine/view/range~Range#start start} position and
-     * {@link module:engine/view/range~Range#end end} position are in the same {@link module:engine/view/position~Position#parent parent}.
+     * Returns whether this range is flat, that is if {@link module:engine/view/range~ViewRange#start start} position and
+     * {@link module:engine/view/range~ViewRange#end end} position are in the same
+     * {@link module:engine/view/position~ViewPosition#parent parent}.
      */
     get isFlat() {
         return this.start.parent === this.end.parent;
@@ -85,9 +86,9 @@ export default class Range extends TypeCheckable {
      *
      * Note that in the sample above:
      *
-     * - `<p>` have type of {@link module:engine/view/containerelement~ContainerElement},
-     * - `<b>` have type of {@link module:engine/view/attributeelement~AttributeElement},
-     * - `<span>` have type of {@link module:engine/view/uielement~UIElement}.
+     * - `<p>` have type of {@link module:engine/view/containerelement~ViewContainerElement},
+     * - `<b>` have type of {@link module:engine/view/attributeelement~ViewAttributeElement},
+     * - `<span>` have type of {@link module:engine/view/uielement~ViewUIElement}.
      *
      * @returns Enlarged range.
      */
@@ -96,12 +97,12 @@ export default class Range extends TypeCheckable {
         let end = this.end.getLastMatchingPosition(enlargeTrimSkip);
         // Fix positions, in case if they are in Text node.
         if (start.parent.is('$text') && start.isAtStart) {
-            start = Position._createBefore(start.parent);
+            start = ViewPosition._createBefore(start.parent);
         }
         if (end.parent.is('$text') && end.isAtEnd) {
-            end = Position._createAfter(end.parent);
+            end = ViewPosition._createAfter(end.parent);
         }
-        return new Range(start, end);
+        return new ViewRange(start, end);
     }
     /**
      * Creates a minimum range that has the same content as this range but is trimmed in both ways (at the beginning
@@ -116,28 +117,28 @@ export default class Range extends TypeCheckable {
      *
      * Note that in the sample above:
      *
-     * - `<p>` have type of {@link module:engine/view/containerelement~ContainerElement},
-     * - `<b>` have type of {@link module:engine/view/attributeelement~AttributeElement},
-     * - `<span>` have type of {@link module:engine/view/uielement~UIElement}.
+     * - `<p>` have type of {@link module:engine/view/containerelement~ViewContainerElement},
+     * - `<b>` have type of {@link module:engine/view/attributeelement~ViewAttributeElement},
+     * - `<span>` have type of {@link module:engine/view/uielement~ViewUIElement}.
      *
      * @returns Shrunk range.
      */
     getTrimmed() {
         let start = this.start.getLastMatchingPosition(enlargeTrimSkip);
         if (start.isAfter(this.end) || start.isEqual(this.end)) {
-            return new Range(start, start);
+            return new ViewRange(start, start);
         }
         let end = this.end.getLastMatchingPosition(enlargeTrimSkip, { direction: 'backward' });
         const nodeAfterStart = start.nodeAfter;
         const nodeBeforeEnd = end.nodeBefore;
         // Because TreeWalker prefers positions next to text node, we need to move them manually into these text nodes.
         if (nodeAfterStart && nodeAfterStart.is('$text')) {
-            start = new Position(nodeAfterStart, 0);
+            start = new ViewPosition(nodeAfterStart, 0);
         }
         if (nodeBeforeEnd && nodeBeforeEnd.is('$text')) {
-            end = new Position(nodeBeforeEnd, nodeBeforeEnd.data.length);
+            end = new ViewPosition(nodeBeforeEnd, nodeBeforeEnd.data.length);
         }
-        return new Range(start, end);
+        return new ViewRange(start, end);
     }
     /**
      * Two ranges are equal if their start and end positions are equal.
@@ -149,22 +150,22 @@ export default class Range extends TypeCheckable {
         return this == otherRange || (this.start.isEqual(otherRange.start) && this.end.isEqual(otherRange.end));
     }
     /**
-     * Checks whether this range contains given {@link module:engine/view/position~Position position}.
+     * Checks whether this range contains given {@link module:engine/view/position~ViewPosition position}.
      *
      * @param position Position to check.
-     * @returns `true` if given {@link module:engine/view/position~Position position} is contained in this range, `false` otherwise.
+     * @returns `true` if given {@link module:engine/view/position~ViewPosition position} is contained in this range, `false` otherwise.
      */
     containsPosition(position) {
         return position.isAfter(this.start) && position.isBefore(this.end);
     }
     /**
-     * Checks whether this range contains given {@link module:engine/view/range~Range range}.
+     * Checks whether this range contains given {@link module:engine/view/range~ViewRange range}.
      *
      * @param otherRange Range to check.
      * @param loose Whether the check is loose or strict. If the check is strict (`false`), compared range cannot
      * start or end at the same position as this range boundaries. If the check is loose (`true`), compared range can start, end or
      * even be equal to this range. Note that collapsed ranges are always compared in strict mode.
-     * @returns `true` if given {@link module:engine/view/range~Range range} boundaries are contained by this range, `false`
+     * @returns `true` if given {@link module:engine/view/range~ViewRange range} boundaries are contained by this range, `false`
      * otherwise.
      */
     containsRange(otherRange, loose = false) {
@@ -176,9 +177,9 @@ export default class Range extends TypeCheckable {
         return containsStart && containsEnd;
     }
     /**
-     * Computes which part(s) of this {@link module:engine/view/range~Range range} is not a part of given
-     * {@link module:engine/view/range~Range range}.
-     * Returned array contains zero, one or two {@link module:engine/view/range~Range ranges}.
+     * Computes which part(s) of this {@link module:engine/view/range~ViewRange range} is not a part of given
+     * {@link module:engine/view/range~ViewRange range}.
+     * Returned array contains zero, one or two {@link module:engine/view/range~ViewRange ranges}.
      *
      * Examples:
      *
@@ -215,12 +216,12 @@ export default class Range extends TypeCheckable {
             if (this.containsPosition(otherRange.start)) {
                 // Given range start is inside this range. This means that we have to
                 // add shrunken range - from the start to the middle of this range.
-                ranges.push(new Range(this.start, otherRange.start));
+                ranges.push(new ViewRange(this.start, otherRange.start));
             }
             if (this.containsPosition(otherRange.end)) {
                 // Given range end is inside this range. This means that we have to
                 // add shrunken range - from the middle of this range to the end.
-                ranges.push(new Range(otherRange.end, this.end));
+                ranges.push(new ViewRange(otherRange.end, this.end));
             }
         }
         else {
@@ -230,7 +231,8 @@ export default class Range extends TypeCheckable {
         return ranges;
     }
     /**
-     * Returns an intersection of this {@link module:engine/view/range~Range range} and given {@link module:engine/view/range~Range range}.
+     * Returns an intersection of this {@link module:engine/view/range~ViewRange range}
+     * and given {@link module:engine/view/range~ViewRange range}.
      * Intersection is a common part of both of those ranges. If ranges has no common part, returns `null`.
      *
      * Examples:
@@ -268,29 +270,29 @@ export default class Range extends TypeCheckable {
                 // shrink common range to the given range end.
                 commonRangeEnd = otherRange.end;
             }
-            return new Range(commonRangeStart, commonRangeEnd);
+            return new ViewRange(commonRangeStart, commonRangeEnd);
         }
         // Ranges do not intersect, so they do not have common part.
         return null;
     }
     /**
-     * Creates a {@link module:engine/view/treewalker~TreeWalker TreeWalker} instance with this range as a boundary.
+     * Creates a {@link module:engine/view/treewalker~ViewTreeWalker TreeWalker} instance with this range as a boundary.
      *
-     * @param options Object with configuration options. See {@link module:engine/view/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/view/treewalker~ViewTreeWalker}.
      */
     getWalker(options = {}) {
         options.boundaries = this;
-        return new TreeWalker(options);
+        return new ViewTreeWalker(options);
     }
     /**
-     * Returns a {@link module:engine/view/node~Node} or {@link module:engine/view/documentfragment~DocumentFragment}
+     * Returns a {@link module:engine/view/node~ViewNode} or {@link module:engine/view/documentfragment~ViewDocumentFragment}
      * which is a common ancestor of range's both ends (in which the entire range is contained).
      */
     getCommonAncestor() {
         return this.start.getCommonAncestor(this.end);
     }
     /**
-     * Returns an {@link module:engine/view/element~Element Element} contained by the range.
+     * Returns an {@link module:engine/view/element~ViewElement Element} contained by the range.
      * The element will be returned when it is the **only** node within the range and **fully–contained**
      * at the same time.
      */
@@ -324,44 +326,44 @@ export default class Range extends TypeCheckable {
      * Clones this range.
      */
     clone() {
-        return new Range(this.start, this.end);
+        return new ViewRange(this.start, this.end);
     }
     /**
-     * Returns an iterator that iterates over all {@link module:engine/view/item~Item view items} that are in this range and returns
+     * Returns an iterator that iterates over all {@link module:engine/view/item~ViewItem view items} that are in this range and returns
      * them.
      *
-     * This method uses {@link module:engine/view/treewalker~TreeWalker} with `boundaries` set to this range and `ignoreElementEnd` option
-     * set to `true`. However it returns only {@link module:engine/view/item~Item items},
-     * not {@link module:engine/view/treewalker~TreeWalkerValue}.
+     * This method uses {@link module:engine/view/treewalker~ViewTreeWalker} with `boundaries` set to this range
+     * and `ignoreElementEnd` option set to `true`. However it returns only {@link module:engine/view/item~ViewItem items},
+     * not {@link module:engine/view/treewalker~ViewTreeWalkerValue}.
      *
-     * You may specify additional options for the tree walker. See {@link module:engine/view/treewalker~TreeWalker} for
+     * You may specify additional options for the tree walker. See {@link module:engine/view/treewalker~ViewTreeWalker} for
      * a full list of available options.
      *
-     * @param options Object with configuration options. See {@link module:engine/view/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/view/treewalker~ViewTreeWalker}.
      */
     *getItems(options = {}) {
         options.boundaries = this;
         options.ignoreElementEnd = true;
-        const treeWalker = new TreeWalker(options);
+        const treeWalker = new ViewTreeWalker(options);
         for (const value of treeWalker) {
             yield value.item;
         }
     }
     /**
-     * Returns an iterator that iterates over all {@link module:engine/view/position~Position positions} that are boundaries or
+     * Returns an iterator that iterates over all {@link module:engine/view/position~ViewPosition positions} that are boundaries or
      * contained in this range.
      *
-     * This method uses {@link module:engine/view/treewalker~TreeWalker} with `boundaries` set to this range. However it returns only
-     * {@link module:engine/view/position~Position positions}, not {@link module:engine/view/treewalker~TreeWalkerValue}.
+     * This method uses {@link module:engine/view/treewalker~ViewTreeWalker} with `boundaries` set to this range. However it returns only
+     * {@link module:engine/view/position~ViewPosition positions}, not {@link module:engine/view/treewalker~ViewTreeWalkerValue}.
      *
-     * You may specify additional options for the tree walker. See {@link module:engine/view/treewalker~TreeWalker} for
+     * You may specify additional options for the tree walker. See {@link module:engine/view/treewalker~ViewTreeWalker} for
      * a full list of available options.
      *
-     * @param options Object with configuration options. See {@link module:engine/view/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/view/treewalker~ViewTreeWalker}.
      */
     *getPositions(options = {}) {
         options.boundaries = this;
-        const treeWalker = new TreeWalker(options);
+        const treeWalker = new ViewTreeWalker(options);
         yield treeWalker.position;
         for (const value of treeWalker) {
             yield value.nextPosition;
@@ -387,10 +389,10 @@ export default class Range extends TypeCheckable {
      * @returns Created range.
      */
     static _createFromParentsAndOffsets(startElement, startOffset, endElement, endOffset) {
-        return new this(new Position(startElement, startOffset), new Position(endElement, endOffset));
+        return new this(new ViewPosition(startElement, startOffset), new ViewPosition(endElement, endOffset));
     }
     /**
-     * Creates a new range, spreading from specified {@link module:engine/view/position~Position position} to a position moved by
+     * Creates a new range, spreading from specified {@link module:engine/view/position~ViewPosition position} to a position moved by
      * given `shift`. If `shift` is a negative value, shifted position is treated as the beginning of the range.
      *
      * @internal
@@ -403,7 +405,7 @@ export default class Range extends TypeCheckable {
         return shift > 0 ? new this(start, end) : new this(end, start);
     }
     /**
-     * Creates a range inside an {@link module:engine/view/element~Element element} which starts before the first child of
+     * Creates a range inside an {@link module:engine/view/element~ViewElement element} which starts before the first child of
      * that element and ends after the last child of that element.
      *
      * @internal
@@ -413,18 +415,18 @@ export default class Range extends TypeCheckable {
         return this._createFromParentsAndOffsets(element, 0, element, element.childCount);
     }
     /**
-     * Creates a range that starts before given {@link module:engine/view/item~Item view item} and ends after it.
+     * Creates a range that starts before given {@link module:engine/view/item~ViewItem view item} and ends after it.
      *
      * @internal
      */
     static _createOn(item) {
         const size = item.is('$textProxy') ? item.offsetSize : 1;
-        return this._createFromPositionAndShift(Position._createBefore(item), size);
+        return this._createFromPositionAndShift(ViewPosition._createBefore(item), size);
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-Range.prototype.is = function (type) {
+ViewRange.prototype.is = function (type) {
     return type === 'range' || type === 'view:range';
 };
 /**

package/src/view/rawelement.d.ts

@@ -5,11 +5,11 @@
 /**
  * @module engine/view/rawelement
  */
-import Element, { type ElementAttributes } from './element.js';
-import Node from './node.js';
-import type Document from './document.js';
-import type DomConverter from './domconverter.js';
-import type Item from './item.js';
+import { ViewElement, type ViewElementAttributes } from './element.js';
+import { ViewNode } from './node.js';
+import { type ViewDocument } from './document.js';
+import { type ViewDomConverter } from './domconverter.js';
+import { type ViewItem } from './item.js';
 type DomElement = globalThis.HTMLElement;
 /**
  * The raw element class.
@@ -19,40 +19,40 @@ type DomElement = globalThis.HTMLElement;
  * in the editor content without, for instance, worrying about compatibility with other editor features.
  * Raw elements are a perfect tool for integration with external frameworks and data sources.
  *
- * Unlike {@link module:engine/view/uielement~UIElement UI elements}, raw elements act like real editor
- * content (similar to {@link module:engine/view/containerelement~ContainerElement} or
- * {@link module:engine/view/emptyelement~EmptyElement}), they are considered by the editor selection and
+ * Unlike {@link module:engine/view/uielement~ViewUIElement UI elements}, raw elements act like real editor
+ * content (similar to {@link module:engine/view/containerelement~ViewContainerElement} or
+ * {@link module:engine/view/emptyelement~ViewEmptyElement}), they are considered by the editor selection and
  * {@link module:widget/utils~toWidget they can work as widgets}.
  *
  * To create a new raw element, use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createRawElement `downcastWriter#createRawElement()`} method.
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createRawElement `downcastWriter#createRawElement()`} method.
  */
-export default class RawElement extends Element {
+export declare class ViewRawElement extends ViewElement {
     /**
      * Creates a new instance of a raw element.
      *
      * Throws the `view-rawelement-cannot-add` {@link module:utils/ckeditorerror~CKEditorError CKEditorError} when the `children`
-     * parameter is passed to inform that the usage of `RawElement` is incorrect (adding child nodes to `RawElement` is forbidden).
+     * parameter is passed to inform that the usage of `ViewRawElement` is incorrect (adding child nodes to `ViewRawElement` is forbidden).
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createRawElement
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createRawElement
      * @internal
      * @param document The document instance to which this element belongs.
      * @param name Node name.
      * @param attrs Collection of attributes.
      * @param children A list of nodes to be inserted into created element.
      */
-    constructor(document: Document, name: string, attrs?: ElementAttributes, children?: Node | Iterable<Node>);
+    constructor(document: ViewDocument, name: string, attrs?: ViewElementAttributes, children?: ViewNode | Iterable<ViewNode>);
     /**
-     * Overrides the {@link module:engine/view/element~Element#_insertChild} method.
+     * Overrides the {@link module:engine/view/element~ViewElement#_insertChild} method.
      * Throws the `view-rawelement-cannot-add` {@link module:utils/ckeditorerror~CKEditorError CKEditorError} to prevent
      * adding any child nodes to a raw element.
      *
      * @internal
      */
-    _insertChild(index: number, items: Item | Iterable<Item>): number;
+    _insertChild(index: number, items: ViewItem | Iterable<ViewItem>): number;
     /**
-     * This allows rendering the children of a {@link module:engine/view/rawelement~RawElement} on the DOM level.
-     * This method is called by the {@link module:engine/view/domconverter~DomConverter} with the raw DOM element
+     * This allows rendering the children of a {@link module:engine/view/rawelement~ViewRawElement} on the DOM level.
+     * This method is called by the {@link module:engine/view/domconverter~ViewDomConverter} with the raw DOM element
      * passed as an argument, leaving the number and shape of the children up to the integrator.
      *
      * This method **must be defined** for the raw element to work:
@@ -66,8 +66,8 @@ export default class RawElement extends Element {
      * ```
      *
      * @param domElement The native DOM element representing the raw view element.
-     * @param domConverter Instance of the DomConverter used to optimize the output.
+     * @param domConverter Instance of the ViewDomConverter used to optimize the output.
      */
-    render(domElement: DomElement, domConverter: DomConverter): void;
+    render(domElement: DomElement, domConverter: ViewDomConverter): void;
 }
 export {};

package/src/view/rawelement.js

@@ -6,8 +6,8 @@
 /**
  * @module engine/view/rawelement
  */
-import Element from './element.js';
-import Node from './node.js';
+import { ViewElement } from './element.js';
+import { ViewNode } from './node.js';
 import { CKEditorError } from '@ckeditor/ckeditor5-utils';
 /**
  * The raw element class.
@@ -17,22 +17,22 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * in the editor content without, for instance, worrying about compatibility with other editor features.
  * Raw elements are a perfect tool for integration with external frameworks and data sources.
  *
- * Unlike {@link module:engine/view/uielement~UIElement UI elements}, raw elements act like real editor
- * content (similar to {@link module:engine/view/containerelement~ContainerElement} or
- * {@link module:engine/view/emptyelement~EmptyElement}), they are considered by the editor selection and
+ * Unlike {@link module:engine/view/uielement~ViewUIElement UI elements}, raw elements act like real editor
+ * content (similar to {@link module:engine/view/containerelement~ViewContainerElement} or
+ * {@link module:engine/view/emptyelement~ViewEmptyElement}), they are considered by the editor selection and
  * {@link module:widget/utils~toWidget they can work as widgets}.
  *
  * To create a new raw element, use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createRawElement `downcastWriter#createRawElement()`} method.
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createRawElement `downcastWriter#createRawElement()`} method.
  */
-export default class RawElement extends Element {
+export class ViewRawElement extends ViewElement {
     /**
      * Creates a new instance of a raw element.
      *
      * Throws the `view-rawelement-cannot-add` {@link module:utils/ckeditorerror~CKEditorError CKEditorError} when the `children`
-     * parameter is passed to inform that the usage of `RawElement` is incorrect (adding child nodes to `RawElement` is forbidden).
+     * parameter is passed to inform that the usage of `ViewRawElement` is incorrect (adding child nodes to `ViewRawElement` is forbidden).
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createRawElement
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createRawElement
      * @internal
      * @param document The document instance to which this element belongs.
      * @param name Node name.
@@ -45,16 +45,16 @@ export default class RawElement extends Element {
         this.getFillerOffset = getFillerOffset;
     }
     /**
-     * Overrides the {@link module:engine/view/element~Element#_insertChild} method.
+     * Overrides the {@link module:engine/view/element~ViewElement#_insertChild} method.
      * Throws the `view-rawelement-cannot-add` {@link module:utils/ckeditorerror~CKEditorError CKEditorError} to prevent
      * adding any child nodes to a raw element.
      *
      * @internal
      */
     _insertChild(index, items) {
-        if (items && (items instanceof Node || Array.from(items).length > 0)) {
+        if (items && (items instanceof ViewNode || Array.from(items).length > 0)) {
             /**
-             * Cannot add children to a {@link module:engine/view/rawelement~RawElement} instance.
+             * Cannot add children to a {@link module:engine/view/rawelement~ViewRawElement} instance.
              *
              * @error view-rawelement-cannot-add
              */
@@ -63,8 +63,8 @@ export default class RawElement extends Element {
         return 0;
     }
     /**
-     * This allows rendering the children of a {@link module:engine/view/rawelement~RawElement} on the DOM level.
-     * This method is called by the {@link module:engine/view/domconverter~DomConverter} with the raw DOM element
+     * This allows rendering the children of a {@link module:engine/view/rawelement~ViewRawElement} on the DOM level.
+     * This method is called by the {@link module:engine/view/domconverter~ViewDomConverter} with the raw DOM element
      * passed as an argument, leaving the number and shape of the children up to the integrator.
      *
      * This method **must be defined** for the raw element to work:
@@ -78,13 +78,13 @@ export default class RawElement extends Element {
      * ```
      *
      * @param domElement The native DOM element representing the raw view element.
-     * @param domConverter Instance of the DomConverter used to optimize the output.
+     * @param domConverter Instance of the ViewDomConverter used to optimize the output.
      */
     render(domElement, domConverter) { }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-RawElement.prototype.is = function (type, name) {
+ViewRawElement.prototype.is = function (type, name) {
     if (!name) {
         return type === 'rawElement' || type === 'view:rawElement' ||
             // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.

package/src/view/renderer.d.ts

@@ -2,20 +2,20 @@
  * @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 { ChangeType } from './document.js';
-import type DocumentSelection from './documentselection.js';
-import type DomConverter from './domconverter.js';
-import type ViewElement from './element.js';
-import type ViewNode from './node.js';
+import type { ViewDocumentChangeType } from './document.js';
+import { type ViewDocumentSelection } from './documentselection.js';
+import { type ViewDomConverter } from './domconverter.js';
+import { type ViewElement } from './element.js';
+import { type ViewNode } from './node.js';
 import '../../theme/renderer.css';
 type DomDocument = globalThis.Document;
-declare const Renderer_base: {
+declare const ViewRenderer_base: {
     new (): import("@ckeditor/ckeditor5-utils").Observable;
     prototype: import("@ckeditor/ckeditor5-utils").Observable;
 };
 /**
  * Renderer is responsible for updating the DOM structure and the DOM selection based on
- * the {@link module:engine/view/renderer~Renderer#markToSync information about updated view nodes}.
+ * the {@link module:engine/view/renderer~ViewRenderer#markToSync information about updated view nodes}.
  * In other words, it renders the view to the DOM.
  *
  * Its main responsibility is to make only the necessary, minimal changes to the DOM. However, unlike in many
@@ -23,10 +23,10 @@ declare const Renderer_base: {
  * that native editing features such as text composition, autocompletion, spell checking, selection's x-index are
  * affected as little as possible.
  *
- * Renderer uses {@link module:engine/view/domconverter~DomConverter} to transform view nodes and positions
+ * Renderer uses {@link module:engine/view/domconverter~ViewDomConverter} to transform view nodes and positions
  * to and from the DOM.
  */
-export default class Renderer extends /* #__PURE__ */ Renderer_base {
+export declare class ViewRenderer extends /* #__PURE__ */ ViewRenderer_base {
     /**
      * Set of DOM Documents instances.
      */
@@ -34,7 +34,7 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
     /**
      * Converter instance.
      */
-    readonly domConverter: DomConverter;
+    readonly domConverter: ViewDomConverter;
     /**
      * Set of nodes which attributes changed and may need to be rendered.
      */
@@ -50,7 +50,7 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
     /**
      * View selection. Renderer updates DOM selection based on the view selection.
      */
-    readonly selection: DocumentSelection;
+    readonly selection: ViewDocumentSelection;
     /**
      * Indicates if the view document is focused and selection can be rendered. Selection will not be rendered if
      * this is set to `false`.
@@ -72,7 +72,7 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
     /**
      * True if composition is in progress inside the document.
      *
-     * This property is bound to the {@link module:engine/view/document~Document#isComposing `Document#isComposing`} property.
+     * This property is bound to the {@link module:engine/view/document~ViewDocument#isComposing `Document#isComposing`} property.
      *
      * @observable
      */
@@ -91,7 +91,7 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
      * @param domConverter Converter instance.
      * @param selection View selection.
      */
-    constructor(domConverter: DomConverter, selection: DocumentSelection);
+    constructor(domConverter: ViewDomConverter, selection: ViewDocumentSelection);
     /**
      * Marks a view node to be updated in the DOM by {@link #render `render()`}.
      *
@@ -104,7 +104,7 @@ export default class Renderer extends /* #__PURE__ */ Renderer_base {
      * @param type Type of the change.
      * @param node ViewNode to be marked.
      */
-    markToSync(type: ChangeType, node: ViewNode): void;
+    markToSync(type: ViewDocumentChangeType, node: ViewNode): void;
     /**
      * Renders all buffered changes ({@link #markedAttributes}, {@link #markedChildren} and {@link #markedTexts}) and
      * the current view selection (if needed) to the DOM by applying a minimal set of changes to it.

package/src/view/renderer.js

@@ -5,15 +5,15 @@
 /**
  * @module engine/view/renderer
  */
-import ViewText from './text.js';
-import ViewPosition from './position.js';
+import { ViewText } from './text.js';
+import { ViewPosition } from './position.js';
 import { INLINE_FILLER, INLINE_FILLER_LENGTH, startsWithFiller, isInlineFiller } from './filler.js';
 import { CKEditorError, ObservableMixin, diff, env, fastDiff, insertAt, isComment, isNode, isText, remove, indexOf } from '@ckeditor/ckeditor5-utils';
 // @if CK_DEBUG_TYPING // const { _buildLogMessage } = require( '../dev-utils/utils.js' );
 import '../../theme/renderer.css';
 /**
  * Renderer is responsible for updating the DOM structure and the DOM selection based on
- * the {@link module:engine/view/renderer~Renderer#markToSync information about updated view nodes}.
+ * the {@link module:engine/view/renderer~ViewRenderer#markToSync information about updated view nodes}.
  * In other words, it renders the view to the DOM.
  *
  * Its main responsibility is to make only the necessary, minimal changes to the DOM. However, unlike in many
@@ -21,10 +21,10 @@ import '../../theme/renderer.css';
  * that native editing features such as text composition, autocompletion, spell checking, selection's x-index are
  * affected as little as possible.
  *
- * Renderer uses {@link module:engine/view/domconverter~DomConverter} to transform view nodes and positions
+ * Renderer uses {@link module:engine/view/domconverter~ViewDomConverter} to transform view nodes and positions
  * to and from the DOM.
  */
-export default class Renderer extends /* #__PURE__ */ ObservableMixin() {
+export class ViewRenderer extends /* #__PURE__ */ ObservableMixin() {
     /**
      * Set of DOM Documents instances.
      */
@@ -182,7 +182,7 @@ export default class Renderer extends /* #__PURE__ */ ObservableMixin() {
                 this.markedChildren.add(inlineFillerPosition.parent);
             }
         }
-        // Make sure the inline filler has any parent, so it can be mapped to view position by DomConverter.
+        // Make sure the inline filler has any parent, so it can be mapped to view position by ViewDomConverter.
         else if (this._inlineFiller && this._inlineFiller.parentNode) {
             // While the user is making selection, preserve the inline filler at its original position.
             inlineFillerPosition = this.domConverter.domPositionToView(this._inlineFiller);
@@ -1061,7 +1061,7 @@ function areTextNodes(node1, node2) {
  * * Element nodes represented by the same object.
  * * Two block filler elements.
  *
- * @param blockFillerMode Block filler mode, see {@link module:engine/view/domconverter~DomConverter#blockFillerMode}.
+ * @param blockFillerMode Block filler mode, see {@link module:engine/view/domconverter~ViewDomConverter#blockFillerMode}.
  */
 function sameNodes(domConverter, actualDomChild, expectedDomChild) {
     // Elements.