@ckeditor/ckeditor5-engine 36.0.1 → 37.0.0-alpha.0

package/src/dataprocessor/htmldataprocessor.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import DomConverter from '../view/domconverter';
+import type DataProcessor from './dataprocessor';
+import type HtmlWriter from './htmlwriter';
+import type ViewDocument from '../view/document';
+import type ViewDocumentFragment from '../view/documentfragment';
+import type { MatcherPattern } from '../view/matcher';
+/**
+ * The HTML data processor class.
+ * This data processor implementation uses HTML as input and output data.
+ */
+export default class HtmlDataProcessor implements DataProcessor {
+    /**
+     * A DOM parser instance used to parse an HTML string to an HTML document.
+     */
+    domParser: DOMParser;
+    /**
+     * A DOM converter used to convert DOM elements to view elements.
+     */
+    domConverter: DomConverter;
+    /**
+     * A basic HTML writer instance used to convert DOM elements to an HTML string.
+     */
+    htmlWriter: HtmlWriter;
+    skipComments: boolean;
+    /**
+     * Creates a new instance of the HTML data processor class.
+     *
+     * @param document The view document instance.
+     */
+    constructor(document: ViewDocument);
+    /**
+     * Converts a provided {@link module:engine/view/documentfragment~DocumentFragment document fragment}
+     * to data format — in this case to an HTML string.
+     *
+     * @returns HTML string.
+     */
+    toData(viewFragment: ViewDocumentFragment): string;
+    /**
+     * Converts the provided HTML string to a view tree.
+     *
+     * @param data An HTML string.
+     * @returns A converted view element.
+     */
+    toView(data: string): ViewDocumentFragment;
+    /**
+     * Registers a {@link module:engine/view/matcher~MatcherPattern} for view elements whose content should be treated as raw data
+     * and not processed during the conversion from the DOM to the view elements.
+     *
+     * The raw data can be later accessed by a
+     * {@link module:engine/view/element~Element#getCustomProperty custom property of a view element} called `"$rawContent"`.
+     *
+     * @param pattern Pattern matching all view elements whose content should be treated as raw data.
+     */
+    registerRawContentMatcher(pattern: MatcherPattern): void;
+    /**
+     * If the processor is set to use marked fillers, it will insert `&nbsp;` fillers wrapped in `<span>` elements
+     * (`<span data-cke-filler="true">&nbsp;</span>`) instead of regular `&nbsp;` characters.
+     *
+     * This mode allows for a more precise handling of the block fillers (so they do not leak into the editor content) but
+     * bloats the editor data with additional markup.
+     *
+     * This mode may be required by some features and will be turned on by them automatically.
+     *
+     * @param type Whether to use the default or the marked `&nbsp;` block fillers.
+     */
+    useFillerType(type: 'default' | 'marked'): void;
+    /**
+     * Converts an HTML string to its DOM representation. Returns a document fragment containing nodes parsed from
+     * the provided data.
+     */
+    protected _toDom(data: string): DocumentFragment;
+}

package/src/dataprocessor/htmldataprocessor.js

