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

package/dist/index.js

@@ -5,14 +5,17 @@
 import { Command, Plugin } from '@ckeditor/ckeditor5-core/dist/index.js';
 import { Delete } from '@ckeditor/ckeditor5-typing/dist/index.js';
 import { Enter } from '@ckeditor/ckeditor5-enter/dist/index.js';
-import { toArray, first, uid, CKEditorError, FocusTracker, KeystrokeHandler, global, getCode, parseKeystroke, getLocalizedArrowKeyCodeDirection, createElement, logWarning } from '@ckeditor/ckeditor5-utils/dist/index.js';
+import { toArray, first, uid, CKEditorError, FocusTracker, KeystrokeHandler, global, getCode, parseKeystroke, getLocalizedArrowKeyCodeDirection, createElement } from '@ckeditor/ckeditor5-utils/dist/index.js';
+import { _normalizeFontSizeOptions } from '@ckeditor/ckeditor5-font/dist/index.js';
 import { ClipboardPipeline } from '@ckeditor/ckeditor5-clipboard/dist/index.js';
 import { ButtonView, MenuBarMenuListItemButtonView, View, ViewCollection, FocusCycler, addKeyboardHandlingForGrid, CollapsibleView, LabeledFieldView, createLabeledInputNumber, SwitchButtonView, createDropdown, SplitButtonView, MenuBarMenuView, focusChildOnDropdownOpen } from '@ckeditor/ckeditor5-ui/dist/index.js';
 import { IconNumberedList, IconBulletedList, IconListStyleDisc, IconListStyleCircle, IconListStyleSquare, IconListStyleDecimal, IconListStyleDecimalLeadingZero, IconListStyleLowerRoman, IconListStyleUpperRoman, IconListStyleLowerLatin, IconListStyleUpperLatin, IconTodoList } from '@ckeditor/ckeditor5-icons/dist/index.js';
-import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckeditor/ckeditor5-engine/dist/index.js';
+import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from '@ckeditor/ckeditor5-engine/dist/index.js';
 
 /**
  * Document list blocks iterator.
+ *
+ * @internal
  */ class ListWalker {
     /**
 	 * The start list item block element.
@@ -141,6 +144,8 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
 }
 /**
  * Iterates sibling list blocks starting from the given node.
+ *
+ * @internal
  */ class SiblingListBlocksIterator {
     _node;
     _isForward;
@@ -633,11 +638,14 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
  *
  * @param block A block to be tested.
  * @param schema The schema of the document.
+ * @internal
  */ function canBecomeSimpleListItem(block, schema) {
     return schema.checkChild(block.parent, 'listItem') && schema.checkChild(block, '$text') && !schema.isObject(block);
 }
 /**
  * Returns true if listType is of type `numbered` or `customNumbered`.
+ *
+ * @internal
  */ function isNumberedListType(listType) {
     return listType == 'numbered' || listType == 'customNumbered';
 }
@@ -1162,6 +1170,642 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
     }
 }
 
