@ckeditor/ckeditor5-engine 47.6.1 → 48.0.0-alpha.0

package/src/view/elementdefinition.js

@@ -1,5 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-export {};

package/src/view/emptyelement.js

@@ -1,83 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module engine/view/emptyelement
- */
-import { ViewElement } from './element.js';
-import { ViewNode } from './node.js';
-import { CKEditorError } from '@ckeditor/ckeditor5-utils';
-/**
- * Empty element class. It is used to represent elements that cannot contain any child nodes (for example `<img>` elements).
- *
- * To create a new empty element use the
- * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createEmptyElement `downcastWriter#createEmptyElement()`} method.
- */
-export class ViewEmptyElement extends ViewElement {
-    /**
-     * Creates new instance of ViewEmptyElement.
-     *
-     * Throws {@link module:utils/ckeditorerror~CKEditorError CKEditorError} `view-emptyelement-cannot-add` when third parameter is passed,
-     * to inform that usage of ViewEmptyElement is incorrect (adding child nodes to ViewEmptyElement is forbidden).
-     *
-     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createEmptyElement
-     * @internal
-     * @param document The document instance to which this element belongs.
-     * @param name Node name.
-     * @param attributes Collection of attributes.
-     * @param children A list of nodes to be inserted into created element.
-     */
-    constructor(document, name, attributes, children) {
-        super(document, name, attributes, children);
-        this.getFillerOffset = getFillerOffset;
-    }
-    /**
-     * Converts `ViewEmptyElement` instance to plain object and returns it.
-     *
-     * @returns `ViewEmptyElement` instance converted to plain object.
-     */
-    toJSON() {
-        const json = super.toJSON();
-        json.type = 'EmptyElement';
-        return json;
-    }
-    /**
-     * Overrides {@link module:engine/view/element~ViewElement#_insertChild} method.
-     * Throws {@link module:utils/ckeditorerror~CKEditorError CKEditorError} `view-emptyelement-cannot-add` to prevent
-     * adding any child nodes to ViewEmptyElement.
-     *
-     * @internal
-     */
-    _insertChild(index, items) {
-        if (items && (items instanceof ViewNode || Array.from(items).length > 0)) {
-            /**
-             * Cannot add children to {@link module:engine/view/emptyelement~ViewEmptyElement}.
-             *
-             * @error view-emptyelement-cannot-add
-             */
-            throw new CKEditorError('view-emptyelement-cannot-add', [this, items]);
-        }
-        return 0;
-    }
-}
-// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
-// Proper overload would interfere with that.
-ViewEmptyElement.prototype.is = function (type, name) {
-    if (!name) {
-        return type === 'emptyElement' || type === 'view:emptyElement' ||
-            // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
-            type === 'element' || type === 'view:element' ||
-            type === 'node' || type === 'view:node';
-    }
-    else {
-        return name === this.name && (type === 'emptyElement' || type === 'view:emptyElement' ||
-            type === 'element' || type === 'view:element');
-    }
-};
-/**
- * Returns `null` because block filler is not needed for ViewEmptyElements.
- */
-function getFillerOffset() {
-    return null;
-}

package/src/view/filler.js

