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

package/src/dev-utils/model.js

@@ -8,32 +8,32 @@
 /**
  * Collection of methods for manipulating the {@link module:engine/model/model model} for testing purposes.
  */
-import RootElement from '../model/rootelement.js';
-import Model from '../model/model.js';
-import ModelRange from '../model/range.js';
-import ModelPosition from '../model/position.js';
-import ModelSelection from '../model/selection.js';
-import ModelDocumentFragment from '../model/documentfragment.js';
-import DocumentSelection from '../model/documentselection.js';
-import View from '../view/view.js';
-import ViewContainerElement from '../view/containerelement.js';
-import ViewRootEditableElement from '../view/rooteditableelement.js';
-import { parse as viewParse, stringify as viewStringify } from '../../src/dev-utils/view.js';
-import Mapper from '../conversion/mapper.js';
+import { ModelRootElement } from '../model/rootelement.js';
+import { Model } from '../model/model.js';
+import { ModelRange } from '../model/range.js';
+import { ModelPosition } from '../model/position.js';
+import { ModelSelection } from '../model/selection.js';
+import { ModelDocumentFragment } from '../model/documentfragment.js';
+import { ModelDocumentSelection } from '../model/documentselection.js';
+import { EditingView } from '../view/view.js';
+import { ViewContainerElement } from '../view/containerelement.js';
+import { ViewRootEditableElement } from '../view/rooteditableelement.js';
+import { _parseView, _stringifyView } from '../../src/dev-utils/view.js';
+import { Mapper } from '../conversion/mapper.js';
 import { convertCollapsedSelection, convertRangeSelection, insertAttributesAndChildren, insertElement, insertText, insertUIElement, wrap } from '../conversion/downcasthelpers.js';
 import { StylesProcessor } from '../view/stylesmap.js';
-import DowncastDispatcher from '../conversion/downcastdispatcher.js';
-import UpcastDispatcher from '../conversion/upcastdispatcher.js';
+import { DowncastDispatcher } from '../conversion/downcastdispatcher.js';
+import { UpcastDispatcher } from '../conversion/upcastdispatcher.js';
 import { toMap } from '@ckeditor/ckeditor5-utils';
 import { isPlainObject } from 'es-toolkit/compat';
 /**
- * Writes the content of a model {@link module:engine/model/document~Document document} to an HTML-like string.
+ * Writes the content of a model {@link module:engine/model/document~ModelDocument document} to an HTML-like string.
  *
  * ```ts
  * getData( editor.model ); // -> '<paragraph>Foo![]</paragraph>'
  * ```
  *
- * **Note:** A {@link module:engine/model/text~Text text} node that contains attributes will be represented as:
+ * **Note:** A {@link module:engine/model/text~ModelText text} node that contains attributes will be represented as:
  *
  * ```xml
  * <$text attribute="value">Text data</$text>
@@ -49,18 +49,18 @@ import { isPlainObject } from 'es-toolkit/compat';
  * @param options.convertMarkers Whether to include markers in the returned string.
  * @returns The stringified data.
  */