+/**
+ * The list item bold integration plugin.
+ */ class ListItemBoldIntegration extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListItemBoldIntegration';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListEditing
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ init() {
+        const editor = this.editor;
+        const ListFormatting = editor.plugins.get('ListFormatting');
+        const listEditing = editor.plugins.get(ListEditing);
+        if (!editor.plugins.has('BoldEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        ListFormatting.registerFormatAttribute('bold', 'listItemBold');
+        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
+        // registers its converters.
+        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
+        listEditing.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemBold',
+            setAttributeOnDowncast (writer, value, viewElement) {
+                if (value) {
+                    writer.addClass('ck-list-marker-bold', viewElement);
+                }
+            }
+        });
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        const editor = this.editor;
+        const model = editor.model;
+        if (!editor.plugins.has('BoldEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        model.schema.extend('$listItem', {
+            allowAttributes: 'listItemBold'
+        });
+        model.schema.setAttributeProperties('listItemBold', {
+            isFormatting: true
+        });
+        model.schema.addAttributeCheck((context)=>{
+            const item = context.last;
+            if (!item.getAttribute('listItemId')) {
+                return false;
+            }
+        }, 'listItemBold');
+        editor.conversion.for('upcast').attributeToAttribute({
+            model: 'listItemBold',
+            view: {
+                name: 'li',
+                classes: 'ck-list-marker-bold'
+            }
+        });
+    }
+}
+
+/**
+ * The list item italic integration plugin.
+ */ class ListItemItalicIntegration extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListItemItalicIntegration';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListEditing
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ init() {
+        const editor = this.editor;
+        const ListFormatting = editor.plugins.get('ListFormatting');
+        const listEditing = editor.plugins.get(ListEditing);
+        if (!editor.plugins.has('ItalicEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        ListFormatting.registerFormatAttribute('italic', 'listItemItalic');
+        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
+        // registers its converters.
+        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
+        listEditing.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemItalic',
+            setAttributeOnDowncast (writer, value, viewElement) {
+                if (value) {
+                    writer.addClass('ck-list-marker-italic', viewElement);
+                }
+            }
+        });
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        const editor = this.editor;
+        const model = editor.model;
+        if (!editor.plugins.has('ItalicEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        model.schema.extend('$listItem', {
+            allowAttributes: 'listItemItalic'
+        });
+        model.schema.setAttributeProperties('listItemItalic', {
+            isFormatting: true
+        });
+        model.schema.addAttributeCheck((context)=>{
+            const item = context.last;
+            if (!item.getAttribute('listItemId')) {
+                return false;
+            }
+        }, 'listItemItalic');
+        editor.conversion.for('upcast').attributeToAttribute({
+            model: 'listItemItalic',
+            view: {
+                name: 'li',
+                classes: 'ck-list-marker-italic'
+            }
+        });
+    }
+}
+
+/**
+ * The list item font size integration plugin.
+ */ class ListItemFontSizeIntegration extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListItemFontSizeIntegration';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListEditing
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ init() {
+        const editor = this.editor;
+        const ListFormatting = editor.plugins.get('ListFormatting');
+        const listEditing = editor.plugins.get(ListEditing);
+        if (!editor.plugins.has('FontSizeEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        const normalizedFontSizeOptions = _normalizeFontSizeOptions(editor.config.get('fontSize.options'));
+        ListFormatting.registerFormatAttribute('fontSize', 'listItemFontSize');
+        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
+        // registers its converters.
+        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
+        listEditing.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemFontSize',
+            setAttributeOnDowncast (writer, value, viewElement) {
+                if (value) {
+                    const fontSizeOption = normalizedFontSizeOptions.find((option)=>option.model == value);
+                    if (fontSizeOption && fontSizeOption.view && typeof fontSizeOption.view != 'string') {
+                        if (fontSizeOption.view.styles) {
+                            writer.addClass('ck-list-marker-font-size', viewElement);
+                            writer.setStyle('--ck-content-list-marker-font-size', fontSizeOption.view.styles['font-size'], viewElement);
+                        } else if (fontSizeOption.view.classes) {
+                            writer.addClass(`ck-list-marker-font-size-${value}`, viewElement);
+                        }
+                    } else {
+                        writer.addClass('ck-list-marker-font-size', viewElement);
+                        writer.setStyle('--ck-content-list-marker-font-size', value, viewElement);
+                    }
+                }
+            }
+        });
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        const editor = this.editor;
+        const model = editor.model;
+        if (!editor.plugins.has('FontSizeEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        model.schema.extend('$listItem', {
+            allowAttributes: 'listItemFontSize'
+        });
+        model.schema.setAttributeProperties('listItemFontSize', {
+            isFormatting: true
+        });
+        model.schema.addAttributeCheck((context)=>{
+            const item = context.last;
+            if (!item.getAttribute('listItemId')) {
+                return false;
+            }
+        }, 'listItemFontSize');
+        editor.conversion.for('upcast').elementToAttribute({
+            model: {
+                key: 'listItemFontSize',
+                value: (viewElement)=>viewElement.getStyle('--ck-content-list-marker-font-size')
+            },
+            view: {
+                name: 'li',
+                classes: 'ck-list-marker-font-size',
+                styles: {
+                    '--ck-content-list-marker-font-size': /.*/
+                }
+            }
+        });
+        const fontSizeOptions = _normalizeFontSizeOptions(editor.config.get('fontSize.options'));
+        for (const option of fontSizeOptions){
+            if (option.model && option.view) {
+                editor.conversion.for('upcast').elementToAttribute({
+                    model: {
+                        key: 'listItemFontSize',
+                        value: option.model
+                    },
+                    view: {
+                        name: 'li',
+                        classes: `ck-list-marker-font-size-${option.model}`
+                    }
+                });
+            }
+        }
+    }
+}
+
+/**
+ * The list item font color integration plugin.
+ */ class ListItemFontColorIntegration extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListItemFontColorIntegration';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListEditing
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ init() {
+        const editor = this.editor;
+        const ListFormatting = editor.plugins.get('ListFormatting');
+        const listEditing = editor.plugins.get(ListEditing);
+        if (!editor.plugins.has('FontColorEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        ListFormatting.registerFormatAttribute('fontColor', 'listItemFontColor');
+        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
+        // registers its converters.
+        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
+        listEditing.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemFontColor',
+            setAttributeOnDowncast (writer, value, viewElement) {
+                if (value) {
+                    writer.addClass('ck-list-marker-color', viewElement);
+                    writer.setStyle('--ck-content-list-marker-color', value, viewElement);
+                }
+            }
+        });
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        const editor = this.editor;
+        const model = editor.model;
+        if (!editor.plugins.has('FontColorEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        model.schema.extend('$listItem', {
+            allowAttributes: 'listItemFontColor'
+        });
+        model.schema.setAttributeProperties('listItemFontColor', {
+            isFormatting: true
+        });
+        model.schema.addAttributeCheck((context)=>{
+            const item = context.last;
+            if (!item.getAttribute('listItemId')) {
+                return false;
+            }
+        }, 'listItemFontColor');
+        editor.conversion.for('upcast').attributeToAttribute({
+            model: {
+                key: 'listItemFontColor',
+                value: (viewElement)=>{
+                    return viewElement.getStyle('--ck-content-list-marker-color');
+                }
+            },
+            view: {
+                name: 'li',
+                classes: 'ck-list-marker-color',
+                styles: {
+                    '--ck-content-list-marker-color': /.*/
+                }
+            }
+        });
+    }
+}
+
+/**
+ * The list item font family integration plugin.
+ */ class ListItemFontFamilyIntegration extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListItemFontFamilyIntegration';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListEditing
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ init() {
+        const editor = this.editor;
+        const ListFormatting = editor.plugins.get('ListFormatting');
+        const listEditing = editor.plugins.get(ListEditing);
+        if (!editor.plugins.has('FontFamilyEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        ListFormatting.registerFormatAttribute('fontFamily', 'listItemFontFamily');
+        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
+        // registers its converters.
+        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
+        listEditing.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemFontFamily',
+            setAttributeOnDowncast (writer, value, viewElement) {
+                // There is no need of removing the style because downcast strategies handles it automatically.
+                if (value) {
+                    writer.addClass('ck-list-marker-font-family', viewElement);
+                    writer.setStyle('--ck-content-list-marker-font-family', value, viewElement);
+                }
+            }
+        });
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        const editor = this.editor;
+        const model = editor.model;
+        if (!editor.plugins.has('FontFamilyEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        model.schema.extend('$listItem', {
+            allowAttributes: 'listItemFontFamily'
+        });
+        model.schema.setAttributeProperties('listItemFontFamily', {
+            isFormatting: true
+        });
+        model.schema.addAttributeCheck((context)=>{
+            const item = context.last;
+            if (!item.getAttribute('listItemId')) {
+                return false;
+            }
+        }, 'listItemFontFamily');
+        editor.conversion.for('upcast').attributeToAttribute({
+            model: {
+                key: 'listItemFontFamily',
+                value: (viewElement)=>{
+                    return viewElement.getStyle('--ck-content-list-marker-font-family');
+                }
+            },
+            view: {
+                name: 'li',
+                classes: 'ck-list-marker-font-family',
+                styles: {
+                    '--ck-content-list-marker-font-family': /.*/
+                }
+            }
+        });
+    }
+}
+
+/**
+ * The list formatting plugin.
+ *
+ * It enables integration with formatting plugins to style the list marker.
+ * The list marker is styled based on the consistent formatting applied to the content of the list item.
+ *
+ * The list of supported formatting plugins includes:
+ * * Font color.
+ * * Font size.
+ * * Font family.
+ * * Bold.
+ * * Italic.
+ */ class ListFormatting extends Plugin {
+    /**
+	 * The list of loaded formatting.
+	 */ _loadedFormatting = {};
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
+        return 'ListFormatting';
+    }
+    /**
+	 * @inheritDoc
+	 */ static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
+        return [
+            ListItemBoldIntegration,
+            ListItemItalicIntegration,
+            ListItemFontSizeIntegration,
+            ListItemFontColorIntegration,
+            ListItemFontFamilyIntegration
+        ];
+    }
+    /**
+	 * @inheritDoc
+	 */ constructor(editor){
+        super(editor);
+        editor.config.define('list.enableListItemMarkerFormatting', true);
+    }
+    /**
+	 * @inheritDoc
+	 */ afterInit() {
+        if (!this.editor.config.get('list.enableListItemMarkerFormatting')) {
+            return;
+        }
+        this._registerPostfixerForListItemFormatting();
+    }
+    /**
+	 * Registers a postfixer that ensures that the list item formatting attribute is consistent with the formatting
+	 * applied to the content of the list item.
+	 */ _registerPostfixerForListItemFormatting() {
+        const model = this.editor.model;
+        model.document.registerPostFixer((writer)=>{
+            const changes = model.document.differ.getChanges();
+            const modifiedListItems = new Set();
+            let returnValue = false;
+            for (const entry of changes){
+                if (entry.type === 'attribute') {
+                    if (entry.attributeKey == 'listItemId' || entry.attributeKey == 'listType' || this._isInlineOrSelectionFormatting(entry.attributeKey)) {
+                        if (isListItemBlock(entry.range.start.nodeAfter)) {
+                            modifiedListItems.add(entry.range.start.nodeAfter);
+                        } else if (isListItemBlock(entry.range.start.parent)) {
+                            modifiedListItems.add(entry.range.start.parent);
+                        }
+                    }
+                } else {
+                    if (isListItemBlock(entry.position.nodeAfter)) {
+                        modifiedListItems.add(entry.position.nodeAfter);
+                    }
+                    if (isListItemBlock(entry.position.nodeBefore)) {
+                        modifiedListItems.add(entry.position.nodeBefore);
+                    }
+                    if (isListItemBlock(entry.position.parent)) {
+                        modifiedListItems.add(entry.position.parent);
+                    }
+                    if (entry.type == 'insert' && entry.name != '$text') {
+                        const range = writer.createRangeIn(entry.position.nodeAfter);
+                        for (const item of range.getItems()){
+                            if (isListItemBlock(item)) {
+                                modifiedListItems.add(item);
+                            }
+                        }
+                    }
+                }
+            }
+            for (const listItem of modifiedListItems){
+                const formats = getListItemConsistentFormat(model, listItem, Object.keys(this._loadedFormatting));
+                for (const [formatAttributeName, formatValue] of Object.entries(formats)){
+                    const listItemFormatAttributeName = this._loadedFormatting[formatAttributeName];
+                    if (formatValue && setFormattingToListItem(writer, listItem, listItemFormatAttributeName, formatValue)) {
+                        returnValue = true;
+                    } else if (!formatValue && removeFormattingFromListItem(writer, listItem, listItemFormatAttributeName)) {
+                        returnValue = true;
+                    }
+                }
+            }
+            return returnValue;
+        });
+    }
+    /**
+	 * Registers an integration between a default attribute (e.g., `fontFamily`) and a new attribute
+	 * intended specifically for list item elements (e.g., `listItemFontFamily`).
+	 *
+	 * These attributes are later used by the postfixer logic to determine whether to add the new attribute
+	 * to the list item element, based on whether there is a consistent default formatting attribute
+	 * applied within its content.
+	 */ registerFormatAttribute(formatAttribute, listItemFormatAttribute) {
+        this._loadedFormatting[formatAttribute] = listItemFormatAttribute;
+    }
+    /**
+	 * Returns true if the given model attribute name is a supported inline formatting attribute.
+	 */ _isInlineOrSelectionFormatting(attributeKey) {
+        return attributeKey.replace(/^selection:/, '') in this._loadedFormatting;
+    }
+}
+/**
+ * Returns the consistent format of the list item element.
+ * If the list item contains multiple blocks, it checks only the first block.
+ */ function getListItemConsistentFormat(model, listItem, attributeKeys) {
+    if (isFirstBlockOfListItem(listItem)) {
+        return getSingleListItemConsistentFormat(model, listItem, attributeKeys);
+    }
+    // Always the first block of the list item should be checked for consistent formatting.
+    const listItemBlocks = getAllListItemBlocks(listItem);
+    return getSingleListItemConsistentFormat(model, listItemBlocks[0], attributeKeys);
+}
+/**
+ * Returns the consistent format of a single list item element.
+ */ function getSingleListItemConsistentFormat(model, listItem, attributeKeys) {
+    // Only bulleted and numbered lists can have formatting (to-do lists are not supported).
+    // Do not check internals of limit elements (for example, do not check table cells).
+    if (!isNumberedOrBulletedList(listItem) || model.schema.isLimit(listItem)) {
+        return Object.fromEntries(attributeKeys.map((attributeKey)=>[
+                attributeKey
+            ]));
+    }
+    if (listItem.isEmpty) {
+        return Object.fromEntries(attributeKeys.map((attributeKey)=>[
+                attributeKey,
+                listItem.getAttribute(`selection:${attributeKey}`)
+            ]));
+    }
+    const attributesToCheck = new Set(attributeKeys);
+    const valuesMap = {};
+    const range = model.createRangeIn(listItem);
+    const walker = range.getWalker({
+        ignoreElementEnd: true
+    });
+    for (const { item } of walker){
+        for (const attributeKey of attributesToCheck){
+            if (model.schema.checkAttribute(item, attributeKey)) {
+                const formatAttribute = item.getAttribute(attributeKey);
+                if (formatAttribute === undefined) {
+                    attributesToCheck.delete(attributeKey);
+                    valuesMap[attributeKey] = undefined;
+                } else if (valuesMap[attributeKey] === undefined) {
+                    // First item inside a list item block.
+                    valuesMap[attributeKey] = formatAttribute;
+                } else if (valuesMap[attributeKey] !== formatAttribute) {
+                    // Following items in the same block of a list item.
+                    attributesToCheck.delete(attributeKey);
+                    valuesMap[attributeKey] = undefined;
+                }
+            }
+        }
+        // End early if all attributes have been checked and are inconsistent.
+        if (!attributesToCheck.size) {
+            break;
+        }
+        // Jump over inline limit elements as we expect only outside them to be the same formatting.
+        if (model.schema.isLimit(item)) {
+            walker.jumpTo(model.createPositionAfter(item));
+        }
+    }
+    return valuesMap;
+}
+/**
+ * Adds the specified formatting attribute to the list item element.
+ */ function setFormattingToListItem(writer, listItem, attributeKey, attributeValue) {
+    // Multi-block items should have consistent formatting.
+    const listItemBlocks = getAllListItemBlocks(listItem);
+    let wasChanged = false;
+    for (const listItem of listItemBlocks){
+        if (!listItem.hasAttribute(attributeKey) || listItem.getAttribute(attributeKey) !== attributeValue) {
+            writer.setAttribute(attributeKey, attributeValue, listItem);
+            wasChanged = true;
+        }
+    }
+    return wasChanged;
+}
+/**
+ * Removes the specified formatting attribute from the list item element.
+ */ function removeFormattingFromListItem(writer, listItem, attributeKey) {
+    // Multi-block items should have consistent formatting.
+    const listItemBlocks = getAllListItemBlocks(listItem);
+    let wasChanged = false;
+    for (const listItem of listItemBlocks){
+        if (listItem.hasAttribute(attributeKey)) {
+            writer.removeAttribute(attributeKey, listItem);
+            wasChanged = true;
+        }
+    }
+    return wasChanged;
+}
+/**
+ * Checks if the given list type is a numbered or bulleted list.
+ */ function isNumberedOrBulletedList(listItem) {
+    return [
+        'numbered',
+        'bulleted',
+        'customNumbered',
+        'customBulleted'
+    ].includes(listItem.getAttribute('listType'));
+}
+
 /**
  * A set of helpers related to document lists.
  */ class ListUtils extends Plugin {
@@ -1460,7 +2104,10 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
         if (!items.length) {
             return;
         }
-        const listItemId = ListItemUid.next();
+        const listItemId = data.viewItem.getAttribute('data-list-item-id') || ListItemUid.next();
+        conversionApi.consumable.consume(data.viewItem, {
+            attributes: 'data-list-item-id'
+        });
         const listIndent = getIndent$1(data.viewItem);
         let listType = data.viewItem.parent && data.viewItem.parent.is('element', 'ol') ? 'numbered' : 'bulleted';
         // Preserve list type if was already set (for example by to-do list feature).
@@ -1668,11 +2315,13 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
             dataPipeline
         });
         // Then wrap them with the new list wrappers (UL, OL, LI).