@@ -1,161 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { keyCodes, isText } from '@ckeditor/ckeditor5-utils';
-/**
- * Set of utilities related to handling block and inline fillers.
- *
- * Browsers do not allow to put caret in elements which does not have height. Because of it, we need to fill all
- * empty elements which should be selectable with elements or characters called "fillers". Unfortunately there is no one
- * universal filler, this is why two types are uses:
- *
- * * Block filler is an element which fill block elements, like `<p>`. CKEditor uses `<br>` as a block filler during the editing,
- * as browsers do natively. So instead of an empty `<p>` there will be `<p><br></p>`. The advantage of block filler is that
- * it is transparent for the selection, so when the caret is before the `<br>` and user presses right arrow he will be
- * moved to the next paragraph, not after the `<br>`. The disadvantage is that it breaks a block, so it cannot be used
- * in the middle of a line of text. The {@link module:engine/view/filler~BR_FILLER `<br>` filler} can be replaced with any other
- * character in the data output, for instance {@link module:engine/view/filler~NBSP_FILLER non-breaking space} or
- * {@link module:engine/view/filler~MARKED_NBSP_FILLER marked non-breaking space}.
- *
- * * Inline filler is a filler which does not break a line of text, so it can be used inside the text, for instance in the empty
- * `<b>` surrendered by text: `foo<b></b>bar`, if we want to put the caret there. CKEditor uses a sequence of the zero-width
- * spaces as an {@link module:engine/view/filler~INLINE_FILLER inline filler} having the predetermined
- * {@link module:engine/view/filler~INLINE_FILLER_LENGTH length}. A sequence is used, instead of a single character to
- * avoid treating random zero-width spaces as the inline filler. Disadvantage of the inline filler is that it is not
- * transparent for the selection. The arrow key moves the caret between zero-width spaces characters, so the additional
- * code is needed to handle the caret.
- *
- * Both inline and block fillers are handled by the {@link module:engine/view/renderer~ViewRenderer renderer} and are not present in the
- * view.
- *
- * @module engine/view/filler
- */
-/**
- * Non-breaking space filler creator. This function creates the `&nbsp;` text node.
- * It defines how the filler is created.
- *
- * @see module:engine/view/filler~MARKED_NBSP_FILLER
- * @see module:engine/view/filler~BR_FILLER
- * @internal
- */
-export const NBSP_FILLER = (domDocument) => domDocument.createTextNode('\u00A0');
-/**
- * Marked non-breaking space filler creator. This function creates the `<span data-cke-filler="true">&nbsp;</span>` element.
- * It defines how the filler is created.
- *
- * @see module:engine/view/filler~NBSP_FILLER
- * @see module:engine/view/filler~BR_FILLER
- * @internal
- */
-export const MARKED_NBSP_FILLER = (domDocument) => {
-    const span = domDocument.createElement('span');
-    span.dataset.ckeFiller = 'true';
-    span.innerText = '\u00A0';
-    return span;
-};
-/**
- * `<br>` filler creator. This function creates the `<br data-cke-filler="true">` element.
- * It defines how the filler is created.
- *
- * @see module:engine/view/filler~NBSP_FILLER
- * @see module:engine/view/filler~MARKED_NBSP_FILLER
- * @internal
- */
-export const BR_FILLER = (domDocument) => {
-    const fillerBr = domDocument.createElement('br');
-    fillerBr.dataset.ckeFiller = 'true';
-    return fillerBr;
-};
-/**
- * Length of the {@link module:engine/view/filler~INLINE_FILLER INLINE_FILLER}.
- *
- * @internal
- */
-export const INLINE_FILLER_LENGTH = 7;
-/**
- * Inline filler which is a sequence of the word joiners.
- *
- * @internal
- */
-export const INLINE_FILLER = '\u2060'.repeat(INLINE_FILLER_LENGTH);
-/**
- * Checks if the node is a text node which starts with the {@link module:engine/view/filler~INLINE_FILLER inline filler}.
- *
- * ```ts
- * startsWithFiller( document.createTextNode( INLINE_FILLER ) ); // true
- * startsWithFiller( document.createTextNode( INLINE_FILLER + 'foo' ) ); // true
- * startsWithFiller( document.createTextNode( 'foo' ) ); // false
- * startsWithFiller( document.createElement( 'p' ) ); // false
- * ```
- *
- * @param domNode DOM node.
- * @returns True if the text node starts with the {@link module:engine/view/filler~INLINE_FILLER inline filler}.
- * @internal
- */
-export function startsWithFiller(domNode) {
-    if (typeof domNode == 'string') {
-        return domNode.substr(0, INLINE_FILLER_LENGTH) === INLINE_FILLER;
-    }
-    return isText(domNode) && (domNode.data.substr(0, INLINE_FILLER_LENGTH) === INLINE_FILLER);
-}
-/**
- * Checks if the text node contains only the {@link module:engine/view/filler~INLINE_FILLER inline filler}.
- *
- * ```ts
- * isInlineFiller( document.createTextNode( INLINE_FILLER ) ); // true
- * isInlineFiller( document.createTextNode( INLINE_FILLER + 'foo' ) ); // false
- * ```
- *
- * @param domText DOM text node.
- * @returns True if the text node contains only the {@link module:engine/view/filler~INLINE_FILLER inline filler}.
- * @internal
- */
-export function isInlineFiller(domText) {
-    return domText.data.length == INLINE_FILLER_LENGTH && startsWithFiller(domText);
-}
-/**
- * Get string data from the text node, removing an {@link module:engine/view/filler~INLINE_FILLER inline filler} from it,
- * if text node contains it.
- *
- * ```ts
- * getDataWithoutFiller( document.createTextNode( INLINE_FILLER + 'foo' ) ) == 'foo' // true
- * getDataWithoutFiller( document.createTextNode( 'foo' ) ) == 'foo' // true
- * ```
- *
- * @param domText DOM text node, possible with inline filler.
- * @returns Data without filler.
- * @internal
- */
-export function getDataWithoutFiller(domText) {
-    const data = typeof domText == 'string' ? domText : domText.data;
-    if (startsWithFiller(domText)) {
-        return data.slice(INLINE_FILLER_LENGTH);
-    }
-    return data;
-}
-/**
- * Assign key observer which move cursor from the end of the inline filler to the beginning of it when
- * the left arrow is pressed, so the filler does not break navigation.
- *
- * @param view View controller instance we should inject quirks handling on.
- * @internal
- */
-export function injectQuirksHandling(view) {
-    view.document.on('arrowKey', jumpOverInlineFiller, { priority: 'low' });
-}
-/**
- * Move cursor from the end of the inline filler to the beginning of it when, so the filler does not break navigation.
- */
-function jumpOverInlineFiller(evt, data) {
-    if (data.keyCode == keyCodes.arrowleft) {
-        const domSelection = data.domTarget.ownerDocument.defaultView.getSelection();
-        if (domSelection.rangeCount == 1 && domSelection.getRangeAt(0).collapsed) {
-            const domParent = domSelection.getRangeAt(0).startContainer;
-            const domOffset = domSelection.getRangeAt(0).startOffset;
-            if (startsWithFiller(domParent) && domOffset <= INLINE_FILLER_LENGTH) {
-                domSelection.collapse(domParent, 0);
-            }
-        }
-    }
-}