@@ -11,42 +11,24 @@ import DomConverter from '../view/domconverter';
 /**
  * The HTML data processor class.
  * This data processor implementation uses HTML as input and output data.
- *
- * @implements module:engine/dataprocessor/dataprocessor~DataProcessor
  */
 export default class HtmlDataProcessor {
     /**
      * Creates a new instance of the HTML data processor class.
      *
-     * @param {module:engine/view/document~Document} document The view document instance.
+     * @param document The view document instance.
      */
     constructor(document) {
         this.skipComments = true;
-        /**
-         * A DOM parser instance used to parse an HTML string to an HTML document.
-         *
-         * @member {DOMParser}
-         */
         this.domParser = new DOMParser();
-        /**
-         * A DOM converter used to convert DOM elements to view elements.
-         *
-         * @member {module:engine/view/domconverter~DomConverter}
-         */
         this.domConverter = new DomConverter(document, { renderingMode: 'data' });
-        /**
-         * A basic HTML writer instance used to convert DOM elements to an HTML string.
-         *
-         * @member {module:engine/dataprocessor/htmlwriter~HtmlWriter}
-         */
         this.htmlWriter = new BasicHtmlWriter();
     }
     /**
      * Converts a provided {@link module:engine/view/documentfragment~DocumentFragment document fragment}
      * to data format — in this case to an HTML string.
      *
-     * @param {module:engine/view/documentfragment~DocumentFragment} viewFragment
-     * @returns {String} HTML string.
+     * @returns HTML string.
      */
     toData(viewFragment) {
         // Convert view DocumentFragment to DOM DocumentFragment.
@@ -57,8 +39,8 @@ export default class HtmlDataProcessor {
     /**
      * Converts the provided HTML string to a view tree.
      *
-     * @param {String} data An HTML string.
-     * @returns {module:engine/view/node~Node|module:engine/view/documentfragment~DocumentFragment|null} A converted view element.
+     * @param data An HTML string.
+     * @returns A converted view element.
      */
     toView(data) {
         // Convert input HTML data to DOM DocumentFragment.
@@ -73,8 +55,7 @@ export default class HtmlDataProcessor {
      * The raw data can be later accessed by a
      * {@link module:engine/view/element~Element#getCustomProperty custom property of a view element} called `"$rawContent"`.
      *
-     * @param {module:engine/view/matcher~MatcherPattern} pattern Pattern matching all view elements whose content should
-     * be treated as raw data.
+     * @param pattern Pattern matching all view elements whose content should be treated as raw data.
      */
     registerRawContentMatcher(pattern) {
         this.domConverter.registerRawContentMatcher(pattern);
@@ -88,7 +69,7 @@ export default class HtmlDataProcessor {
      *
      * This mode may be required by some features and will be turned on by them automatically.
      *
-     * @param {'default'|'marked'} type Whether to use the default or the marked ` ` block fillers.
+     * @param type Whether to use the default or the marked ` ` block fillers.
      */
     useFillerType(type) {
         this.domConverter.blockFillerMode = type == 'marked' ? 'markedNbsp' : 'nbsp';
@@ -96,9 +77,6 @@ export default class HtmlDataProcessor {
     /**
      * Converts an HTML string to its DOM representation. Returns a document fragment containing nodes parsed from
      * the provided data.
-     *
-     * @param {String} data
-     * @returns {DocumentFragment}
      */
     _toDom(data) {
         // Wrap data with a <body> tag so leading non-layout nodes (like <script>, <style>, HTML comment)

package/src/dataprocessor/htmlwriter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/dataprocessor/htmlwriter
+ */
+/**
+ * The HTML writer interface.
+ */
+export default interface HtmlWriter {
+    /**
+     * Returns an HTML string created from a document fragment.
+     */
+    getHtml(fragment: DocumentFragment): string;
+}

package/src/dataprocessor/xmldataprocessor.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import DomConverter from '../view/domconverter';
+import type DataProcessor from './dataprocessor';
+import type HtmlWriter from './htmlwriter';
+import type ViewDocument from '../view/document';
+import type ViewDocumentFragment from '../view/documentfragment';
+import type { MatcherPattern } from '../view/matcher';
+/**
+ * The XML data processor class.
+ * This data processor implementation uses XML as input and output data.
+ * This class is needed because unlike HTML, XML allows to use any tag with any value.
+ * For example, `<link>Text</link>` is a valid XML but invalid HTML.
+ */
+export default class XmlDataProcessor implements DataProcessor {
+    /**
+     * A list of namespaces allowed to use in the XML input.
+     *
+     * For example, registering namespaces [ 'attribute', 'container' ] allows to use `<attirbute:tagName></attribute:tagName>`
+     * and `<container:tagName></container:tagName>` input. It is mainly for debugging.
+     */
+    namespaces: Array<string>;
+    /**
+     * DOM parser instance used to parse an XML string to an XML document.
+     */
+    domParser: DOMParser;
+    /**
+     * DOM converter used to convert DOM elements to view elements.
+     */
+    domConverter: DomConverter;
+    /**
+     * A basic HTML writer instance used to convert DOM elements to an XML string.
+     * There is no need to use a dedicated XML writer because the basic HTML writer works well in this case.
+     */
+    htmlWriter: HtmlWriter;
+    skipComments: boolean;
+    /**
+     * Creates a new instance of the XML data processor class.
+     *
+     * @param document The view document instance.
+     * @param options Configuration options.
+     * @param options.namespaces A list of namespaces allowed to use in the XML input.
+     */
+    constructor(document: ViewDocument, options?: {
+        namespaces?: Array<string>;
+    });
+    /**
+     * Converts the provided {@link module:engine/view/documentfragment~DocumentFragment document fragment}
+     * to data format &mdash; in this case an XML string.
+     *
+     * @returns An XML string.
+     */
+    toData(viewFragment: ViewDocumentFragment): string;
+    /**
+     * Converts the provided XML string to a view tree.
+     *
+     * @param data An XML string.
+     * @returns A converted view element.
+     */
+    toView(data: string): ViewDocumentFragment;
+    /**
+     * Registers a {@link module:engine/view/matcher~MatcherPattern} for view elements whose content should be treated as raw data
+     * and not processed during the conversion from XML to view elements.
+     *
+     * The raw data can be later accessed by a
+     * {@link module:engine/view/element~Element#getCustomProperty custom property of a view element} called `"$rawContent"`.
+     *
+     * @param pattern Pattern matching all view elements whose content should be treated as raw data.
+     */
+    registerRawContentMatcher(pattern: MatcherPattern): void;
+    /**
+     * If the processor is set to use marked fillers, it will insert `&nbsp;` fillers wrapped in `<span>` elements
+     * (`<span data-cke-filler="true">&nbsp;</span>`) instead of regular `&nbsp;` characters.
+     *
+     * This mode allows for a more precise handling of block fillers (so they do not leak into editor content) but
+     * bloats the editor data with additional markup.
+     *
+     * This mode may be required by some features and will be turned on by them automatically.
+     *
+     * @param type Whether to use the default or the marked `&nbsp;` block fillers.
+     */
+    useFillerType(type: 'default' | 'marked'): void;
+    /**
+     * Converts an XML string to its DOM representation. Returns a document fragment containing nodes parsed from
+     * the provided data.
+     */
+    private _toDom;
+}

package/src/dataprocessor/xmldataprocessor.js

@@ -13,54 +13,27 @@ import DomConverter from '../view/domconverter';
  * This data processor implementation uses XML as input and output data.
  * This class is needed because unlike HTML, XML allows to use any tag with any value.
  * For example, `<link>Text</link>` is a valid XML but invalid HTML.
- *
- * @implements module:engine/dataprocessor/dataprocessor~DataProcessor
  */
 export default class XmlDataProcessor {
     /**
      * Creates a new instance of the XML data processor class.
      *
-     * @param {module:engine/view/document~Document} document The view document instance.
-     * @param {Object} options Configuration options.
-     * @param {Array.<String>} [options.namespaces=[]] A list of namespaces allowed to use in the XML input.
+     * @param document The view document instance.
+     * @param options Configuration options.
+     * @param options.namespaces A list of namespaces allowed to use in the XML input.
      */
     constructor(document, options = {}) {
         this.skipComments = true;
-        /**
-         * A list of namespaces allowed to use in the XML input.
-         *
-         * For example, registering namespaces [ 'attribute', 'container' ] allows to use `<attirbute:tagName></attribute:tagName>`
-         * and `<container:tagName></container:tagName>` input. It is mainly for debugging.
-         *
-         * @member {Array.<String>}
-         */
         this.namespaces = options.namespaces || [];
-        /**
-         * DOM parser instance used to parse an XML string to an XML document.
-         *
-         * @member {DOMParser}
-         */
         this.domParser = new DOMParser();
-        /**
-         * DOM converter used to convert DOM elements to view elements.
-         *
-         * @member {module:engine/view/domconverter~DomConverter}
-         */
         this.domConverter = new DomConverter(document, { renderingMode: 'data' });
-        /**
-         * A basic HTML writer instance used to convert DOM elements to an XML string.
-         * There is no need to use a dedicated XML writer because the basic HTML writer works well in this case.
-         *
-         * @member {module:engine/dataprocessor/htmlwriter~HtmlWriter}
-         */
         this.htmlWriter = new BasicHtmlWriter();
     }
     /**
      * Converts the provided {@link module:engine/view/documentfragment~DocumentFragment document fragment}
      * to data format &mdash; in this case an XML string.
      *
-     * @param {module:engine/view/documentfragment~DocumentFragment} viewFragment
-     * @returns {String} An XML string.
+     * @returns An XML string.
      */
     toData(viewFragment) {
         // Convert view DocumentFragment to DOM DocumentFragment.
@@ -72,8 +45,8 @@ export default class XmlDataProcessor {
     /**
      * Converts the provided XML string to a view tree.
      *
-     * @param {String} data An XML string.
-     * @returns {module:engine/view/node~Node|module:engine/view/documentfragment~DocumentFragment|null} A converted view element.
+     * @param data An XML string.
+     * @returns A converted view element.
      */
     toView(data) {
         // Convert input XML data to DOM DocumentFragment.
@@ -91,8 +64,7 @@ export default class XmlDataProcessor {
      * The raw data can be later accessed by a
      * {@link module:engine/view/element~Element#getCustomProperty custom property of a view element} called `"$rawContent"`.
      *
-     * @param {module:engine/view/matcher~MatcherPattern} pattern Pattern matching all view elements whose content should
-     * be treated as raw data.
+     * @param pattern Pattern matching all view elements whose content should be treated as raw data.
      */
     registerRawContentMatcher(pattern) {
         this.domConverter.registerRawContentMatcher(pattern);
@@ -106,7 +78,7 @@ export default class XmlDataProcessor {
      *
      * This mode may be required by some features and will be turned on by them automatically.
      *
-     * @param {'default'|'marked'} type Whether to use the default or the marked `&nbsp;` block fillers.
+     * @param type Whether to use the default or the marked `&nbsp;` block fillers.
      */
     useFillerType(type) {
         this.domConverter.blockFillerMode = type == 'marked' ? 'markedNbsp' : 'nbsp';
@@ -114,10 +86,6 @@ export default class XmlDataProcessor {
     /**
      * Converts an XML string to its DOM representation. Returns a document fragment containing nodes parsed from
      * the provided data.
-     *
-     * @private
-     * @param {String} data
-     * @returns {DocumentFragment}
      */
     _toDom(data) {
         // Stringify namespaces.

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

@@ -0,0 +1,124 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import Model from '../model/model';
+import ModelRange from '../model/range';
+import ModelPosition from '../model/position';
+import ModelSelection from '../model/selection';
+import ModelDocumentFragment from '../model/documentfragment';
+import DocumentSelection from '../model/documentselection';
+import type { BatchType } from '../model/batch';
+import type MarkerCollection from '../model/markercollection';
+import type { default as Schema, SchemaContextDefinition } from '../model/schema';
+import type ModelNode from '../model/node';
+/**
+ * Writes the content of a model {@link module:engine/model/document~Document 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:
+ *
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
+ *
+ * **Note:** Using this tool in production-grade code is not recommended. It was designed for development, prototyping,
+ * debugging and testing.
+ *
+ * @param options.withoutSelection Whether to write the selection. When set to `true`, the selection will
+ * not be included in the returned string.
+ * @param options.rootName The name of the root from which the data should be stringified. If not provided,
+ * the default `main` name will be used.
+ * @param options.convertMarkers Whether to include markers in the returned string.
+ * @returns The stringified data.
+ */
+export declare function getData(model: Model, options?: {
+    withoutSelection?: boolean;
+    rootName?: string;
+    convertMarkers?: boolean;
+}): string;
+export declare namespace getData {
+    var _stringify: typeof stringify;
+}
+/**
+ * Sets the content of a model {@link module:engine/model/document~Document document} provided as an HTML-like string.
+ *
+ * ```ts
+ * setData( editor.model, '<paragraph>Foo![]</paragraph>' );
+ * ```
+ *
+ * **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:
+ *
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
+ *
+ * **Note:** Using this tool in production-grade code is not recommended. It was designed for development, prototyping,
+ * debugging and testing.
+ *
+ * @param data HTML-like string to write into the document.
+ * @param options.rootName Root name where parsed data will be stored. If not provided, the default `main`
+ * name will be used.
+ * @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 declare function setData(model: Model, data: string, options?: {
+    rootName?: string;
+    selectionAttributes?: Record<string, unknown>;
+    lastRangeBackward?: boolean;
+    batchType?: BatchType;
+}): void;
+export declare namespace setData {
+    var _parse: typeof parse;
+}
+/**
+ * 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:
+ *
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
+ *
+ * @param node A node to stringify.
+ * @param selectionOrPositionOrRange A selection instance whose ranges will be included in the returned string data.
+ * 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.
+ * @param markers Markers to include.
+ * @returns An HTML-like string representing the model.
+ */
+export declare function stringify(node: ModelNode | ModelDocumentFragment, selectionOrPositionOrRange?: ModelSelection | DocumentSelection | ModelPosition | ModelRange | null, markers?: MarkerCollection | null): string;
+/**
+ * Parses an HTML-like string and returns the model {@link module:engine/model/rootelement~RootElement rootElement}.
+ *
+ * **Note:** To create a {@link module:engine/model/text~Text text} node that contains attributes use:
+ *
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
+ *
+ * @param data HTML-like string to be parsed.
+ * @param schema A schema instance used by converters for element validation.
+ * @param options Additional configuration.
+ * @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.context The conversion context. If not provided, the default `'$root'` will be used.
+ * @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 declare function parse(data: string, schema: Schema, options?: {
+    selectionAttributes?: Record<string, unknown> | Iterable<[string, unknown]>;
+    lastRangeBackward?: boolean;
+    context?: SchemaContextDefinition;
+}): ModelNode | ModelDocumentFragment | {
+    model: ModelNode | ModelDocumentFragment;
+    selection: ModelSelection;
+};

package/src/dev-utils/model.js

@@ -29,23 +29,25 @@ import { isPlainObject } from 'lodash-es';
 /**
  * Writes the content of a model {@link module:engine/model/document~Document document} to an HTML-like string.
  *
- *		getData( editor.model ); // -> '<paragraph>Foo![]</paragraph>'
+ * ```ts
+ * getData( editor.model ); // -> '<paragraph>Foo![]</paragraph>'
+ * ```
  *
  * **Note:** A {@link module:engine/model/text~Text text} node that contains attributes will be represented as:
  *
- *		<$text attribute="value">Text data</$text>
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
  *
  * **Note:** Using this tool in production-grade code is not recommended. It was designed for development, prototyping,
  * debugging and testing.
  *
- * @param {module:engine/model/model~Model} model
- * @param {Object} [options]
- * @param {Boolean} [options.withoutSelection=false] Whether to write the selection. When set to `true`, the selection will
+ * @param options.withoutSelection Whether to write the selection. When set to `true`, the selection will
  * not be included in the returned string.
- * @param {String} [options.rootName='main'] The name of the root from which the data should be stringified. If not provided,
+ * @param options.rootName The name of the root from which the data should be stringified. If not provided,
  * the default `main` name will be used.
- * @param {Boolean} [options.convertMarkers=false] Whether to include markers in the returned string.
- * @returns {String} The stringified data.
+ * @param options.convertMarkers Whether to include markers in the returned string.
+ * @returns The stringified data.
  */
 export function getData(model, options = {}) {
     if (!(model instanceof Model)) {
@@ -60,26 +62,28 @@ getData._stringify = stringify;
 /**
  * Sets the content of a model {@link module:engine/model/document~Document document} provided as an HTML-like string.
  *
- *		setData( editor.model, '<paragraph>Foo![]</paragraph>' );
+ * ```ts
+ * setData( editor.model, '<paragraph>Foo![]</paragraph>' );
+ * ```
  *
  * **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:
  *
- *		<$text attribute="value">Text data</$text>
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
  *
  * **Note:** Using this tool in production-grade code is not recommended. It was designed for development, prototyping,
  * debugging and testing.
  *
- * @param {module:engine/model/model~Model} model
- * @param {String} data HTML-like string to write into the document.
- * @param {Object} options
- * @param {String} [options.rootName='main'] Root name where parsed data will be stored. If not provided, the default `main`
+ * @param data HTML-like string to write into the document.
+ * @param options.rootName Root name where parsed data will be stored. If not provided, the default `main`
  * name will be used.
- * @param {Array<Object>} [options.selectionAttributes] A list of attributes which will be passed to the selection.
- * @param {Boolean} [options.lastRangeBackward=false] If set to `true`, the last range will be added as backward.
- * @param {Object} [options.batchType] Batch type used for inserting elements. See {@link module:engine/model/batch~Batch#constructor}.
+ * @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 = {}) {
@@ -138,17 +142,16 @@ setData._parse = parse;
  *
  * **Note:** A {@link module:engine/model/text~Text text} node that contains attributes will be represented as:
  *
- *		<$text attribute="value">Text data</$text>
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
  *
- * @param {module:engine/model/rootelement~RootElement|module:engine/model/element~Element|module:engine/model/text~Text|
- * module:engine/model/documentfragment~DocumentFragment} node A node to stringify.
- * @param {module:engine/model/selection~Selection|module:engine/model/position~Position|
- * module:engine/model/range~Range} [selectionOrPositionOrRange=null]
- * A selection instance whose ranges will be included in the returned string data. 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.
- * @param {Iterable.<module:engine/model/markercollection~Marker>|null} markers Markers to include.
- * @returns {String} An HTML-like string representing the model.
+ * @param node A node to stringify.
+ * @param selectionOrPositionOrRange A selection instance whose ranges will be included in the returned string data.
+ * 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.
+ * @param markers Markers to include.
+ * @returns An HTML-like string representing the model.
  */
 export function stringify(node, selectionOrPositionOrRange = null, markers = null) {
     const model = new Model();
@@ -243,18 +246,18 @@ export function stringify(node, selectionOrPositionOrRange = null, markers = nul
  *
  * **Note:** To create a {@link module:engine/model/text~Text text} node that contains attributes use:
  *
- *		<$text attribute="value">Text data</$text>
+ * ```xml
+ * <$text attribute="value">Text data</$text>
+ * ```
  *
- * @param {String} data HTML-like string to be parsed.
- * @param {module:engine/model/schema~Schema} schema A schema instance used by converters for element validation.
- * @param {Object} [options={}] Additional configuration.
- * @param {Array<Object>} [options.selectionAttributes] A list of attributes which will be passed to the selection.
- * @param {Boolean} [options.lastRangeBackward=false] If set to `true`, the last range will be added as backward.
- * @param {module:engine/model/schema~SchemaContextDefinition} [options.context='$root'] The conversion context.
- * If not provided, the default `'$root'` will be used.
- * @returns {module:engine/model/element~Element|module:engine/model/text~Text|
- * module:engine/model/documentfragment~DocumentFragment|Object} Returns the parsed model node or
- * an object with two fields: `model` and `selection`, when selection ranges were included in the data to parse.
+ * @param data HTML-like string to be parsed.
+ * @param schema A schema instance used by converters for element validation.
+ * @param options Additional configuration.
+ * @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.context The conversion context. If not provided, the default `'$root'` will be used.
+ * @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 = {}) {
     const mapper = new Mapper();