-        wrapListItemBlock(listItem, viewRange, strategies, writer);
+        wrapListItemBlock(listItem, viewRange, strategies, writer, conversionApi.options);
     };
 }
 /**
  * The 'remove' downcast converter for custom markers.
+ *
+ * @internal
  */ function listItemDowncastRemoveConverter(schema) {
     return (evt, data, conversionApi)=>{
         const { writer, mapper } = conversionApi;
@@ -1737,6 +2386,8 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
 }
 /**
  * The model to view custom position mapping for cases when marker is injected at the beginning of a block.
+ *
+ * @internal
  */ function createModelToViewPositionMapper(strategies, view) {
     return (evt, data)=>{
         if (data.modelPosition.offset > 0) {
@@ -1754,7 +2405,7 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
         const viewWalker = viewRange.getWalker();
         let positionAfterLastMarker = viewRange.start;
         for (const { item } of viewWalker){
-            // Walk only over the non-mapped elements (UIElements, AttributeElements, $text, or any other element without mapping).
+            // Walk only over the non-mapped elements (UIElements, ViewAttributeElements, $text, or any other element without mapping).
             if (item.is('element') && data.mapper.toModelElement(item) || item.is('$textProxy')) {
                 break;
             }
@@ -1787,7 +2438,7 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
     }
     function collectMarkersToRemove(viewWalker) {
         for (const { item } of viewWalker){
-            // Walk only over the non-mapped elements (UIElements, AttributeElements, $text, or any other element without mapping).
+            // Walk only over the non-mapped elements (UIElements, ViewAttributeElements, $text, or any other element without mapping).
             if (item.is('element') && mapper.toModelElement(item)) {
                 break;
             }
@@ -1858,7 +2509,7 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
 }
 /**
  * Wraps the given list item with appropriate attribute elements for ul, ol, and li.
- */ function wrapListItemBlock(listItem, viewRange, strategies, writer) {
+ */ function wrapListItemBlock(listItem, viewRange, strategies, writer, options) {
     if (!listItem.hasAttribute('listIndent')) {
         return;
     }
@@ -1869,7 +2520,7 @@ import { DomEventObserver, Matcher, TreeWalker, getFillerOffset } from '@ckedito
         const listViewElement = createListElement(writer, indent, currentListItem.getAttribute('listType'));
         for (const strategy of strategies){
             if ((strategy.scope == 'list' || strategy.scope == 'item') && currentListItem.hasAttribute(strategy.attributeName)) {
-                strategy.setAttributeOnDowncast(writer, currentListItem.getAttribute(strategy.attributeName), strategy.scope == 'list' ? listViewElement : listItemViewElement);
+                strategy.setAttributeOnDowncast(writer, currentListItem.getAttribute(strategy.attributeName), strategy.scope == 'list' ? listViewElement : listItemViewElement, options);
             }
         }
         viewRange = writer.wrap(viewRange, listItemViewElement);
@@ -1952,7 +2603,8 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
             Enter,
             Delete,
             ListUtils,
-            ClipboardPipeline
+            ClipboardPipeline,
+            ListFormatting
         ];
     }
     /**
@@ -2023,6 +2675,7 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         this._setupTabIntegration();
         this._setupClipboardIntegration();
         this._setupAccessibilityIntegration();
+        this._setupListItemIdConversionStrategy();
     }
     /**
 	 * @inheritDoc
@@ -2068,7 +2721,7 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         ];
     }
     /**
-	 * Attaches the listener to the {@link module:engine/view/document~Document#event:delete} event and handles backspace/delete
+	 * Attaches the listener to the {@link module:engine/view/document~ViewDocument#event:delete} event and handles backspace/delete
 	 * keys in and around document lists.
 	 */ _setupDeleteIntegration() {
         const editor = this.editor;
@@ -2130,7 +2783,7 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         });
     }
     /**
-	 * Attaches a listener to the {@link module:engine/view/document~Document#event:enter} event and handles enter key press
+	 * Attaches a listener to the {@link module:engine/view/document~ViewDocument#event:enter} event and handles enter key press
 	 * in document lists.
 	 */ _setupEnterIntegration() {
         const editor = this.editor;
@@ -2188,7 +2841,7 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         });
     }
     /**
-	 * Attaches a listener to the {@link module:engine/view/document~Document#event:tab} event and handles tab key and tab+shift keys
+	 * Attaches a listener to the {@link module:engine/view/document~ViewDocument#event:tab} event and handles tab key and tab+shift keys
 	 * presses in document lists.
 	 */ _setupTabIntegration() {
         const editor = this.editor;
@@ -2389,6 +3042,20 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
             ]
         });
     }