-export function getData(model, options = {}) {
+export function _getModelData(model, options = {}) {
     if (!(model instanceof Model)) {
         throw new TypeError('Model needs to be an instance of module:engine/model/model~Model.');
     }
     const rootName = options.rootName || 'main';
     const root = model.document.getRoot(rootName);
-    return getData._stringify(root, options.withoutSelection ? null : model.document.selection, options.convertMarkers ? model.markers : null);
+    return _getModelData._stringify(root, options.withoutSelection ? null : model.document.selection, options.convertMarkers ? model.markers : null);
 }
 // Set stringify as getData private method - needed for testing/spying.
-getData._stringify = stringify;
+_getModelData._stringify = _stringifyModel;
 /**
- * Sets the content of a model {@link module:engine/model/document~Document document} provided as an HTML-like string.
+ * Sets the content of a model {@link module:engine/model/document~ModelDocument document} provided as an HTML-like string.
  *
  * ```ts
  * setData( editor.model, '<paragraph>Foo![]</paragraph>' );
@@ -69,7 +69,7 @@ getData._stringify = stringify;
  * **Note:** Remember to register elements in the {@link module:engine/model/model~Model#schema model's schema} before
  * trying to use them.
  *
- * **Note:** To create a {@link module:engine/model/text~Text text} node that contains attributes use:
+ * **Note:** To create a {@link module:engine/model/text~ModelText text} node that contains attributes use:
  *
  * ```xml
  * <$text attribute="value">Text data</$text>
@@ -84,9 +84,8 @@ getData._stringify = stringify;
  * @param options.selectionAttributes A list of attributes which will be passed to the selection.
  * @param options.lastRangeBackward If set to `true`, the last range will be added as backward.
  * @param options.batchType Batch type used for inserting elements. See {@link module:engine/model/batch~Batch#constructor}.
- * See {@link module:engine/model/batch~Batch#type}.
  */
-export function setData(model, data, options = {}) {
+export function _setModelData(model, data, options = {}) {
     if (!(model instanceof Model)) {
         throw new TypeError('Model needs to be an instance of module:engine/model/model~Model.');
     }
@@ -94,7 +93,7 @@ export function setData(model, data, options = {}) {
     let selection = null;
     const modelRoot = model.document.getRoot(options.rootName || 'main');
     // Parse data string to model.
-    const parsedResult = setData._parse(data, model.schema, {
+    const parsedResult = _setModelData._parse(data, model.schema, {
         lastRangeBackward: options.lastRangeBackward,
         selectionAttributes: options.selectionAttributes,
         context: [modelRoot.name],
@@ -137,11 +136,11 @@ export function setData(model, data, options = {}) {
     }
 }
 // Set parse as setData private method - needed for testing/spying.
-setData._parse = parse;
+_setModelData._parse = _parseModel;
 /**
  * Converts model nodes to HTML-like string representation.
  *
- * **Note:** A {@link module:engine/model/text~Text text} node that contains attributes will be represented as:
+ * **Note:** A {@link module:engine/model/text~ModelText text} node that contains attributes will be represented as:
  *
  * ```xml
  * <$text attribute="value">Text data</$text>
@@ -154,13 +153,13 @@ setData._parse = parse;
  * @param markers Markers to include.
  * @returns An HTML-like string representing the model.
  */
-export function stringify(node, selectionOrPositionOrRange = null, markers = null) {
+export function _stringifyModel(node, selectionOrPositionOrRange = null, markers = null) {
     const model = new Model();
     const mapper = new Mapper();
     let selection = null;
     let range;
     // Create a range witch wraps passed node.
-    if (node instanceof RootElement || node instanceof ModelDocumentFragment) {
+    if (node instanceof ModelRootElement || node instanceof ModelDocumentFragment) {
         range = model.createRangeIn(node);
     }
     else {
@@ -177,7 +176,7 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
     if (selectionOrPositionOrRange instanceof ModelSelection) {
         selection = selectionOrPositionOrRange;
     }
-    else if (selectionOrPositionOrRange instanceof DocumentSelection) {
+    else if (selectionOrPositionOrRange instanceof ModelDocumentSelection) {
         selection = selectionOrPositionOrRange;
     }
     else if (selectionOrPositionOrRange instanceof ModelRange) {
@@ -189,7 +188,7 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
     // Set up conversion.
     // Create a temporary view controller.
     const stylesProcessor = new StylesProcessor();
-    const view = new View(stylesProcessor);
+    const view = new EditingView(stylesProcessor);
     const viewDocument = view.document;
     const viewRoot = new ViewRootEditableElement(viewDocument, 'div');
     // Create a temporary root element in view document.
@@ -202,7 +201,7 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
     downcastDispatcher.on('insert:$text', insertText());
     downcastDispatcher.on('insert', insertAttributesAndChildren(), { priority: 'lowest' });
     downcastDispatcher.on('attribute', (evt, data, conversionApi) => {
-        if (data.item instanceof ModelSelection || data.item instanceof DocumentSelection || data.item.is('$textProxy')) {
+        if (data.item instanceof ModelSelection || data.item instanceof ModelDocumentSelection || data.item.is('$textProxy')) {
             const converter = wrap((modelAttributeValue, { writer }) => {
                 return writer.createAttributeElement('model-text-with-attributes', { [data.attributeKey]: stringifyAttributeValue(modelAttributeValue) });
             });
@@ -235,7 +234,7 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
         downcastDispatcher.convertSelection(selection, markers || model.markers, writer);
     }
     // Parse view to data string.
-    let data = viewStringify(viewRoot, viewDocument.selection, { sameSelectionCharacters: true });
+    let data = _stringifyView(viewRoot, viewDocument.selection, { sameSelectionCharacters: true });
     // Removing unnecessary <div> and </div> added because `viewRoot` was also stringified alongside input data.
     data = data.substr(5, data.length - 11);
     view.destroy();
@@ -243,9 +242,9 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
     return data.replace(new RegExp('model-text-with-attributes', 'g'), '$text');
 }
 /**
- * Parses an HTML-like string and returns the model {@link module:engine/model/rootelement~RootElement rootElement}.
+ * Parses an HTML-like string and returns the model {@link module:engine/model/rootelement~ModelRootElement rootElement}.
  *
- * **Note:** To create a {@link module:engine/model/text~Text text} node that contains attributes use:
+ * **Note:** To create a {@link module:engine/model/text~ModelText text} node that contains attributes use:
  *
  * ```xml
  * <$text attribute="value">Text data</$text>
@@ -260,12 +259,12 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
  * @returns Returns the parsed model node or an object with two fields: `model` and `selection`,
  * when selection ranges were included in the data to parse.
  */
-export function parse(data, schema, options = {}) {
+export function _parseModel(data, schema, options = {}) {
     const mapper = new Mapper();
     // Replace not accepted by XML `$text` tag name by valid one `model-text-with-attributes`.
     data = data.replace(new RegExp('\\$text', 'g'), 'model-text-with-attributes');
     // Parse data to view using view utils.
-    const parsedResult = viewParse(data, {
+    const parsedResult = _parseView(data, {
         sameSelectionCharacters: true,
         lastRangeBackward: !!options.lastRangeBackward,
         inlineObjectElements: options.inlineObjectElements

package/src/dev-utils/operationreplayer.d.ts

@@ -2,12 +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 Model from '../model/model.js';
-import type Operation from '../model/operation/operation.js';
+import { type Model } from '../model/model.js';
+import { type Operation } from '../model/operation/operation.js';
 /**
  * Operation replayer is a development tool created for easy replaying of operations on the document from stringified operations.
+ *
+ * @internal
  */
-export default class OperationReplayer {
+export declare class OperationReplayer {
     private _model;
     private _logSeparator;
     private _operationsToReplay;

package/src/dev-utils/operationreplayer.js

@@ -5,11 +5,13 @@
 /**
  * @module engine/dev-utils/operationreplayer
  */
-import OperationFactory from '../model/operation/operationfactory.js';
+import { OperationFactory } from '../model/operation/operationfactory.js';
 /**
  * Operation replayer is a development tool created for easy replaying of operations on the document from stringified operations.
+ *
+ * @internal
  */
-export default class OperationReplayer {
+export class OperationReplayer {
     _model;
     _logSeparator;
     _operationsToReplay;

package/src/dev-utils/utils.d.ts

@@ -14,6 +14,7 @@
  *
  * @param map Map to convert.
  * @returns Converted map.
+ * @internal
  */
 export declare function convertMapToTags(map: Iterable<[string, unknown]>): string;
 /**
@@ -21,17 +22,24 @@ export declare function convertMapToTags(map: Iterable<[string, unknown]>): stri
  *
  * @param map Map to convert.
  * @returns Converted map.
+ * @internal
  */
 export declare function convertMapToStringifiedObject(map: Iterable<[string, unknown]>): string;
 /**
  * Helper function that stores the `document` state for a given `version`.
+ *
+ * @internal
  */
 export declare function dumpTrees(document: any, version: any): void;
 /**
  * Helper function that initializes document dumping.
+ *
+ * @internal
  */
 export declare function initDocumentDumping(document: any): void;
 /**
  * Helper function that logs document for the given version.
+ *
+ * @internal
  */
 export declare function logDocument(document: any, version: any): void;

package/src/dev-utils/utils.js

@@ -15,6 +15,7 @@
  *
  * @param map Map to convert.
  * @returns Converted map.
+ * @internal
  */
 export function convertMapToTags(map) {
     let string = '';
@@ -28,6 +29,7 @@ export function convertMapToTags(map) {
  *
  * @param map Map to convert.
  * @returns Converted map.
+ * @internal
  */
 export function convertMapToStringifiedObject(map) {
     const obj = {};
@@ -40,6 +42,8 @@ const treeDump = Symbol('_treeDump');
 const maxTreeDumpLength = 20;
 /**
  * Helper function that stores the `document` state for a given `version`.
+ *
+ * @internal
  */
 export function dumpTrees(document, version) {
     console.log(document, version);
@@ -55,12 +59,16 @@ export function dumpTrees(document, version) {
 }
 /**
  * Helper function that initializes document dumping.
+ *
+ * @internal
  */
 export function initDocumentDumping(document) {
     document[treeDump] = [];
 }
 /**
  * Helper function that logs document for the given version.
+ *
+ * @internal
  */
 export function logDocument(document, version) {
     console.log('--------------------');

package/src/dev-utils/view.d.ts

@@ -8,16 +8,16 @@
 /**
  * Collection of methods for manipulating the {@link module:engine/view/view view} for testing purposes.
  */
-import View from '../view/view.js';
-import ViewDocumentFragment from '../view/documentfragment.js';
-import ViewElement from '../view/element.js';
-import DocumentSelection from '../view/documentselection.js';
-import Range from '../view/range.js';
-import Position from '../view/position.js';
-import type ViewNode from '../view/node.js';
-import type DomConverter from '../view/domconverter.js';
+import { EditingView } from '../view/view.js';
+import { ViewDocumentFragment } from '../view/documentfragment.js';
+import { ViewElement } from '../view/element.js';
+import { ViewDocumentSelection } from '../view/documentselection.js';
+import { ViewRange } from '../view/range.js';
+import { ViewPosition } from '../view/position.js';
+import { type ViewNode } from '../view/node.js';
+import { type ViewDomConverter } from '../view/domconverter.js';
 /**
- * Writes the content of the {@link module:engine/view/document~Document document} to an HTML-like string.
+ * Writes the content of the {@link module:engine/view/document~ViewDocument document} to an HTML-like string.
  *
  * @param view The view to stringify.
  * @param options.withoutSelection Whether to write the selection. When set to `true`, the selection will
@@ -29,57 +29,58 @@ import type DomConverter from '../view/domconverter.js';
  * @param options.showPriority When set to `true`, the attribute element's priority will be printed
  * (`<span view-priority="12">`, `<b view-priority="10">`).
  * @param options.renderUIElements When set to `true`, the inner content of each
- * {@link module:engine/view/uielement~UIElement} will be printed.
+ * {@link module:engine/view/uielement~ViewUIElement} will be printed.
  * @param options.renderRawElements When set to `true`, the inner content of each
- * {@link module:engine/view/rawelement~RawElement} will be printed.
- * @param options.domConverter When set to an actual {@link module:engine/view/domconverter~DomConverter DomConverter}
+ * {@link module:engine/view/rawelement~ViewRawElement} will be printed.
+ * @param options.domConverter When set to an actual {@link module:engine/view/domconverter~ViewDomConverter ViewDomConverter}
  * instance, it lets the conversion go through exactly the same flow the editing view is going through,
  * i.e. with view data filtering. Otherwise the simple stub is used.
  * @returns The stringified data.
  */
-export declare function getData(view: View, options?: {
+export declare function _getViewData(view: EditingView, options?: {
     withoutSelection?: boolean;
     rootName?: string;
     showType?: boolean;
     showPriority?: boolean;
     renderUIElements?: boolean;
     renderRawElements?: boolean;
-    domConverter?: DomConverter;
+    domConverter?: ViewDomConverter;
+    skipListItemIds?: boolean;
 }): string;
-export declare namespace getData {
-    var _stringify: typeof stringify;
+export declare namespace _getViewData {
+    var _stringify: typeof _stringifyView;
 }
 /**
- * Sets the content of a view {@link module:engine/view/document~Document document} provided as an HTML-like string.
+ * Sets the content of a view {@link module:engine/view/document~ViewDocument document} provided as an HTML-like string.
  *
  * @param data An HTML-like string to write into the document.
- * @param options.rootName The root name where parsed data will be stored. If not provided,
+ * @param options.rootName The root name where _parseViewd data will be stored. If not provided,
  * the default `main` name will be used.
  */
-export declare function setData(view: View, data: string, options?: {
+export declare function _setViewData(view: EditingView, data: string, options?: {
     rootName?: string;
 }): void;
-export declare namespace setData {
-    var _parse: typeof parse;
+export declare namespace _setViewData {
+    var _parse: typeof _parseView;
 }
 /**
  * Converts view elements to HTML-like string representation.
  *
- * A root element can be provided as {@link module:engine/view/text~Text text}:
+ * A root element can be provided as {@link module:engine/view/text~ViewText text}:
  *
  * ```ts
  * const text = downcastWriter.createText( 'foobar' );
  * stringify( text ); // 'foobar'
  * ```
  *
- * or as an {@link module:engine/view/element~Element element}:
+ * or as an {@link module:engine/view/element~ViewElement element}:
  *
  * ```ts
  * const element = downcastWriter.createElement( 'p', null, downcastWriter.createText( 'foobar' ) );
  * stringify( element ); // '<p>foobar</p>'
  * ```
  *
- * or as a {@link module:engine/view/documentfragment~DocumentFragment document fragment}:
+ * or as a {@link module:engine/view/documentfragment~ViewDocumentFragment document fragment}:
  *
  * ```ts
  * const text = downcastWriter.createText( 'foobar' );
@@ -90,7 +91,7 @@ export declare namespace setData {
  * stringify( fragment ); // '<p style="color:red;"></p><b name="test">foobar</b>'
  * ```
  *
- * Additionally, a {@link module:engine/view/documentselection~DocumentSelection selection} instance can be provided.
+ * Additionally, a {@link module:engine/view/documentselection~ViewDocumentSelection selection} instance can be provided.
  * Ranges from the selection will then be included in the output data.
  * If a range position is placed inside the element node, it will be represented with `[` and `]`:
  *
@@ -135,8 +136,8 @@ export declare namespace setData {
  * stringify( text, selection ); // '{f}oo{ba}r'
  * ```
  *
- * A {@link module:engine/view/range~Range range} or {@link module:engine/view/position~Position position} instance can be provided
- * instead of the {@link module:engine/view/documentselection~DocumentSelection selection} instance. If a range instance
+ * A {@link module:engine/view/range~ViewRange range} or {@link module:engine/view/position~ViewPosition position} instance can be provided
+ * instead of the {@link module:engine/view/documentselection~ViewDocumentSelection selection} instance. If a range instance
  * is provided, it will be converted to a selection containing this range. If a position instance is provided, it will
  * be converted to a selection containing one range collapsed at this position.
  *
@@ -151,10 +152,10 @@ export declare namespace setData {
  *
  * An additional `options` object can be provided.
  * If `options.showType` is set to `true`, element's types will be
- * presented for {@link module:engine/view/attributeelement~AttributeElement attribute elements},
- * {@link module:engine/view/containerelement~ContainerElement container elements}
- * {@link module:engine/view/emptyelement~EmptyElement empty elements}
- * and {@link module:engine/view/uielement~UIElement UI elements}:
+ * presented for {@link module:engine/view/attributeelement~ViewAttributeElement attribute elements},
+ * {@link module:engine/view/containerelement~ViewContainerElement container elements}
+ * {@link module:engine/view/emptyelement~ViewEmptyElement empty elements}
+ * and {@link module:engine/view/uielement~ViewUIElement UI elements}:
  *
  * ```ts
  * const attribute = downcastWriter.createAttributeElement( 'b' );
@@ -168,7 +169,7 @@ export declare namespace setData {
  * ```
  *
  * If `options.showPriority` is set to `true`, a priority will be displayed for all
- * {@link module:engine/view/attributeelement~AttributeElement attribute elements}.
+ * {@link module:engine/view/attributeelement~ViewAttributeElement attribute elements}.
  *
  * ```ts
  * const attribute = downcastWriter.createAttributeElement( 'b' );
@@ -177,7 +178,7 @@ export declare namespace setData {
  * ```
  *
  * If `options.showAttributeElementId` is set to `true`, the attribute element's id will be displayed for all
- * {@link module:engine/view/attributeelement~AttributeElement attribute elements} that have it set.
+ * {@link module:engine/view/attributeelement~ViewAttributeElement attribute elements} that have it set.
  *
  * ```ts
  * const attribute = downcastWriter.createAttributeElement( 'span' );
@@ -197,19 +198,19 @@ export declare namespace setData {
  * @param options.showAttributeElementId When set to `true`, attribute element's id will be printed
  * (`<span id="marker:foo">`).
  * @param options.ignoreRoot When set to `true`, the root's element opening and closing will not be printed.
- * Mainly used by the `getData` function to ignore the {@link module:engine/view/document~Document document's} root element.
+ * Mainly used by the `getData` function to ignore the {@link module:engine/view/document~ViewDocument document's} root element.
  * @param options.sameSelectionCharacters When set to `true`, the selection inside the text will be marked as
  *  `{` and `}` and the selection outside the text as `[` and `]`. When set to `false`, both will be marked as `[` and `]` only.
  * @param options.renderUIElements When set to `true`, the inner content of each
- * {@link module:engine/view/uielement~UIElement} will be printed.
+ * {@link module:engine/view/uielement~ViewUIElement} will be printed.
  * @param options.renderRawElements When set to `true`, the inner content of each
- * {@link module:engine/view/rawelement~RawElement} will be printed.
- * @param options.domConverter When set to an actual {@link module:engine/view/domconverter~DomConverter DomConverter}
+ * {@link module:engine/view/rawelement~ViewRawElement} will be printed.
+ * @param options.domConverter When set to an actual {@link module:engine/view/domconverter~ViewDomConverter ViewDomConverter}
  * instance, it lets the conversion go through exactly the same flow the editing view is going through,
  * i.e. with view data filtering. Otherwise the simple stub is used.
  * @returns An HTML-like string representing the view.
  */
-export declare function stringify(node: ViewNode | ViewDocumentFragment, selectionOrPositionOrRange?: DocumentSelection | Position | Range | null, options?: {
+export declare function _stringifyView(node: ViewNode | ViewDocumentFragment, selectionOrPositionOrRange?: ViewDocumentSelection | ViewPosition | ViewRange | null, options?: {
     showType?: boolean;
     showPriority?: boolean;
     showAttributeElementId?: boolean;
@@ -217,96 +218,98 @@ export declare function stringify(node: ViewNode | ViewDocumentFragment, selecti
     sameSelectionCharacters?: boolean;
     renderUIElements?: boolean;
     renderRawElements?: boolean;
-    domConverter?: DomConverter;
+    domConverter?: ViewDomConverter;
+    skipListItemIds?: boolean;
 }): string;
 /**
  * Parses an HTML-like string and returns a view tree.
- * A simple string will be converted to a {@link module:engine/view/text~Text text} node:
+ * A simple string will be converted to a {@link module:engine/view/text~ViewText text} node:
  *
  * ```ts
- * parse( 'foobar' ); // Returns an instance of text.
+ * _parseView( 'foobar' ); // Returns an instance of text.
  * ```
  *
- * {@link module:engine/view/element~Element Elements} will be parsed with attributes as children:
+ * {@link module:engine/view/element~ViewElement Elements} will be _parseViewd with attributes as children:
  *
  * ```ts
- * parse( '<b name="baz">foobar</b>' ); // Returns an instance of element with the `baz` attribute and a text child node.
+ * _parseView( '<b name="baz">foobar</b>' ); // Returns an instance of element with the `baz` attribute and a text child node.
  * ```
  *
  * Multiple nodes provided on root level will be converted to a
- * {@link module:engine/view/documentfragment~DocumentFragment document fragment}:
+ * {@link module:engine/view/documentfragment~ViewDocumentFragment document fragment}:
  *
  * ```ts
- * parse( '<b>foo</b><i>bar</i>' ); // Returns a document fragment with two child elements.
+ * _parseView( '<b>foo</b><i>bar</i>' ); // Returns a document fragment with two child elements.
  * ```
  *
- * The method can parse multiple {@link module:engine/view/range~Range ranges} provided in string data and return a
- * {@link module:engine/view/documentselection~DocumentSelection selection} instance containing these ranges. Ranges placed inside
- * {@link module:engine/view/text~Text text} nodes should be marked using `{` and `}` brackets:
+ * The method can _parseView multiple {@link module:engine/view/range~ViewRange ranges} provided in string data and return a
+ * {@link module:engine/view/documentselection~ViewDocumentSelection selection} instance containing these ranges. Ranges placed inside
+ * {@link module:engine/view/text~ViewText text} nodes should be marked using `{` and `}` brackets:
  *
  * ```ts
- * const { text, selection } = parse( 'f{ooba}r' );
+ * const { text, selection } = _parseView( 'f{ooba}r' );
  * ```
  *
  * Ranges placed outside text nodes should be marked using `[` and `]` brackets:
  *
  * ```ts
- * const { root, selection } = parse( '<p>[<b>foobar</b>]</p>' );
+ * const { root, selection } = _parseView( '<p>[<b>foobar</b>]</p>' );
  * ```
  *
  * ** Note: **
  * It is possible to unify selection markers to `[` and `]` for both (inside and outside text)
- * by setting `sameSelectionCharacters=true` option. It is mainly used when the view parse option is used by model utilities.
+ * by setting `sameSelectionCharacters=true` option. It is mainly used when the view _parseView option is used by model utilities.
  *
  * Sometimes there is a need for defining the order of ranges inside the created selection. This can be achieved by providing
  * the range order array as an additional parameter:
  *
  * ```ts
- * const { root, selection } = parse( '{fo}ob{ar}{ba}z', { order: [ 2, 3, 1 ] } );
+ * const { root, selection } = _parseView( '{fo}ob{ar}{ba}z', { order: [ 2, 3, 1 ] } );
  * ```
  *
  * In the example above, the first range (`{fo}`) will be added to the selection as the second one, the second range (`{ar}`) will be
  * added as the third and the third range (`{ba}`) will be added as the first one.
  *
  * If the selection's last range should be added as a backward one
- * (so the {@link module:engine/view/documentselection~DocumentSelection#anchor selection anchor} is represented
- * by the `end` position and {@link module:engine/view/documentselection~DocumentSelection#focus selection focus} is
+ * (so the {@link module:engine/view/documentselection~ViewDocumentSelection#anchor selection anchor} is represented
+ * by the `end` position and {@link module:engine/view/documentselection~ViewDocumentSelection#focus selection focus} is
  * represented by the `start` position), use the `lastRangeBackward` flag:
  *
  * ```ts
- * const { root, selection } = parse( `{foo}bar{baz}`, { lastRangeBackward: true } );
+ * const { root, selection } = _parseView( `{foo}bar{baz}`, { lastRangeBackward: true } );
  * ```
  *
  * Some more examples and edge cases:
  *
  * ```ts
  * // Returns an empty document fragment.
- * parse( '' );
+ * _parseView( '' );
  *
  * // Returns an empty document fragment and a collapsed selection.
- * const { root, selection } = parse( '[]' );
+ * const { root, selection } = _parseView( '[]' );
  *
  * // Returns an element and a selection that is placed inside the document fragment containing that element.
- * const { root, selection } = parse( '[<a></a>]' );
+ * const { root, selection } = _parseView( '[<a></a>]' );
  * ```
  *
  * @param data An HTML-like string to be parsed.
  * @param options.order An array with the order of parsed ranges added to the returned
- * {@link module:engine/view/documentselection~DocumentSelection Selection} instance. Each element should represent the
+ * {@link module:engine/view/documentselection~ViewDocumentSelection Selection} instance. Each element should represent the
  * desired position of each range in the selection instance. For example: `[2, 3, 1]` means that the first range will be
  * placed as the second, the second as the third and the third as the first.
  * @param options.lastRangeBackward If set to `true`, the last range will be added as backward to the returned
- * {@link module:engine/view/documentselection~DocumentSelection selection} instance.
+ * {@link module:engine/view/documentselection~ViewDocumentSelection selection} instance.
  * @param options.rootElement The default root to use when parsing elements.
  * When set to `null`, the root element will be created automatically. If set to
- * {@link module:engine/view/element~Element Element} or {@link module:engine/view/documentfragment~DocumentFragment DocumentFragment},
+ * {@link module:engine/view/element~ViewElement Element} or
+ * {@link module:engine/view/documentfragment~ViewDocumentFragment DocumentFragment},
  * this node will be used as the root for all parsed nodes.
  * @param options.sameSelectionCharacters When set to `false`, the selection inside the text should be marked using
  * `{` and `}` and the selection outside the ext using `[` and `]`. When set to `true`, both should be marked with `[` and `]` only.
  * @returns Returns the parsed view node or an object with two fields: `view` and `selection` when selection ranges were included in the
  * data to parse.
  */
-export declare function parse(data: string, options?: {
+export declare function _parseView(data: string, options?: {
     order?: Array<number>;
     lastRangeBackward?: boolean;
     rootElement?: ViewElement | ViewDocumentFragment;
@@ -314,5 +317,5 @@ export declare function parse(data: string, options?: {
     inlineObjectElements?: Array<string>;
 }): ViewNode | ViewDocumentFragment | {
     view: ViewNode | ViewDocumentFragment;
-    selection: DocumentSelection;
+    selection: ViewDocumentSelection;
 };