@ckeditor/ckeditor5-engine 0.0.0-internal-20241017.0

package/src/controller/editingcontroller.js

@@ -0,0 +1,191 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/controller/editingcontroller
+ */
+import { CKEditorError, ObservableMixin, env } from '@ckeditor/ckeditor5-utils';
+import RootEditableElement from '../view/rooteditableelement.js';
+import View from '../view/view.js';
+import Mapper from '../conversion/mapper.js';
+import DowncastDispatcher from '../conversion/downcastdispatcher.js';
+import { cleanSelection, convertCollapsedSelection, convertRangeSelection, insertAttributesAndChildren, insertText, remove } from '../conversion/downcasthelpers.js';
+import { convertSelectionChange } from '../conversion/upcasthelpers.js';
+import { tryFixingRange } from '../model/utils/selection-post-fixer.js';
+// @if CK_DEBUG_ENGINE // const { dumpTrees, initDocumentDumping } = require( '../dev-utils/utils' );
+/**
+ * A controller for the editing pipeline. The editing pipeline controls the {@link ~EditingController#model model} rendering,
+ * including selection handling. It also creates the {@link ~EditingController#view view} which builds a
+ * browser-independent virtualization over the DOM elements. The editing controller also attaches default converters.
+ */
+export default class EditingController extends /* #__PURE__ */ ObservableMixin() {
+    /**
+     * Creates an editing controller instance.
+     *
+     * @param model Editing model.
+     * @param stylesProcessor The styles processor instance.
+     */
+    constructor(model, stylesProcessor) {
+        super();
+        this.model = model;
+        this.view = new View(stylesProcessor);
+        this.mapper = new Mapper();
+        this.downcastDispatcher = new DowncastDispatcher({
+            mapper: this.mapper,
+            schema: model.schema
+        });
+        const doc = this.model.document;
+        const selection = doc.selection;
+        const markers = this.model.markers;
+        // When plugins listen on model changes (on selection change, post fixers, etc.) and change the view as a result of
+        // the model's change, they might trigger view rendering before the conversion is completed (e.g. before the selection
+        // is converted). We disable rendering for the length of the outermost model change() block to prevent that.
+        //
+        // See https://github.com/ckeditor/ckeditor5-engine/issues/1528
+        this.listenTo(this.model, '_beforeChanges', () => {
+            this.view._disableRendering(true);
+        }, { priority: 'highest' });
+        this.listenTo(this.model, '_afterChanges', () => {
+            this.view._disableRendering(false);
+        }, { priority: 'lowest' });
+        // Whenever model document is changed, convert those changes to the view (using model.Document#differ).
+        // Do it on 'low' priority, so changes are converted after other listeners did their job.
+        // Also convert model selection.
+        this.listenTo(doc, 'change', () => {
+            this.view.change(writer => {
+                this.downcastDispatcher.convertChanges(doc.differ, markers, writer);
+                this.downcastDispatcher.convertSelection(selection, markers, writer);
+            });
+        }, { priority: 'low' });
+        // Convert selection from the view to the model when it changes in the view.
+        this.listenTo(this.view.document, 'selectionChange', convertSelectionChange(this.model, this.mapper));
+        // Fix `beforeinput` target ranges so that they map to the valid model ranges.
+        this.listenTo(this.view.document, 'beforeinput', fixTargetRanges(this.mapper, this.model.schema, this.view), { priority: 'high' });
+        // Attach default model converters.
+        this.downcastDispatcher.on('insert:$text', insertText(), { priority: 'lowest' });
+        this.downcastDispatcher.on('insert', insertAttributesAndChildren(), { priority: 'lowest' });
+        this.downcastDispatcher.on('remove', remove(), { priority: 'low' });
+        // Attach default model selection converters.
+        this.downcastDispatcher.on('cleanSelection', cleanSelection());
+        this.downcastDispatcher.on('selection', convertRangeSelection(), { priority: 'low' });
+        this.downcastDispatcher.on('selection', convertCollapsedSelection(), { priority: 'low' });
+        // Binds {@link module:engine/view/document~Document#roots view roots collection} to
+        // {@link module:engine/model/document~Document#roots model roots collection} so creating
+        // model root automatically creates corresponding view root.
+        this.view.document.roots.bindTo(this.model.document.roots).using(root => {
+            // $graveyard is a special root that has no reflection in the view.
+            if (root.rootName == '$graveyard') {
+                return null;
+            }
+            const viewRoot = new RootEditableElement(this.view.document, root.name);
+            viewRoot.rootName = root.rootName;
+            this.mapper.bindElements(root, viewRoot);
+            return viewRoot;
+        });
+        // @if CK_DEBUG_ENGINE // initDocumentDumping( this.model.document );
+        // @if CK_DEBUG_ENGINE // initDocumentDumping( this.view.document );
+        // @if CK_DEBUG_ENGINE // dumpTrees( this.model.document, this.model.document.version );
+        // @if CK_DEBUG_ENGINE // dumpTrees( this.view.document, this.model.document.version );
+        // @if CK_DEBUG_ENGINE // this.model.document.on( 'change', () => {
+        // @if CK_DEBUG_ENGINE //	dumpTrees( this.view.document, this.model.document.version );
+        // @if CK_DEBUG_ENGINE // }, { priority: 'lowest' } );
+    }
+    /**
+     * Removes all event listeners attached to the `EditingController`. Destroys all objects created
+     * by `EditingController` that need to be destroyed.
+     */
+    destroy() {
+        this.view.destroy();
+        this.stopListening();
+    }
+    /**
+     * Calling this method will refresh the marker by triggering the downcast conversion for it.
+     *
+     * Reconverting the marker is useful when you want to change its {@link module:engine/view/element~Element view element}
+     * without changing any marker data. For instance:
+     *
+     * ```ts
+     * let isCommentActive = false;
+     *
+     * model.conversion.markerToHighlight( {
+     * 	model: 'comment',
+     * 	view: data => {
+     * 		const classes = [ 'comment-marker' ];
+     *
+     * 		if ( isCommentActive ) {
+     * 			classes.push( 'comment-marker--active' );
+     * 		}
+     *
+     * 		return { classes };
+     * 	}
+     * } );
+     *
+     * // ...
+     *
+     * // Change the property that indicates if marker is displayed as active or not.
+     * isCommentActive = true;
+     *
+     * // Reconverting will downcast and synchronize the marker with the new isCommentActive state value.
+     * editor.editing.reconvertMarker( 'comment' );
+     * ```
+     *
+     * **Note**: If you want to reconvert a model item, use {@link #reconvertItem} instead.
+     *
+     * @param markerOrName Name of a marker to update, or a marker instance.
+     */
+    reconvertMarker(markerOrName) {
+        const markerName = typeof markerOrName == 'string' ? markerOrName : markerOrName.name;
+        const currentMarker = this.model.markers.get(markerName);
+        if (!currentMarker) {
+            /**
+             * The marker with the provided name does not exist and cannot be reconverted.
+             *
+             * @error editingcontroller-reconvertmarker-marker-not-exist
+             * @param {String} markerName The name of the reconverted marker.
+             */
+            throw new CKEditorError('editingcontroller-reconvertmarker-marker-not-exist', this, { markerName });
+        }
+        this.model.change(() => {
+            this.model.markers._refresh(currentMarker);
+        });
+    }
+    /**
+     * Calling this method will downcast a model item on demand (by requesting a refresh in the {@link module:engine/model/differ~Differ}).
+     *
+     * You can use it if you want the view representation of a specific item updated as a response to external modifications. For instance,
+     * when the view structure depends not only on the associated model data but also on some external state.
+     *
+     * **Note**: If you want to reconvert a model marker, use {@link #reconvertMarker} instead.
+     *
+     * @param item Item to refresh.
+     */
+    reconvertItem(item) {
+        this.model.change(() => {
+            this.model.document.differ._refreshItem(item);
+        });
+    }
+}
+/**
+ * Checks whether the target ranges provided by the `beforeInput` event can be properly mapped to model ranges and fixes them if needed.
+ *
+ * This is using the same logic as the selection post-fixer.
+ */
+function fixTargetRanges(mapper, schema, view) {
+    return (evt, data) => {
+        // The Renderer is disabled while composing on non-android browsers, so we can't be sure that target ranges
+        // could be properly mapped to view and model because the DOM and view tree drifted apart.
+        if (view.document.isComposing && !env.isAndroid) {
+            return;
+        }
+        for (let i = 0; i < data.targetRanges.length; i++) {
+            const viewRange = data.targetRanges[i];
+            const modelRange = mapper.toModelRange(viewRange);
+            const correctedRange = tryFixingRange(modelRange, schema);
+            if (!correctedRange || correctedRange.isEqual(modelRange)) {
+                continue;
+            }
+            data.targetRanges[i] = mapper.toViewRange(correctedRange);
+        }
+    };
+}