+    /**
+	 * Convert `listItemId` attribute to `data-list-item-id` attribute on the view element in both downcast pipelines.
+	 */ _setupListItemIdConversionStrategy() {
+        this.registerDowncastStrategy({
+            scope: 'item',
+            attributeName: 'listItemId',
+            setAttributeOnDowncast (writer, attributeValue, viewElement, options) {
+                if (options && (options.skipListItemIds || options.isClipboardPipeline)) {
+                    return;
+                }
+                writer.setAttribute('data-list-item-id', attributeValue, viewElement);
+            }
+        });
+    }
 }
 /**
  * Post-fixer that reacts to changes on document and fixes incorrect model states (invalid `listItemId` and `listIndent` values).
@@ -2793,27 +3460,36 @@ for (const { listStyle, typeAttribute, listType } of LIST_STYLE_TYPES){
 }
 /**
  * Gets all the style types supported by given list type.
+ *
+ * @internal
  */ function getAllSupportedStyleTypes() {
     return LIST_STYLE_TYPES.map((x)=>x.listStyle);
 }
 /**
  * Checks whether the given list-style-type is supported by numbered or bulleted list.
+ *
+ * @internal
  */ function getListTypeFromListStyleType$1(listStyleType) {
     return LIST_STYLE_TO_LIST_TYPE[listStyleType] || null;
 }
 /**
  * Converts `type` attribute of `<ul>` or `<ol>` elements to `list-style-type` equivalent.
+ *
+ * @internal
  */ function getListStyleTypeFromTypeAttribute(value) {
     return TYPE_ATTRIBUTE_TO_LIST_STYLE[value] || null;
 }
 /**
  * Converts `list-style-type` style to `type` attribute of `<ul>` or `<ol>` elements.
+ *
+ * @internal
  */ function getTypeAttributeFromListStyleType(value) {
     return LIST_STYLE_TO_TYPE_ATTRIBUTE[value] || null;
 }
 /**
  * Normalizes list style by converting aliases to their canonical form.
  *
+ * @internal
  * @param listStyle The list style value to normalize.
  * @returns The canonical form of the list style.
  *
@@ -3069,6 +3745,7 @@ for (const { listStyle, typeAttribute, listType } of LIST_STYLE_TYPES){
  * }
  * ```
  *
+ * @internal
  * @param config The list properties {@link module:list/listconfig~ListPropertiesConfig config}.
  * @returns An object with normalized list properties options.
  */ function getNormalizedConfig(config) {
@@ -4099,7 +4776,7 @@ function getStyleTypeSupportChecker(listStyleCommand) {
         return selectedElements.every((element)=>element.getAttribute('todoListChecked'));
     }
     /**
-	 * Gets all to-do list items selected by the {@link module:engine/model/selection~Selection}.
+	 * Gets all to-do list items selected by the {@link module:engine/model/selection~ModelSelection}.
 	 */ _getSelectedItems() {
         const model = this.editor.model;
         const schema = model.schema;
@@ -4124,7 +4801,9 @@ function getStyleTypeSupportChecker(listStyleCommand) {
  * Observes all to-do list checkboxes state changes.
  *
  * Note that this observer is not available by default. To make it available it needs to be added to
- * {@link module:engine/view/view~View} by {@link module:engine/view/view~View#addObserver} method.
+ * {@link module:engine/view/view~EditingView} by {@link module:engine/view/view~EditingView#addObserver} method.
+ *
+ * @internal
  */ class TodoCheckboxChangeObserver extends DomEventObserver {
     /**
 	 * @inheritDoc
@@ -5024,8 +5703,9 @@ const ITEM_TOGGLE_KEYSTROKE$1 = /* #__PURE__ */ parseKeystroke('Ctrl+Enter');
 }
 
 /**
- * Creates a list item {@link module:engine/view/containerelement~ContainerElement}.
+ * Creates a list item {@link module:engine/view/containerelement~ViewContainerElement}.
  *
+ * @internal
  * @param writer The writer instance.
  */ function createViewListItemElement(writer) {
     const viewItem = writer.createContainerElement('li');
@@ -5037,6 +5717,7 @@ const ITEM_TOGGLE_KEYSTROKE$1 = /* #__PURE__ */ parseKeystroke('Ctrl+Enter');
  * Then, it binds the created view list item (`<li>`) with the model `listItem` element.
  * The function then returns the created view list item (`<li>`).
  *
+ * @internal
  * @param modelItem Model list item.
  * @param conversionApi Conversion interface.
  * @returns View list element.
@@ -5056,6 +5737,7 @@ const ITEM_TOGGLE_KEYSTROKE$1 = /* #__PURE__ */ parseKeystroke('Ctrl+Enter');
  * should be in a view list element (`<ul>` or `<ol>`) and should be its only child.
  * See comments below to better understand the algorithm.
  *
+ * @internal
  * @param modelItem Model list item.
  * @param injectedItem
  * @param conversionApi Conversion interface.
@@ -5165,6 +5847,7 @@ function mergeViewLists(viewWriter, firstList, secondList) {
  * `<container:p>foo^<ui:span></ui:span><ui:span></ui:span>bar</container:p>`
  * For position ^, the position before "bar" will be returned.
  *
+ * @internal
  */ function positionAfterUiElements(viewPosition) {
     return viewPosition.getLastMatchingPosition((value)=>value.item.is('uiElement'));
 }
@@ -5172,6 +5855,7 @@ function mergeViewLists(viewWriter, firstList, secondList) {
  * Helper function that searches for a previous list item sibling of a given model item that meets the given criteria
  * passed by the options object.
  *
+ * @internal
  * @param options Search criteria.
  * @param options.sameIndent Whether the sought sibling should have the same indentation.
  * @param options.smallerIndent Whether the sought sibling should have a smaller indentation.
@@ -5197,6 +5881,8 @@ function mergeViewLists(viewWriter, firstList, secondList) {
 }
 /**
  * Returns a first list view element that is direct child of the given view element.
+ *
+ * @internal
  */ function findNestedList(viewElement) {
     for (const node of viewElement.getChildren()){
         if (node.name == 'ul' || node.name == 'ol') {
@@ -5212,6 +5898,7 @@ function mergeViewLists(viewWriter, firstList, secondList) {
  *
  * Additionally, if the `position` is inside a list item, that list item will be returned as well.
  *
+ * @internal
  * @param position Starting position.
  * @param direction Walking direction.
  */ function getSiblingNodes(position, direction) {
@@ -5225,7 +5912,7 @@ function mergeViewLists(viewWriter, firstList, secondList) {
     };
     const limitIndent = listItem.getAttribute('listIndent');
     const nodes = [
-        ...new TreeWalker(walkerOptions)
+        ...new ModelTreeWalker(walkerOptions)
     ].filter((value)=>value.item.is('element')).map((value)=>value.item);
     for (const element of nodes){
         // If found something else than `listItem`, we're out of the list scope.
@@ -5331,6 +6018,8 @@ const NUMBERED_LIST_STYLE_TYPES = [
 ];
 /**
  * Checks whether the given list-style-type is supported by numbered or bulleted list.
+ *
+ * @internal
  */ function getListTypeFromListStyleType(listStyleType) {
     if (BULLETED_LIST_STYLE_TYPES.includes(listStyleType)) {
         return 'bulleted';
@@ -5349,7 +6038,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
     if (this.isEmpty || hasOnlyLists) {
         return 0;
     }
-    return getFillerOffset.call(this);
+    return getViewFillerOffset.call(this);
 }
 
 /**
@@ -5399,6 +6088,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * It creates a `<ul><li></li><ul>` (or `<ol>`) view structure out of a `listItem` model element, inserts it at the correct
  * position, and merges the list with surrounding lists (if available).
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
  * @param model Model instance.
  */ function modelViewInsertion$1(model) {
@@ -5418,6 +6108,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
 /**
  * A model-to-view converter for the `listItem` model element removal.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:remove
  * @param model Model instance.
  * @returns Returns a conversion callback.
@@ -5460,6 +6151,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * Splitting this conversion into 2 steps makes it possible to add an additional conversion in the middle.
  * Check {@link module:list/legacytodolist/legacytodolistconverters~modelViewChangeType} to see an example of it.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
  */ const modelViewChangeType$1 = (evt, data, conversionApi)=>{
     if (!conversionApi.consumable.test(data.item, evt.name)) {
@@ -5480,6 +6172,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
 /**
  * A model-to-view converter that attempts to merge nodes split by {@link module:list/legacylist/legacyconverters~modelViewChangeType}.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
  */ const modelViewMergeAfterChangeType = (evt, data, conversionApi)=>{
     conversionApi.consumable.consume(data.item, evt.name);
@@ -5493,6 +6186,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
 /**
  * A model-to-view converter for the `listIndent` attribute change on the `listItem` model element.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
  * @param model Model instance.
  * @returns Returns a conversion callback.
@@ -5546,6 +6240,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * <listItem>bar</listItem>         <ul><li>foo</li><p>xxx</p><li>bar</li></ul>
  * ```
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
  */ const modelViewSplitOnInsert = (evt, data, conversionApi)=>{
     if (!conversionApi.consumable.test(data.item, evt.name)) {
@@ -5657,6 +6352,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  *                                  </ul>
  * ```
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:remove
  */ const modelViewMergeAfter = (evt, data, conversionApi)=>{
     const viewPosition = conversionApi.mapper.toViewPosition(data.position);
@@ -5674,6 +6370,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * * checks `<li>`'s parent,
  * * stores and increases the `conversionApi.store.indent` value when `<li>`'s sub-items are converted.
  *
+ * @internal
  * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element
  */ const viewModelConverter = (evt, data, conversionApi)=>{
     if (conversionApi.consumable.consume(data.viewItem, {
@@ -5702,6 +6399,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * This is mostly to clean whitespaces from between the `<li>` view elements inside the view list element, however, also
  * incorrect data can be cleared if the view was incorrect.
  *
+ * @internal
  * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element
  */ const cleanList = (evt, data, conversionApi)=>{
     if (conversionApi.consumable.test(data.viewItem, {
@@ -5720,6 +6418,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
 /**
  * A view-to-model converter for the `<li>` elements that cleans whitespace formatting from the input view.
  *
+ * @internal
  * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element
  */ const cleanListItem = (evt, data, conversionApi)=>{
     if (conversionApi.consumable.test(data.viewItem, {
@@ -5747,6 +6446,8 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * Returns a callback for model position to view position mapping for {@link module:engine/conversion/mapper~Mapper}. The callback fixes
  * positions between the `listItem` elements that would be incorrectly mapped because of how list items are represented in the model
  * and in the view.
+ *
+ * @internal
  */ function modelToViewPosition(view) {
     return (evt, data)=>{
         if (data.isPhantom) {
@@ -5774,6 +6475,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * positions between the `<li>` elements that would be incorrectly mapped because of how list items are represented in the model
  * and in the view.
  *
+ * @internal
  * @see module:engine/conversion/mapper~Mapper#event:viewToModelPosition
  * @param model Model instance.
  * @returns Returns a conversion callback.
@@ -5843,6 +6545,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * <listItem listType="bulleted" listIndent=1>Item 3</listItem>   <--- note that indent got post-fixed.
  * ```
  *
+ * @internal
  * @param model The data model.
  * @param writer The writer to do changes with.
  * @returns `true` if any change has been applied, `false` otherwise.
@@ -5990,6 +6693,8 @@ const NUMBERED_LIST_STYLE_TYPES = [
  * <listItem listType="bulleted" listIndent=2>Y/listItem>
  * <listItem listType="bulleted" listIndent=2>C</listItem>
  * ```
+ *
+ * @internal
  */ const modelIndentPasteFixer = function(evt, [content, selectable]) {
     const model = this;
     // Check whether inserted content starts from a `listItem`. If it does not, it means that there are some other
@@ -6101,7 +6806,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
 /**
  * Helper function that seeks for a next list item starting from given `startPosition`.
  */ function findNextListItem(startPosition) {
-    const treeWalker = new TreeWalker({
+    const treeWalker = new ModelTreeWalker({
         startPosition
     });
     let value;
@@ -7327,7 +8032,7 @@ const attributeKey = 'todoListChecked';
  * the `checkTodoList` editor command and it is also available via aliased `todoListCheck` name.
  */ class LegacyCheckTodoListCommand extends Command {
     /**
-	 * A list of to-do list items selected by the {@link module:engine/model/selection~Selection}.
+	 * A list of to-do list items selected by the {@link module:engine/model/selection~ModelSelection}.
 	 *
 	 * @internal
 	 */ _selectedElements;
@@ -7352,7 +8057,7 @@ const attributeKey = 'todoListChecked';
         this.isEnabled = !!this._selectedElements.length;
     }
     /**
-	 * Gets all to-do list items selected by the {@link module:engine/model/selection~Selection}.
+	 * Gets all to-do list items selected by the {@link module:engine/model/selection~ModelSelection}.
 	 */ _getSelectedItems() {
         const model = this.editor.model;
         const schema = model.schema;
@@ -7392,11 +8097,12 @@ const attributeKey = 'todoListChecked';
 /**
  * A model-to-view converter for the `listItem` model element insertion.
  *
- * It converts the `listItem` model element to an unordered list with a {@link module:engine/view/uielement~UIElement checkbox element}
+ * It converts the `listItem` model element to an unordered list with a {@link module:engine/view/uielement~ViewUIElement checkbox element}
  * at the beginning of each list item. It also merges the list with surrounding lists (if available).
  *
  * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
  * @param model Model instance.
  * @param onCheckboxChecked Callback function.
@@ -7433,6 +8139,7 @@ const attributeKey = 'todoListChecked';
  *
  * It is used by {@link module:engine/controller/datacontroller~DataController}.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
  * @param model Model instance.
  * @returns Returns a conversion callback.
@@ -7480,6 +8187,7 @@ const attributeKey = 'todoListChecked';
  *
  * It is used by {@link module:engine/controller/datacontroller~DataController}.
  *
+ * @internal
  * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element
  */ const dataViewModelCheckmarkInsertion = (evt, data, conversionApi)=>{
     const modelCursor = data.modelCursor;
@@ -7504,7 +8212,7 @@ const attributeKey = 'todoListChecked';
  * A model-to-view converter for the `listType` attribute change on the `listItem` model element.
  *
  * This change means that the `<li>` element parent changes to `<ul class="todo-list">` and a
- * {@link module:engine/view/uielement~UIElement checkbox UI element} is added at the beginning
+ * {@link module:engine/view/uielement~ViewUIElement checkbox UI element} is added at the beginning
  * of the list item element (or vice versa).
  *
  * This converter is preceded by {@link module:list/legacylist/legacyconverters~modelViewChangeType} and followed by
@@ -7513,6 +8221,7 @@ const attributeKey = 'todoListChecked';
  *
  * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
  * @param onCheckedChange Callback fired after clicking the checkbox UI element.
  * @param view Editing view controller.
@@ -7552,10 +8261,11 @@ const attributeKey = 'todoListChecked';
 /**
  * A model-to-view converter for the `todoListChecked` attribute change on the `listItem` model element.
  *
- * It marks the {@link module:engine/view/uielement~UIElement checkbox UI element} as checked.
+ * It marks the {@link module:engine/view/uielement~ViewUIElement checkbox UI element} as checked.
  *
  * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
  *
+ * @internal
  * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
  * @param onCheckedChange Callback fired after clicking the checkbox UI element.
  * @returns Returns a conversion callback.
@@ -7585,6 +8295,8 @@ const attributeKey = 'todoListChecked';
  * This helper ensures that position inside todo-list in the view is mapped after the checkbox.
  *
  * It only handles the position at the beginning of a list item as other positions are properly mapped be the default mapper.
+ *
+ * @internal
  */ function mapModelToViewPosition(view) {
     return (evt, data)=>{
         const modelPosition = data.modelPosition;
@@ -7937,116 +8649,5 @@ class AdjacentListsSupport extends Plugin {
     };
 }
 
-/**
- * The document list feature.
- *
- * This is an obsolete plugin that exists for backward compatibility only.
- * Use the {@link module:list/list~List `List`} instead.
- *
- * @deprecated
- */ class DocumentList extends Plugin {
-    /**
-	 * @inheritDoc
-	 */ static get requires() {
-        return [
-            List
-        ];
-    }
-    /**
-	 * @inheritDoc
-	 */ static get pluginName() {
-        return 'DocumentList';
-    }
-    /**
-	 * @inheritDoc
-	 */ static get isOfficialPlugin() {
-        return true;
-    }
-    constructor(editor){
-        super(editor);
-        /**
-		 * The `DocumentList` plugin is obsolete. Use `List` instead.
-		 *
-		 * @error plugin-obsolete-documentlist
-		 */ logWarning('plugin-obsolete-documentlist', {
-            pluginName: 'DocumentList'
-        });
-    }
-}
-
-/**
- * The document list properties feature.
- *
- * This is an obsolete plugin that exists for backward compatibility only.
- * Use the {@link module:list/listproperties~ListProperties `ListProperties`} instead.
- *
- * @deprecated
- */ class DocumentListProperties extends Plugin {
-    /**
-	 * @inheritDoc
-	 */ static get requires() {
-        return [
-            ListProperties
-        ];
-    }
-    /**
-	 * @inheritDoc
-	 */ static get pluginName() {
-        return 'DocumentListProperties';
-    }
-    /**
-	 * @inheritDoc
-	 */ static get isOfficialPlugin() {
-        return true;
-    }
-    constructor(editor){
-        super(editor);
-        /**
-		 * The `DocumentListProperties` plugin is obsolete. Use `ListProperties` instead.
-		 *
-		 * @error plugin-obsolete-documentlistproperties
-		 */ logWarning('plugin-obsolete-documentlistproperties', {
-            pluginName: 'DocumentListProperties'
-        });
-    }
-}
-
-/**
- * The to-do list feature.
- *
- * This is an obsolete plugin that exists for backward compatibility only.
- * Use the {@link module:list/todolist~TodoList `TodoList`} instead.
- *
- * @deprecated
- */ class TodoDocumentList extends Plugin {
-    /**
-	 * @inheritDoc
-	 */ static get requires() {
-        return [
-            TodoList
-        ];
-    }
-    /**
-	 * @inheritDoc
-	 */ static get pluginName() {
-        return 'TodoDocumentList';
-    }
-    /**
-	 * @inheritDoc
-	 */ static get isOfficialPlugin() {
-        return true;
-    }
-    constructor(editor){
-        super(editor);
-        /**
-		 * The `TodoDocumentList` plugin is obsolete. Use `TodoList` instead.
-		 *
-		 * @error plugin-obsolete-tododocumentlist
-		 */ logWarning('plugin-obsolete-tododocumentlist', {
-            pluginName: 'TodoDocumentList'
-        });
-    }
-}
-
-export { AdjacentListsSupport, DocumentList, DocumentListProperties, LegacyIndentCommand, LegacyList, LegacyListEditing, LegacyListProperties, LegacyListPropertiesEditing, LegacyListUtils, LegacyTodoList, LegacyTodoListEditing, List, ListCommand, ListEditing, ListIndentCommand, ListProperties, ListPropertiesEditing, ListPropertiesUI, ListPropertiesUtils, ListUI, ListUtils, TodoDocumentList, TodoList, TodoListEditing, TodoListUI };
+export { AdjacentListsSupport, CheckTodoListCommand, LegacyCheckTodoListCommand, LegacyIndentCommand, LegacyList, LegacyListCommand, LegacyListEditing, LegacyListProperties, LegacyListPropertiesEditing, LegacyListReversedCommand, LegacyListStartCommand, LegacyListStyleCommand, LegacyListUtils, LegacyTodoList, LegacyTodoListEditing, List, ListCommand, ListEditing, ListFormatting, ListIndentCommand, ListItemBoldIntegration, ListItemFontColorIntegration, ListItemFontFamilyIntegration, ListItemFontSizeIntegration, ListItemItalicIntegration, ListMergeCommand, ListProperties, ListPropertiesEditing, ListPropertiesUI, ListPropertiesUtils, ListReversedCommand, ListSplitCommand, ListStartCommand, ListStyleCommand, ListUI, ListUtils, TodoList, TodoListEditing, TodoListUI, ListBlocksIterable as _ListBlocksIterable, ListPropertiesView as _ListPropertiesView, ListWalker as _ListWalker, SiblingListBlocksIterator as _SiblingListBlocksIterator, TodoCheckboxChangeObserver as _TodoCheckboxChangeObserver, canBecomeSimpleListItem as _canBecomeSimpleListItem, createListElement as _createListElement, createListItemElement as _createListItemElement, createUIComponents as _createListUIComponents, createModelToViewPositionMapper as _createModelToViewListPositionMapper, expandListBlocksToCompleteItems as _expandListBlocksToCompleteItems, expandListBlocksToCompleteList as _expandListBlocksToCompleteList, findAndAddListHeadToMap as _findAndAddListHeadToMap, findMappedViewElement as _findMappedListItemViewElement, fixListIndents as _fixListIndents, fixListItemIds as _fixListItemIds, getAllListItemBlocks as _getAllListItemBlocks, getAllSupportedStyleTypes as _getAllSupportedListStyleTypes, getIndent$1 as _getListIndent, getListItemBlocks as _getListItemBlocks, getListItems as _getListItems, getListStyleTypeFromTypeAttribute as _getListStyleTypeFromTypeAttribute, getListTypeFromListStyleType$1 as _getListTypeFromListStyleType, getNestedListBlocks as _getNestedListBlocks, getNormalizedConfig as _getNormalizedListConfig, getSelectedBlockObject as _getSelectedBlockObject, getTypeAttributeFromListStyleType as _getTypeAttributeFromListStyleType, getViewElementIdForListType as _getViewElementIdForListType, getViewElementNameForListType as _getViewElementNameForListType, indentBlocks as _indentListBlocks, isFirstBlockOfListItem as _isFirstBlockOfListItem, isLastBlockOfListItem as _isLastBlockOfListItem, isListItemBlock as _isListItemBlock, isListItemView as _isListItemView, isListView as _isListView, isNumberedListType as _isNumberedListType, isSingleListItem as _isSingleListItem, bogusParagraphCreator as _listItemBogusParagraphCreator, listItemDowncastConverter as _listItemDowncastConverter, listItemDowncastRemoveConverter as _listItemDowncastRemoveConverter, listItemUpcastConverter as _listItemUpcastConverter, listPropertiesUpcastConverter as _listPropertiesUpcastConverter, mergeListItemBefore as _mergeListItemBefore, normalizeListStyle as _normalizeListStyle, outdentFollowingItems as _outdentFollowingListItems, outdentBlocksWithMerge as _outdentListBlocksWithMerge, reconvertItemsOnDataChange as _reconvertListItemsOnDataChange, removeListAttributes as _removeListAttributes, sortBlocks as _sortListBlocks, splitListItemBefore as _splitListItemBefore };
 //# sourceMappingURL=index.js.map