package/src/view/item.js

@@ -1,5 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-export {};

package/src/view/matcher.js

@@ -1,437 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { logWarning } from '@ckeditor/ckeditor5-utils';
-import { normalizeConsumables } from '../conversion/viewconsumable.js';
-/**
- * View matcher class.
- * Instance of this class can be used to find {@link module:engine/view/element~ViewElement elements} that match given pattern.
- */
-export class Matcher {
-    _patterns = [];
-    /**
-     * Creates new instance of Matcher.
-     *
-     * @param pattern Match patterns. See {@link module:engine/view/matcher~Matcher#add add method} for more information.
-     */
-    constructor(...pattern) {
-        this.add(...pattern);
-    }
-    /**
-     * Adds pattern or patterns to matcher instance.
-     *
-     * ```ts
-     * // String.
-     * matcher.add( 'div' );
-     *
-     * // Regular expression.
-     * matcher.add( /^\w/ );
-     *
-     * // Single class.
-     * matcher.add( {
-     * 	classes: 'foobar'
-     * } );
-     * ```
-     *
-     * See {@link module:engine/view/matcher~MatcherPattern} for more examples.
-     *
-     * Multiple patterns can be added in one call:
-     *
-     * ```ts
-     * matcher.add( 'div', { classes: 'foobar' } );
-     * ```
-     *
-     * @param pattern Object describing pattern details. If string or regular expression
-     * is provided it will be used to match element's name. Pattern can be also provided in a form
-     * of a function - then this function will be called with each {@link module:engine/view/element~ViewElement element} as a parameter.
-     * Function's return value will be stored under `match` key of the object returned from
-     * {@link module:engine/view/matcher~Matcher#match match} or {@link module:engine/view/matcher~Matcher#matchAll matchAll} methods.
-     */
-    add(...pattern) {
-        for (let item of pattern) {
-            // String or RegExp pattern is used as element's name.
-            if (typeof item == 'string' || item instanceof RegExp) {
-                item = { name: item };
-            }
-            this._patterns.push(item);
-        }
-    }
-    /**
-     * Matches elements for currently stored patterns. Returns match information about first found
-     * {@link module:engine/view/element~ViewElement element}, otherwise returns `null`.
-     *
-     * Example of returned object:
-     *
-     * ```ts
-     * {
-     * 	element: <instance of found element>,
-     * 	pattern: <pattern used to match found element>,
-     * 	match: {
-     * 		name: true,
-     * 		attributes: [
-     * 			[ 'title' ],
-     * 			[ 'href' ],
-     * 			[ 'class', 'foo' ],
-     * 			[ 'style', 'color' ],
-     * 			[ 'style', 'position' ]
-     * 		]
-     * 	}
-     * }
-     * ```
-     *
-     * You could use the `match` field from the above returned object as an input for the
-     * {@link module:engine/conversion/viewconsumable~ViewConsumable#test `ViewConsumable#test()`} and
-     * {@link module:engine/conversion/viewconsumable~ViewConsumable#consume `ViewConsumable#consume()`} methods.
-     *
-     * @see module:engine/view/matcher~Matcher#add
-     * @see module:engine/view/matcher~Matcher#matchAll
-     * @param element View element to match against stored patterns.
-     * @returns The match information about found element or `null`.
-     */
-    match(...element) {
-        for (const singleElement of element) {
-            for (const pattern of this._patterns) {
-                const match = this._isElementMatching(singleElement, pattern);
-                if (match) {
-                    return {
-                        element: singleElement,
-                        pattern,
-                        match
-                    };
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Matches elements for currently stored patterns. Returns array of match information with all found
-     * {@link module:engine/view/element~ViewElement elements}. If no element is found - returns `null`.
-     *
-     * @see module:engine/view/matcher~Matcher#add
-     * @see module:engine/view/matcher~Matcher#match
-     * @param element View element to match against stored patterns.
-     * @returns Array with match information about found elements or `null`. For more information
-     * see {@link module:engine/view/matcher~Matcher#match match method} description.
-     */
-    matchAll(...element) {
-        const results = [];
-        for (const singleElement of element) {
-            for (const pattern of this._patterns) {
-                const match = this._isElementMatching(singleElement, pattern);
-                if (match) {
-                    results.push({
-                        element: singleElement,
-                        pattern,
-                        match
-                    });
-                }
-            }
-        }
-        return results.length > 0 ? results : null;
-    }
-    /**
-     * Returns the name of the element to match if there is exactly one pattern added to the matcher instance
-     * and it matches element name defined by `string` (not `RegExp`). Otherwise, returns `null`.
-     *
-     * @returns Element name trying to match.
-     */
-    getElementName() {
-        if (this._patterns.length !== 1) {
-            return null;
-        }
-        const pattern = this._patterns[0];
-        const name = pattern.name;
-        return (typeof pattern != 'function' && name && !(name instanceof RegExp)) ? name : null;
-    }
-    /**
-     * Returns match information if {@link module:engine/view/element~ViewElement element} is matching provided pattern.
-     * If element cannot be matched to provided pattern - returns `null`.
-     *
-     * @returns Returns object with match information or null if element is not matching.
-     */
-    _isElementMatching(element, pattern) {
-        // If pattern is provided as function - return result of that function;
-        if (typeof pattern == 'function') {
-            const match = pattern(element);
-            // In some places we use Matcher with callback pattern that returns boolean.
-            if (!match || typeof match != 'object') {
-                return match;
-            }
-            return normalizeConsumables(match);
-        }
-        const match = {};
-        // Check element's name.
-        if (pattern.name) {
-            match.name = matchName(pattern.name, element.name);
-            if (!match.name) {
-                return null;
-            }
-        }
-        const attributesMatch = [];
-        // Check element's attributes.
-        if (pattern.attributes && !matchAttributes(pattern.attributes, element, attributesMatch)) {
-            return null;
-        }
-        // Check element's classes.
-        if (pattern.classes && !matchClasses(pattern.classes, element, attributesMatch)) {
-            return null;
-        }
-        // Check element's styles.
-        if (pattern.styles && !matchStyles(pattern.styles, element, attributesMatch)) {
-            return null;
-        }
-        // Note the `attributesMatch` array is populated by the above calls.
-        if (attributesMatch.length) {
-            match.attributes = attributesMatch;
-        }
-        return match;
-    }
-}
-/**
- * Returns true if the given `item` matches the pattern.
- *
- * @internal
- * @param pattern A pattern representing a key/value we want to match.
- * @param item An actual item key/value (e.g. `'src'`, `'background-color'`, `'ck-widget'`) we're testing against pattern.
- */
-export function isPatternMatched(pattern, item) {
-    return pattern === true ||
-        pattern === item ||
-        pattern instanceof RegExp && !!String(item).match(pattern);
-}
-/**
- * Checks if name can be matched by provided pattern.
- *
- * @returns Returns `true` if name can be matched, `false` otherwise.
- */
-function matchName(pattern, name) {
-    // If pattern is provided as RegExp - test against this regexp.
-    if (pattern instanceof RegExp) {
-        return !!name.match(pattern);
-    }
-    return pattern === name;
-}
-/**
- * Bring all the possible pattern forms to an array of tuples where first item is a key, second is a value,
- * and third optional is a token value.
- *
- * Examples:
- *
- * Boolean pattern value:
- *
- * ```ts
- * true
- * ```
- *
- * to
- *
- * ```ts
- * [ [ true, true ] ]
- * ```
- *
- * Textual pattern value:
- *
- * ```ts
- * 'attribute-name-or-class-or-style'
- * ```
- *
- * to
- *
- * ```ts
- * [ [ 'attribute-name-or-class-or-style', true ] ]
- * ```
- *
- * Regular expression:
- *
- * ```ts
- * /^data-.*$/
- * ```
- *
- * to
- *
- * ```ts
- * [ [ /^data-.*$/, true ] ]
- * ```
- *
- * Objects (plain or with `key` and `value` specified explicitly):
- *
- * ```ts
- * {
- * 	src: /^https:.*$/
- * }
- * ```
- *
- * or
- *
- * ```ts
- * [ {
- * 	key: 'src',
- * 	value: /^https:.*$/
- * } ]
- * ```
- *
- * to:
- *
- * ```ts
- * [ [ 'src', /^https:.*$/ ] ]
- * ```
- *
- * @returns Returns an array of objects or null if provided patterns were not in an expected form.
- */
-function normalizePatterns(patterns, prefix) {
-    if (Array.isArray(patterns)) {
-        return patterns.map(pattern => {
-            if (typeof pattern !== 'object' || pattern instanceof RegExp) {
-                return prefix ?
-                    [prefix, pattern, true] :
-                    [pattern, true];
-            }
-            if (pattern.key === undefined || pattern.value === undefined) {
-                // Documented at the end of matcher.js.
-                logWarning('matcher-pattern-missing-key-or-value', pattern);
-            }
-            return prefix ?
-                [prefix, pattern.key, pattern.value] :
-                [pattern.key, pattern.value];
-        });
-    }
-    if (typeof patterns !== 'object' || patterns instanceof RegExp) {
-        return [
-            prefix ?
-                [prefix, patterns, true] :
-                [patterns, true]
-        ];
-    }
-    // Below we do what Object.entries() does, but faster
-    const normalizedPatterns = [];
-    for (const key in patterns) {
-        // Replace with Object.hasOwn() when we upgrade to es2022.
-        if (Object.prototype.hasOwnProperty.call(patterns, key)) {
-            normalizedPatterns.push(prefix ?
-                [prefix, key, patterns[key]] :
-                [key, patterns[key]]);
-        }
-    }
-    return normalizedPatterns;
-}
-/**
- * Checks if attributes of provided element can be matched against provided patterns.
- *
- * @param patterns Object with information about attributes to match. Each key of the object will be
- * used as attribute name. Value of each key can be a string or regular expression to match against attribute value.
- * @param  element Element which attributes will be tested.
- * @param match An array to populate with matching tuples.
- * @returns Returns array with matched attribute names or `null` if no attributes were matched.
- */
-function matchAttributes(patterns, element, match) {
-    let excludeAttributes;
-    // `style` and `class` attribute keys are deprecated. Only allow them in object pattern
-    // for backward compatibility.
-    if (typeof patterns === 'object' && !(patterns instanceof RegExp) && !Array.isArray(patterns)) {
-        if (patterns.style !== undefined) {
-            // Documented at the end of matcher.js.
-            logWarning('matcher-pattern-deprecated-attributes-style-key', patterns);
-        }
-        if (patterns.class !== undefined) {
-            // Documented at the end of matcher.js.
-            logWarning('matcher-pattern-deprecated-attributes-class-key', patterns);
-        }
-    }
-    else {
-        excludeAttributes = ['class', 'style'];
-    }
-    return element._collectAttributesMatch(normalizePatterns(patterns), match, excludeAttributes);
-}
-/**
- * Checks if classes of provided element can be matched against provided patterns.
- *
- * @param patterns Array of strings or regular expressions to match against element's classes.
- * @param element Element which classes will be tested.
- * @param match An array to populate with matching tuples.
- * @returns Returns array with matched class names or `null` if no classes were matched.
- */
-function matchClasses(patterns, element, match) {
-    return element._collectAttributesMatch(normalizePatterns(patterns, 'class'), match);
-}
-/**
- * Checks if styles of provided element can be matched against provided patterns.
- *
- * @param patterns Object with information about styles to match. Each key of the object will be
- * used as style name. Value of each key can be a string or regular expression to match against style value.
- * @param element Element which styles will be tested.
- * @param match An array to populate with matching tuples.
- * @returns Returns array with matched style names or `null` if no styles were matched.
- */
-function matchStyles(patterns, element, match) {
-    return element._collectAttributesMatch(normalizePatterns(patterns, 'style'), match);
-}
-/**
- * The key-value matcher pattern is missing key or value. Both must be present.
- * Refer the documentation: {@link module:engine/view/matcher~MatcherPattern}.
- *
- * @param pattern Pattern with missing properties.
- * @error matcher-pattern-missing-key-or-value
- */
-/**
- * The key-value matcher pattern for `attributes` option is using deprecated `style` key.
- *
- * Use `styles` matcher pattern option instead:
- *
- * ```ts
- * // Instead of:
- * const pattern = {
- * 	attributes: {
- * 		key1: 'value1',
- * 		key2: 'value2',
- * 		style: /^border.*$/
- * 	}
- * }
- *
- * // Use:
- * const pattern = {
- * 	attributes: {
- * 		key1: 'value1',
- * 		key2: 'value2'
- * 	},
- * 	styles: /^border.*$/
- * }
- * ```
- *
- * Refer to the {@glink updating/guides/update-to-29##update-to-ckeditor-5-v2910 Migration to v29.1.0} guide
- * and {@link module:engine/view/matcher~MatcherPattern} documentation.
- *
- * @param pattern Pattern with missing properties.
- * @error matcher-pattern-deprecated-attributes-style-key
- */
-/**
- * The key-value matcher pattern for `attributes` option is using deprecated `class` key.
- *
- * Use `classes` matcher pattern option instead:
- *
- * ```ts
- * // Instead of:
- * const pattern = {
- * 	attributes: {
- * 		key1: 'value1',
- * 		key2: 'value2',
- * 		class: 'foobar'
- * 	}
- * }
- *
- * // Use:
- * const pattern = {
- * 	attributes: {
- * 		key1: 'value1',
- * 		key2: 'value2'
- * 	},
- * 	classes: 'foobar'
- * }
- * ```
- *
- * Refer to the {@glink updating/guides/update-to-29##update-to-ckeditor-5-v2910 Migration to v29.1.0} guide
- * and the {@link module:engine/view/matcher~MatcherPattern} documentation.
- *
- * @param pattern Pattern with missing properties.
- * @error matcher-pattern-deprecated-attributes-class-key
- */