package/src/conversion/conversion.d.ts

@@ -0,0 +1,478 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/conversion/conversion
+ */
+import { type ArrayOrItem, type PriorityString } from '@ckeditor/ckeditor5-utils';
+import UpcastHelpers from './upcasthelpers.js';
+import DowncastHelpers, { type AttributeCreatorFunction, type AttributeDescriptor } from './downcasthelpers.js';
+import type DowncastDispatcher from './downcastdispatcher.js';
+import type UpcastDispatcher from './upcastdispatcher.js';
+import type ElementDefinition from '../view/elementdefinition.js';
+import type { MatcherPattern } from '../view/matcher.js';
+/**
+ * A utility class that helps add converters to upcast and downcast dispatchers.
+ *
+ * We recommend reading the {@glink framework/deep-dive/conversion/intro editor conversion} guide first to
+ * understand the core concepts of the conversion mechanisms.
+ *
+ * An instance of the conversion manager is available in the
+ * {@link module:core/editor/editor~Editor#conversion `editor.conversion`} property
+ * and by default has the following groups of dispatchers (i.e. directions of conversion):
+ *
+ * * `downcast` (editing and data downcasts)
+ * * `editingDowncast`
+ * * `dataDowncast`
+ * * `upcast`
+ *
+ * # One-way converters
+ *
+ * To add a converter to a specific group, use the {@link module:engine/conversion/conversion~Conversion#for `for()`}
+ * method:
+ *
+ * ```ts
+ * // Add a converter to editing downcast and data downcast.
+ * editor.conversion.for( 'downcast' ).elementToElement( config ) );
+ *
+ * // Add a converter to the data pipepline only:
+ * editor.conversion.for( 'dataDowncast' ).elementToElement( dataConversionConfig ) );
+ *
+ * // And a slightly different one for the editing pipeline:
+ * editor.conversion.for( 'editingDowncast' ).elementToElement( editingConversionConfig ) );
+ * ```
+ *
+ * See {@link module:engine/conversion/conversion~Conversion#for `for()`} method documentation to learn more about
+ * available conversion helpers and how to use your custom ones.
+ *
+ * # Two-way converters
+ *
+ * Besides using one-way converters via the `for()` method, you can also use other methods available in this
+ * class to add two-way converters (upcast and downcast):
+ *
+ * * {@link module:engine/conversion/conversion~Conversion#elementToElement `elementToElement()`} –
+ * Model element to view element and vice versa.
+ * * {@link module:engine/conversion/conversion~Conversion#attributeToElement `attributeToElement()`} –
+ * Model attribute to view element and vice versa.
+ * * {@link module:engine/conversion/conversion~Conversion#attributeToAttribute `attributeToAttribute()`} –
+ * Model attribute to view attribute and vice versa.
+ */
+export default class Conversion {
+    /**
+     * Maps dispatchers group name to ConversionHelpers instances.
+     */
+    private readonly _helpers;
+    private readonly _downcast;
+    private readonly _upcast;
+    /**
+     * Creates a new conversion instance.
+     */
+    constructor(downcastDispatchers: ArrayOrItem<DowncastDispatcher>, upcastDispatchers: ArrayOrItem<UpcastDispatcher>);
+    addAlias(alias: `${string}Downcast`, dispatcher: DowncastDispatcher): void;
+    addAlias(alias: `${string}Upcast`, dispatcher: UpcastDispatcher): void;
+    addAlias(alias: string, dispatcher: DowncastDispatcher | UpcastDispatcher): void;
+    for(groupName: 'downcast' | 'dataDowncast' | 'editingDowncast'): DowncastHelpers;
+    for(groupName: 'upcast'): UpcastHelpers;
+    for<T extends string>(groupName: T): ConversionType<T>;
+    /**
+     * Sets up converters between the model and the view that convert a model element to a view element (and vice versa).
+     * For example, the model `<paragraph>Foo</paragraph>` is turned into `<p>Foo</p>` in the view.
+     *
+     * ```ts
+     * // A simple conversion from the `paragraph` model element to the `<p>` view element (and vice versa).
+     * editor.conversion.elementToElement( { model: 'paragraph', view: 'p' } );
+     *
+     * // Override other converters by specifying a converter definition with a higher priority.
+     * editor.conversion.elementToElement( { model: 'paragraph', view: 'div', converterPriority: 'high' } );
+     *
+     * // View specified as an object instead of a string.
+     * editor.conversion.elementToElement( {
+     * 	model: 'fancyParagraph',
+     * 	view: {
+     * 		name: 'p',
+     * 		classes: 'fancy'
+     * 	}
+     * } );
+     *
+     * // Use `upcastAlso` to define other view elements that should also be converted to a `paragraph` element.
+     * editor.conversion.elementToElement( {
+     * 	model: 'paragraph',
+     * 	view: 'p',
+     * 	upcastAlso: [
+     * 		'div',
+     * 		{
+     * 			// Any element with the `display: block` style.
+     * 			styles: {
+     * 				display: 'block'
+     * 			}
+     * 		}
+     * 	]
+     * } );
+     *
+     * // `upcastAlso` set as callback enables a conversion of a wide range of different view elements.
+     * editor.conversion.elementToElement( {
+     * 	model: 'heading',
+     * 	view: 'h2',
+     * 	// Convert "heading-like" paragraphs to headings.
+     * 	upcastAlso: viewElement => {
+     * 		const fontSize = viewElement.getStyle( 'font-size' );
+     *
+     * 		if ( !fontSize ) {
+     * 			return null;
+     * 		}
+     *
+     * 		const match = fontSize.match( /(\d+)\s*px/ );
+     *
+     * 		if ( !match ) {
+     * 			return null;
+     * 		}
+     *
+     * 		const size = Number( match[ 1 ] );
+     *
+     * 		if ( size > 26 ) {
+     * 			// Returned value can be an object with the matched properties.
+     * 			// These properties will be "consumed" during the conversion.
+     * 			// See `engine.view.Matcher~MatcherPattern` and `engine.view.Matcher#match` for more details.
+     *
+     * 			return { name: true, styles: [ 'font-size' ] };
+     * 		}
+     *
+     * 		return null;
+     * 	}
+     * } );
+     * ```
+     *
+     * `definition.model` is a `String` with a model element name to convert from or to.
+     *
+     * @param definition The converter definition.
+     */
+    elementToElement(definition: {
+        model: string;
+        view: ElementDefinition;
+        upcastAlso?: ArrayOrItem<ElementDefinition | MatcherPattern>;
+        converterPriority?: PriorityString;
+    }): void;
+    /**
+     * Sets up converters between the model and the view that convert a model attribute to a view element (and vice versa).
+     * For example, a model text node with `"Foo"` as data and the `bold` attribute will be turned to `<strong>Foo</strong>` in the view.
+     *
+     * ```ts
+     * // A simple conversion from the `bold=true` attribute to the `<strong>` view element (and vice versa).
+     * editor.conversion.attributeToElement( { model: 'bold', view: 'strong' } );
+     *
+     * // Override other converters by specifying a converter definition with a higher priority.
+     * editor.conversion.attributeToElement( { model: 'bold', view: 'b', converterPriority: 'high' } );
+     *
+     * // View specified as an object instead of a string.
+     * editor.conversion.attributeToElement( {
+     * 	model: 'bold',
+     * 	view: {
+     * 		name: 'span',
+     * 		classes: 'bold'
+     * 	}
+     * } );
+     *
+     * // Use `config.model.name` to define the conversion only from a given node type, `$text` in this case.
+     * // The same attribute on different elements may then be handled by a different converter.
+     * editor.conversion.attributeToElement( {
+     * 	model: {
+     * 		key: 'textDecoration',
+     * 		values: [ 'underline', 'lineThrough' ],
+     * 		name: '$text'
+     * 	},
+     * 	view: {
+     * 		underline: {
+     * 			name: 'span',
+     * 			styles: {
+     * 				'text-decoration': 'underline'
+     * 			}
+     * 		},
+     * 		lineThrough: {
+     * 			name: 'span',
+     * 			styles: {
+     * 				'text-decoration': 'line-through'
+     * 			}
+     * 		}
+     * 	}
+     * } );
+     *
+     * // Use `upcastAlso` to define other view elements that should also be converted to the `bold` attribute.
+     * editor.conversion.attributeToElement( {
+     * 	model: 'bold',
+     * 	view: 'strong',
+     * 	upcastAlso: [
+     * 		'b',
+     * 		{
+     * 			name: 'span',
+     * 			classes: 'bold'
+     * 		},
+     * 		{
+     * 			name: 'span',
+     * 			styles: {
+     * 				'font-weight': 'bold'
+     * 			}
+     * 		},
+     * 		viewElement => {
+     * 			const fontWeight = viewElement.getStyle( 'font-weight' );
+     *
+     * 			if ( viewElement.is( 'element', 'span' ) && fontWeight && /\d+/.test() && Number( fontWeight ) > 500 ) {
+     * 				// Returned value can be an object with the matched properties.
+     * 				// These properties will be "consumed" during the conversion.
+     * 				// See `engine.view.Matcher~MatcherPattern` and `engine.view.Matcher#match` for more details.
+     *
+     * 				return {
+     * 					name: true,
+     * 					styles: [ 'font-weight' ]
+     * 				};
+     * 			}
+     * 		}
+     * 	]
+     * } );
+     *
+     * // Conversion from and to a model attribute key whose value is an enum (`fontSize=big|small`).
+     * // `upcastAlso` set as callback enables a conversion of a wide range of different view elements.
+     * editor.conversion.attributeToElement( {
+     * 	model: {
+     * 		key: 'fontSize',
+     * 		values: [ 'big', 'small' ]
+     * 	},
+     * 	view: {
+     * 		big: {
+     * 			name: 'span',
+     * 			styles: {
+     * 				'font-size': '1.2em'
+     * 			}
+     * 		},
+     * 		small: {
+     * 			name: 'span',
+     * 			styles: {
+     * 				'font-size': '0.8em'
+     * 			}
+     * 		}
+     * 	},
+     * 	upcastAlso: {
+     * 		big: viewElement => {
+     * 			const fontSize = viewElement.getStyle( 'font-size' );
+     *
+     * 			if ( !fontSize ) {
+     * 				return null;
+     * 			}
+     *
+     * 			const match = fontSize.match( /(\d+)\s*px/ );
+     *
+     * 			if ( !match ) {
+     * 				return null;
+     * 			}
+     *
+     * 			const size = Number( match[ 1 ] );
+     *
+     * 			if ( viewElement.is( 'element', 'span' ) && size > 10 ) {
+     * 				// Returned value can be an object with the matched properties.
+     * 				// These properties will be "consumed" during the conversion.
+     * 				// See `engine.view.Matcher~MatcherPattern` and `engine.view.Matcher#match` for more details.
+     *
+     * 				return { name: true, styles: [ 'font-size' ] };
+     * 			}
+     *
+     * 			return null;
+     * 		},
+     * 		small: viewElement => {
+     * 			const fontSize = viewElement.getStyle( 'font-size' );
+     *
+     * 			if ( !fontSize ) {
+     * 				return null;
+     * 			}
+     *
+     * 			const match = fontSize.match( /(\d+)\s*px/ );
+     *
+     * 			if ( !match ) {
+     * 				return null;
+     * 			}
+     *
+     * 			const size = Number( match[ 1 ] );
+     *
+     * 			if ( viewElement.is( 'element', 'span' ) && size < 10 ) {
+     * 				// Returned value can be an object with the matched properties.
+     * 				// These properties will be "consumed" during the conversion.
+     * 				// See `engine.view.Matcher~MatcherPattern` and `engine.view.Matcher#match` for more details.
+     *
+     * 				return { name: true, styles: [ 'font-size' ] };
+     * 			}
+     *
+     * 			return null;
+     * 		}
+     * 	}
+     * } );
+     * ```
+     *
+     * The `definition.model` parameter specifies which model attribute should be converted from or to. It can be a `{ key, value }` object
+     * describing the attribute key and value to convert or a `String` specifying just the attribute key (in such a case
+     * `value` is set to `true`).
+     *
+     * @param definition The converter definition.
+     */
+    attributeToElement<TValues extends string>(definition: {
+        model: string | {
+            key: string;
+            name?: string;
+        };
+        view: ElementDefinition;
+        upcastAlso?: ArrayOrItem<MatcherPattern>;
+        converterPriority?: PriorityString;
+    } | {
+        model: {
+            key: string;
+            name?: string;
+            values: Array<TValues>;
+        };
+        view: Record<TValues, ElementDefinition>;
+        upcastAlso?: Record<TValues, ArrayOrItem<MatcherPattern>>;
+        converterPriority?: PriorityString;
+    }): void;
+    /**
+     * Sets up converters between the model and the view that convert a model attribute to a view attribute (and vice versa). For example,
+     * `<imageBlock src='foo.jpg'></imageBlock>` is converted to `<img src='foo.jpg'></img>` (the same attribute key and value).
+     * This type of converters is intended to be used with {@link module:engine/model/element~Element model element} nodes.
+     * To convert the text attributes,
+     * the {@link module:engine/conversion/conversion~Conversion#attributeToElement `attributeToElement converter`}should be set up.
+     *
+     * ```ts
+     * // A simple conversion from the `source` model attribute to the `src` view attribute (and vice versa).
+     * editor.conversion.attributeToAttribute( { model: 'source', view: 'src' } );
+     *
+     * // Attribute values are strictly specified.
+     * editor.conversion.attributeToAttribute( {
+     * 	model: {
+     * 		name: 'imageInline',
+     * 		key: 'aside',
+     * 		values: [ 'aside' ]
+     * 	},
+     * 	view: {
+     * 		aside: {
+     * 			name: 'img',
+     * 			key: 'class',
+     * 			value: [ 'aside', 'half-size' ]
+     * 		}
+     * 	}
+     * } );
+     *
+     * // Set the style attribute.
+     * editor.conversion.attributeToAttribute( {
+     * 	model: {
+     * 		name: 'imageInline',
+     * 		key: 'aside',
+     * 		values: [ 'aside' ]
+     * 	},
+     * 	view: {
+     * 		aside: {
+     * 			name: 'img',
+     * 			key: 'style',
+     * 			value: {
+     * 				float: 'right',
+     * 				width: '50%',
+     * 				margin: '5px'
+     * 			}
+     * 		}
+     * 	}
+     * } );
+     *
+     * // Conversion from and to a model attribute key whose value is an enum (`align=right|center`).
+     * // Use `upcastAlso` to define other view elements that should also be converted to the `align=right` attribute.
+     * editor.conversion.attributeToAttribute( {
+     * 	model: {
+     * 		key: 'align',
+     * 		values: [ 'right', 'center' ]
+     * 	},
+     * 	view: {
+     * 		right: {
+     * 			key: 'class',
+     * 			value: 'align-right'
+     * 		},
+     * 		center: {
+     * 			key: 'class',
+     * 			value: 'align-center'
+     * 		}
+     * 	},
+     * 	upcastAlso: {
+     * 		right: {
+     * 			styles: {
+     * 				'text-align': 'right'
+     * 			}
+     * 		},
+     * 		center: {
+     * 			styles: {
+     * 				'text-align': 'center'
+     * 			}
+     * 		}
+     * 	}
+     * } );
+     * ```
+     *
+     * The `definition.model` parameter specifies which model attribute should be converted from and to.
+     * It can be a `{ key, [ values ], [ name ] }` object or a `String`, which will be treated like `{ key: definition.model }`.
+     * The `key` property is the model attribute key to convert from and to.
+     * The `values` are the possible model attribute values. If the `values` parameter is not set, the model attribute value
+     * will be the same as the view attribute value.
+     * If `name` is set, the conversion will be set up only for model elements with the given name.
+     *
+     * The `definition.view` parameter specifies which view attribute should be converted from and to.
+     * It can be a `{ key, value, [ name ] }` object or a `String`, which will be treated like `{ key: definition.view }`.
+     * The `key` property is the view attribute key to convert from and to.
+     * The `value` is the view attribute value to convert from and to. If `definition.value` is not set, the view attribute value will be
+     * the same as the model attribute value.
+     * If `key` is `'class'`, `value` can be a `String` or an array of `String`s.
+     * If `key` is `'style'`, `value` is an object with key-value pairs.
+     * In other cases, `value` is a `String`.
+     * If `name` is set, the conversion will be set up only for model elements with the given name.
+     * If `definition.model.values` is set, `definition.view` is an object that assigns values from `definition.model.values`
+     * to `{ key, value, [ name ] }` objects.
+     *
+     * `definition.upcastAlso` specifies which other matching view elements should also be upcast to the given model configuration.
+     * If `definition.model.values` is set, `definition.upcastAlso` should be an object assigning values from `definition.model.values`
+     * to {@link module:engine/view/matcher~MatcherPattern}s or arrays of {@link module:engine/view/matcher~MatcherPattern}s.
+     *
+     * **Note:** `definition.model` and `definition.view` form should be mirrored, so the same types of parameters should
+     * be given in both parameters.
+     *
+     * @param definition The converter definition.
+     * @param definition.model The model attribute to convert from and to.
+     * @param definition.view The view attribute to convert from and to.
+     * @param definition.upcastAlso Any view element matching `definition.upcastAlso` will also be converted to the given model attribute.
+     * `definition.upcastAlso` is used only if `config.model.values` is specified.
+     */
+    attributeToAttribute<TValues extends string>(definition: {
+        model: string | {
+            key: string;
+            name?: string;
+        };
+        view: string | (AttributeDescriptor & {
+            name?: string;
+        });
+        upcastAlso?: ArrayOrItem<string | (AttributeDescriptor & {
+            name?: string;
+        }) | AttributeCreatorFunction>;
+        converterPriority?: PriorityString;
+    } | {
+        model: {
+            key: string;
+            name?: string;
+            values: Array<TValues>;
+        };
+        view: Record<TValues, (AttributeDescriptor & {
+            name?: string;
+        })>;
+        upcastAlso?: Record<TValues, (AttributeDescriptor & {
+            name?: string;
+        }) | AttributeCreatorFunction>;
+        converterPriority?: PriorityString;
+    }): void;
+    /**
+     * Creates and caches conversion helpers for given dispatchers group.
+     *
+     * @param options.name Group name.
+     */
+    private _createConversionHelpers;
+}
+type ConversionType<T extends string> = T extends `${string}Downcast` ? DowncastHelpers : T extends `${string}Upcast` ? UpcastHelpers : DowncastHelpers | UpcastHelpers;
+export {};