@ckeditor/ckeditor5-list 48.1.1 → 48.2.0-alpha.0

package/ckeditor5-metadata.json

@@ -120,6 +120,12 @@
 				},
 				{
 					"elements": "li"
+				},
+				{
+					"elements": "li",
+					"styles": "list-style-type",
+					"isAlternative": true,
+					"_comment": "If `config.list.enableSkipLevelLists` is set to `true`, intermediate `<li>` wrappers with `list-style-type: none` are emitted to bridge missing indent levels."
 				}
 			]
 		},

package/dist/index.js

@@ -476,7 +476,11 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
             continue;
         }
         // Merge with parent list item while outdenting and indent matches reference indent.
-        if (block.getAttribute('listIndent') == referenceIndent) {
+        // The parent block may be null if the block has no ancestor with a lower indent (e.g. when skip-level
+        // lists are enabled and the first item starts at indent > 0). In that case, skip the merge and just
+        // decrease the indent. Without skip-level lists, the post-fixer guarantees sequential indents, so
+        // a parent with a lower indent always exists and this guard has no effect.
+        if (block.getAttribute('listIndent') == referenceIndent && parentBlocks.get(block)) {
             const mergedBlocks = mergeListItemIfNotLast(block, parentBlocks.get(block), writer);
             // All list item blocks are updated while merging so add those to visited set.
             for (const mergedBlock of mergedBlocks){
@@ -655,16 +659,65 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
     return listType == 'numbered' || listType == 'customNumbered';
 }
 /**
- * Checks if the given list item is the first item in the list.
+ * Checks if the given list item block is the first block of the first item in its list at the given indent.
  *
- * This function checks if there's any other list item before the given list item
- * at the same indent level with the same list type.
+ * Walks back over previous siblings and returns:
+ * - `true` if it reaches a non-list block or a list block at a lower indent (a new list begins here),
+ * - `false` if it finds a same-indent block of the same `listItemId` (a continuation of the current item) or of the same
+ *   `listType` (the visible list already has earlier items),
+ * - `true` if it finds a same-indent block of a different `listType` and a different `listItemId` (a different list ends; ours
+ *   starts here),
+ * - `false` if the loop ends (it reaches the first non-list-item block, or no more previous siblings) while passing only
+ *   higher-indent blocks (those blocks live inside an intermediate skip-level `<li style="list-style-type:none">` wrapper
+ *   at our indent).
+ *
+ * For example, in the model:
+ *
+ * ```
+ * '  # aaa'
+ * '# bbb'
+ * ```
+ *
+ * `bbb` is preceded by a higher-indent block `aaa`, which in the view is rendered inside an intermediate
+ * skip-level wrapper at indent 0:
+ *
+ * ```html
+ * <ol>
+ *   <li style="list-style-type:none">
+ *     <ol>
+ *       <li>aaa</li>
+ *     </ol>
+ *   </li>
+ *   <li>bbb</li>
+ * </ol>
+ * ```
+ *
+ * So `bbb` is the second visible item in the outer list and the function returns `false`.
  */ function isFirstListItemInList(listItem) {
-    const previousItem = ListWalker.first(listItem, {
-        sameIndent: true,
-        sameAttributes: 'listType'
-    });
-    return !previousItem;
+    const itemIndent = listItem.getAttribute('listIndent');
+    const itemListType = listItem.getAttribute('listType');
+    const itemListItemId = listItem.getAttribute('listItemId');
+    let previous = listItem.previousSibling;
+    let sawHigherIndent = false;
+    while(isListItemBlock(previous)){
+        const previousIndent = previous.getAttribute('listIndent');
+        if (previousIndent < itemIndent) {
+            return true;
+        }
+        if (previousIndent === itemIndent) {
+            // The previous block belongs to the current item — we are a continuation block, not the first block of
+            // the list item, so item-block indent should not apply (a normal list indent should fall through instead).
+            if (previous.getAttribute('listItemId') === itemListItemId) {
+                return false;
+            }
+            return previous.getAttribute('listType') !== itemListType;
+        }
+        sawHigherIndent = true;
+        previous = previous.previousSibling;
+    }
+    // Reached the first non-list-item block (or no more previous siblings). If only higher-indent blocks were on
+    // the way, they live inside an intermediate skip-level wrapper at our indent — we are not first.
+    return !sawHigherIndent;
 }
 /**
  * Merges a given block to the given parent block if parent is a list item and there is no more blocks in the same item.
@@ -788,6 +841,10 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
         if (isSingleListItem(blocks) && !isFirstBlockOfListItem(blocks[0])) {
             return true;
         }
+        // When skip levels are allowed, any list item can always be indented further.
+        if (this.editor.config.get('list.enableSkipLevelLists')) {
+            return true;
+        }
         blocks = expandListBlocksToCompleteItems(blocks);
         firstBlock = blocks[0];
         // Check if there is any list item before selected items that could become a parent of selected items.
@@ -1011,6 +1068,12 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
         const attributeNames = listEditing.getListAttributeNames();
         model.change((writer)=>{
             const { firstElement, lastElement } = this._getMergeSubjectElements(selection, shouldMergeOnBlocksContentLevel);
+            // A defensive guard. When `_getMergeSubjectElements()` cannot determine a valid pair of elements
+            // to merge (for example because there is no list block before/after the current one),
+            // the command should be a no-op instead of throwing on `null.getAttribute()`.
+            if (!firstElement || !lastElement) {
+                return;
+            }
             const firstIndent = firstElement.getAttribute('listIndent') || 0;
             const lastIndent = lastElement.getAttribute('listIndent');
             const lastElementId = lastElement.getAttribute('listItemId');
@@ -1123,6 +1186,11 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
                         sameIndent: true,
                         lowerIndent: true
                     });
+                    // Fallback for "skip-level" structures where the previous list block in the model
+                    // happens to live at a *higher* indent (no same-or-lower-indent block precedes it).
+                    if (!firstElement && isListItemBlock(positionParent.previousSibling)) {
+                        firstElement = positionParent.previousSibling;
+                    }
                 } else {
                     firstElement = positionParent.previousSibling;
                 }
@@ -2139,6 +2207,55 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
     return applied;
 }
 
+/**
+ * Returns a consuming upcast converter for skip-level list item wrappers. It detects intermediate `<li>` elements
+ * with `list-style-type:none` (generated by the skip-level downcast or by external sources) and consumes them
+ * without producing a model element, so they don't end up as empty list items in the model.
+ *
+ * The wrapper `<li>` is consumed, but its children (nested lists) are converted normally. Because `getIndent()`
+ * counts all ancestor `<li>` elements (including the consumed wrapper), nested items receive the correct indent
+ * values that reflect the skip-level gap.
+ *
+ * Only `<li>` elements whose sole meaningful content is a nested `<ul>`/`<ol>` are treated as intermediate wrappers.
+ * Anything else (text, paragraphs, custom elements, even an empty `<li>` with `list-style-type:none` carrying only
+ * attributes) falls through to the regular list item upcast, so its data and attributes can be preserved by GHS
+ * or other plugins.
+ *
+ * @internal
+ */ function listItemSkipLevelConsumer() {
+    return (evt, data, conversionApi)=>{
+        const viewItem = data.viewItem;
+        if (viewItem.getStyle('list-style-type') !== 'none') {
+            return;
+        }
+        if (!isSkipLevelWrapper(viewItem)) {
+            return;
+        }
+        if (!conversionApi.consumable.consume(viewItem, {
+            name: true
+        })) {
+            return;
+        }
+        const { modelRange, modelCursor } = conversionApi.convertChildren(viewItem, data.modelCursor);
+        data.modelRange = modelRange;
+        data.modelCursor = modelCursor;
+    };
+}
+/**
+ * Checks whether a `<li>` view element is a skip-level intermediate wrapper, i.e. its only child is a nested
+ * `<ul>`/`<ol>`. Any other content (text, `<br>`, `<p>`, custom elements, NBSP, etc.) disqualifies the element,
+ * so it is upcast as a regular list item.
+ */ function isSkipLevelWrapper(viewItem) {
+    let hasNestedList = false;
+    for (const child of viewItem.getChildren()){
+        if (child.is('element', 'ul') || child.is('element', 'ol')) {
+            hasNestedList = true;
+            continue;
+        }
+        return false;
+    }
+    return hasNestedList;
+}
 /**
  * Returns the upcast converter for list items. It's supposed to work after the block converters (content inside list items) are converted.
  *
@@ -2155,6 +2272,11 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
         if (!items.length) {
             return;
         }
+        // All items already have list attributes set by a recursive conversion (e.g. children of a skip-level
+        // wrapper <li> that was consumed without creating a model element). Nothing left to do here.
+        if (items.every((item)=>item.hasAttribute('listItemId'))) {
+            return;
+        }
         const listItemId = data.viewItem.getAttribute('data-list-item-id') || ListItemUid.next();
         conversionApi.consumable.consume(data.viewItem, {
             attributes: 'data-list-item-id'
@@ -2263,9 +2385,10 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
             }
             // Update the stack for the current indent level.
             stack[itemIndent] = {
-                modelAttributes: Object.fromEntries(Array.from(node.getAttributes()).filter(([key])=>attributeNames.includes(key))),
+                modelAttributes: getListModelAttributes(node),
                 modelElement: node
             };
+            fillStackForIntermediates(node, itemIndent, stack);
             // Find all blocks of the current node.
             const blocks = getListItemBlocks(node, {
                 direction: 'forward'
@@ -2282,6 +2405,42 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
         }
         return itemsToRefresh;
     }
+    // Returns model list attributes (those tracked by `attributeNames`) of the given item as a plain object.
+    function getListModelAttributes(item) {
+        return Object.fromEntries(Array.from(item.getAttributes()).filter(([key])=>attributeNames.includes(key)));
+    }
+    // Skip-level lists have view wrappers (<ol>/<ul>) at indent levels with no matching
+    // model item. Each such wrapper inherits its attributes (listStart, listStyle, etc.)
+    // from a nearby model item - the first sibling found at that indent, or the closest
+    // lower-indent ancestor (mirroring the downcast's fallback). Remember that item here
+    // so later we can compare the wrapper against the current model and tell whether it's
+    // still up to date.
+    function fillStackForIntermediates(node, itemIndent, stack) {
+        for(let i = itemIndent - 1; i >= 0; i--){
+            if (stack[i]) {
+                break;
+            }
+            const siblingAtIndent = findSiblingListItemAt(node, i);
+            let ancestorAtLowerIndent = null;
+            if (!siblingAtIndent) {
+                for(let k = i - 1; k >= 0; k--){
+                    if (stack[k]) {
+                        ancestorAtLowerIndent = stack[k].modelElement;
+                        break;
+                    }
+                }
+            }
+            const referenceItem = siblingAtIndent || ancestorAtLowerIndent || node;
+            stack[i] = {
+                modelAttributes: {
+                    ...getListModelAttributes(referenceItem),
+                    listItemId: `list-item-skip-${i}`,
+                    listIndent: i
+                },
+                modelElement: referenceItem
+            };
+        }
+    }
     function doesItemBlockRequiresRefresh(item, blocks) {
         const viewElement = editing.mapper.toViewElement(item);
         if (!viewElement) {
@@ -2338,14 +2497,20 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
             if (!isListElement && !isListItemElement) {
                 continue;
             }
-            const eventName = `checkAttributes:${isListItemElement ? 'item' : 'list'}`;
-            const needsRefresh = listEditing.fire(eventName, {
-                viewElement: element,
-                modelAttributes: stack[indent].modelAttributes,
-                modelReferenceElement: stack[indent].modelElement
-            });
-            if (needsRefresh) {
-                break;
+            // The stack is indexed by listIndent, so with skip-level lists it may have empty slots
+            // for skipped indent levels. Skip attribute checking for those but still track the indent
+            // level below. Without skip-level lists, the post-fixer ensures sequential indents, so the
+            // stack is always fully populated and this guard has no effect.
+            if (stack[indent]) {
+                const eventName = `checkAttributes:${isListItemElement ? 'item' : 'list'}`;
+                const needsRefresh = listEditing.fire(eventName, {
+                    viewElement: element,
+                    modelAttributes: stack[indent].modelAttributes,
+                    modelReferenceElement: stack[indent].modelElement
+                });
+                if (needsRefresh) {
+                    break;
+                }
             }
             if (isListElement) {
                 indent--;
@@ -2365,7 +2530,7 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
  * @param attributeNames A list of attribute names that should be converted if they are set.
  * @param strategies The strategies.
  * @param model The model.
- */ function listItemDowncastConverter(attributeNames, strategies, model, { dataPipeline } = {}) {
+ */ function listItemDowncastConverter(attributeNames, strategies, model, { dataPipeline, enableSkipLevelLists }) {
     const consumer = createAttributesConsumer(attributeNames, strategies);
     return (evt, data, conversionApi)=>{
         const { writer, mapper, consumable } = conversionApi;
@@ -2379,7 +2544,8 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
         }
         const options = {
             ...conversionApi.options,
-            dataPipeline
+            dataPipeline,
+            enableSkipLevelLists
         };
         // Use positions mapping instead of mapper.toViewElement( listItem ) to find outermost view element.
         // This is for cases when mapping is using inner view element like in the code blocks (pre > code).
@@ -2593,35 +2759,109 @@ import { DomEventObserver, Matcher, ModelTreeWalker, getViewFillerOffset } from
 }
 /**
  * Wraps the given list item with appropriate attribute elements for ul, ol, and li.
+ *
+ * For skip-level lists (where indent gaps exist, e.g. indent 0 → indent 2), this function
+ * generates intermediate wrapper pairs (ul/ol + li) at each missing level. These intermediate
+ * wrappers are invisible (`list-style-type: none` on the li). Scope `'list'` strategies are
+ * applied so the wrapper element (ul/ol) carries the same classes and styles as real list
+ * wrappers, while scope `'item'` strategies are skipped since there is no model element
+ * backing the intermediate level.
  */ function wrapListItemBlock(listItem, viewRange, strategies, writer, options) {
     if (!listItem.hasAttribute('listIndent')) {
         return;
     }
     const listItemIndent = listItem.getAttribute('listIndent');
+    const enableSkipLevelLists = options.enableSkipLevelLists;
     let currentListItem = listItem;
     for(let indent = listItemIndent; indent >= 0; indent--){
-        const listItemViewElement = createListItemElement(writer, indent, currentListItem.getAttribute('listItemId'));
-        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, options, currentListItem);
+        // When ListWalker jumps over indent levels (e.g. from indent 2 to indent 0, either because
+        // enableSkipLevelLists is enabled or because the item is at the start of a fragment and its
+        // nearest ancestor is further up), the levels in between have no corresponding model element.
+        // We detect these "intermediate" levels by checking if currentListItem's indent doesn't match
+        // the current loop indent. Handling this regardless of the enableSkipLevelLists config makes the
+        // downcast resilient to unexpected skip-level states in the model.
+        const isIntermediate = currentListItem.getAttribute('listIndent') !== indent;
+        if (isIntermediate) {
+            // Intermediate levels get invisible wrappers: list-style-type:none hides the marker on <li>,
+            // and scope:'item' strategies are not applied (no data-list-item-id, etc.) since there is no
+            // model element backing this level.
+            //
+            // The <li> uses a fixed ID per indent (`list-item-skip-N`) so that sibling items sharing
+            // the same skipped level merge into one <li> (e.g. two items at indent 1 with no parent
+            // at indent 0 share one intermediate <li> at indent 0).
+            //
+            // The <ul/ol> type is chosen to ensure correct merging at this indent:
+            // - If a real list item exists at this indent (found by walking forward), use its type
+            //   so the intermediate wrapper merges with that item's real wrapper.
+            // - Otherwise, use the ancestor's type so all intermediates at this indent share the
+            //   same type and merge with each other.
+            const siblingAtIndent = findSiblingListItemAt(listItem, indent);
+            const referenceItem = siblingAtIndent || currentListItem;
+            const listType = referenceItem.getAttribute('listType');
+            const listItemViewElement = createListItemElement(writer, indent, `list-item-skip-${indent}`);
+            const listViewElement = createListElement(writer, indent, listType);
+            writer.setStyle('list-style-type', 'none', listItemViewElement);
+            // Apply scope:'list' strategies so that intermediate <ol>/<ul> wrappers carry the same
+            // classes and styles as real list wrappers (e.g. multi-level-list class, todo-list class,
+            // list-style-type:none). Without this, intermediate and real list elements at the same
+            // indent would have mismatched attributes and could not merge correctly, causing browsers
+            // to render unwanted default markers.
+            //
+            // Use the reference item (sibling or ancestor) as the strategy source so the attributes
+            // match whatever this intermediate is supposed to merge with.
+            for (const strategy of strategies){
+                if (strategy.scope == 'list' && referenceItem.hasAttribute(strategy.attributeName)) {
+                    strategy.setAttributeOnDowncast(writer, referenceItem.getAttribute(strategy.attributeName), listViewElement, options, referenceItem);
+                }
+            }
+            viewRange = writer.wrap(viewRange, listItemViewElement);
+            viewRange = writer.wrap(viewRange, listViewElement);
+        } else {
+            const listItemViewElement = createListItemElement(writer, indent, currentListItem.getAttribute('listItemId'));
+            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, options, currentListItem);
+                }
             }
+            viewRange = writer.wrap(viewRange, listItemViewElement);
+            viewRange = writer.wrap(viewRange, listViewElement);
         }
-        viewRange = writer.wrap(viewRange, listItemViewElement);
-        viewRange = writer.wrap(viewRange, listViewElement);
         if (indent == 0) {
             break;
         }
-        currentListItem = ListWalker.first(currentListItem, {
-            lowerIndent: true
-        });
-        // There is no list item with lower indent, this means this is a document fragment containing
-        // only a part of nested list (like copy to clipboard) so we don't need to try to wrap it further.
-        if (!currentListItem) {
-            break;
+        // Only look for a parent when at a real (non-intermediate) level. At intermediate levels
+        // currentListItem already points to the nearest found ancestor and won't change.
+        if (!isIntermediate) {
+            const nextListItem = ListWalker.first(currentListItem, {
+                lowerIndent: true
+            });
+            if (nextListItem) {
+                currentListItem = nextListItem;
+            } else if (!enableSkipLevelLists) {
+                break;
+            }
         }
     }
 }
+/**
+ * Walks forward from the given list item through model siblings to find the first list item block
+ * at exactly the specified indent level. Stops when it encounters a non-list block or a list item
+ * at a lower indent (which means we left the current subtree).
+ */ function findSiblingListItemAt(listItem, targetIndent) {
+    let node = listItem.nextSibling;
+    while(node && isListItemBlock(node)){
+        const indent = node.getAttribute('listIndent');
+        if (indent < targetIndent) {
+            return null;
+        }
+        if (indent === targetIndent) {
+            return node;
+        }
+        node = node.nextSibling;
+    }
+    return null;
+}
 // Returns the function that is responsible for consuming attributes that are set on the model node.
 function createAttributesConsumer(attributeNames, strategies) {
     const nonConsumingAttributes = strategies.filter((strategy)=>strategy.consume === false).map((strategy)=>strategy.attributeName);
@@ -2951,6 +3191,7 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         const attributeNames = this.getListAttributeNames();
         const multiBlock = editor.config.get('list.multiBlock');
         const elementName = multiBlock ? 'paragraph' : 'listItem';
+        const enableSkipLevelLists = !!editor.config.get('list.enableSkipLevelLists');
         editor.conversion.for('upcast')// Convert <li> to a generic paragraph (or listItem element) so the content of <li> is always inside a block.
         // Setting the listType attribute to let other features (to-do list) know that this is part of a list item.
         // This is also important to properly handle simple lists so that paragraphs inside a list item won't break the list item.
@@ -2978,6 +3219,60 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
             },
             converterPriority: 'high'
         }).add((dispatcher)=>{
+            // A `<p>` that is the only `<p>` child of its `<li>` and carries no own attributes is
+            // a bogus wrapper around the list item's content. Consume its name and convert its
+            // children directly into the surrounding `<li>`'s paragraph instead of letting
+            // `elementToElement('p')` above create a separate paragraph and force an autobreak.
+            // Otherwise we would end up with two paragraphs (one of them empty), instead of one paragraph with content.
+            dispatcher.on('element:p', (evt, data, conversionApi)=>{
+                const viewElement = data.viewItem;
+                if (!viewElement.parent || !viewElement.parent.is('element', 'li')) {
+                    return;
+                }
+                // Empty <p> (truly empty, e.g. `<li><p></p></li>`) must go through the standard
+                // `elementToElement('p')` path so the EmptyBlock upcast (priority 'lowest') takes care of it.
+                if (viewElement.isEmpty) {
+                    return;
+                }
+                // Bogus only when `<p>` carries no own attributes.
+                if (!viewElement.getAttributeKeys().next().done) {
+                    return;
+                }
+                // And the surrounding <li> has no other block-level content besides nested lists
+                // (any text or non-list element sibling means a multi-block list item where this
+                // <p> must keep its own paragraph in the model).
+                for (const sibling of viewElement.parent.getChildren()){
+                    if (sibling === viewElement) {
+                        continue;
+                    }
+                    if (sibling.is('element', 'ol') || sibling.is('element', 'ul')) {
+                        continue;
+                    }
+                    return;
+                }
+                // Mark the <p> as consumed so the lower-priority `elementToElement('p')` (and the
+                // Paragraph plugin's default `<p>` converter) skip it — otherwise they would
+                // create a separate model paragraph and trigger the auto-break empty paragraph
+                // we are working around.
+                conversionApi.consumable.consume(viewElement, {
+                    name: true
+                });
+                const { modelRange, modelCursor } = conversionApi.convertChildren(viewElement, data.modelCursor);
+                data.modelRange = modelRange;
+                data.modelCursor = modelCursor;
+            }, {
+                priority: 'highest'
+            });
+            if (enableSkipLevelLists) {
+                // A consuming converter for intermediate `<li>` wrappers produced by the skip-level downcast
+                // (or by external sources). It is registered with 'high' priority so it reliably runs before
+                // any other `element:li` upcast converter. Registration order inside this `.add()` is already
+                // enough for our own converters, but `high` guards against other plugins that may attach their
+                // own `element:li` listeners at the default priority in a separate `.add()` block.
+                dispatcher.on('element:li', listItemSkipLevelConsumer(), {
+                    priority: 'high'
+                });
+            }
             dispatcher.on('element:li', listItemUpcastConverter());
         });
         if (!multiBlock) {
@@ -2991,7 +3286,9 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
             view: bogusParagraphCreator(attributeNames),
             converterPriority: 'high'
         }).add((dispatcher)=>{
-            dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model));
+            dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model, {
+                enableSkipLevelLists
+            }));
             dispatcher.on('remove', listItemDowncastRemoveConverter(model.schema));
         });
         editor.conversion.for('dataDowncast').elementToElement({
@@ -3002,7 +3299,8 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
             converterPriority: 'high'
         }).add((dispatcher)=>{
             dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model, {
-                dataPipeline: true
+                dataPipeline: true,
+                enableSkipLevelLists
             }));
         });
         const modelToViewPositionMapper = createModelToViewPositionMapper(this._downcastStrategies, editor.editing.view);
@@ -3035,12 +3333,14 @@ function shouldUseBogusParagraph(item, attributeNames, blocks = getAllListItemBl
         // First the low level handler.
         model.document.registerPostFixer((writer)=>modelChangePostFixer$1(model, writer, attributeNames, this));
         // Then the callbacks for the specific lists.
-        // The indentation fixing must be the first one...
-        this.on('postFixer', (evt, { listNodes, writer })=>{
-            evt.return = fixListIndents(listNodes, writer) || evt.return;
-        }, {
-            priority: 'high'
-        });
+        // The indentation fixing must be the first one (but only when skip levels are not allowed)...
+        if (!this.editor.config.get('list.enableSkipLevelLists')) {
+            this.on('postFixer', (evt, { listNodes, writer })=>{
+                evt.return = fixListIndents(listNodes, writer) || evt.return;
+            }, {
+                priority: 'high'
+            });
+        }
         // ...then the item ids... and after that other fixers that rely on the correct indentation and ids.
         this.on('postFixer', (evt, { listNodes, writer, seenIds })=>{
             evt.return = fixListItemIds(listNodes, seenIds, writer) || evt.return;
@@ -4651,7 +4951,8 @@ const DEFAULT_LIST_TYPE$1 = 'default';
             dropdownView.panelView.children.add(listPropertiesView);
         });
         // Focus the editable after executing the command.
-        // Overrides a default behaviour where the focus is moved to the dropdown button (#12125).
+        // Overrides a default behaviour where the focus is moved to the dropdown button.
+        // See https://github.com/ckeditor/ckeditor5/issues/12125.
         dropdownView.on('execute', ()=>{
             editor.editing.view.focus();
         });
@@ -6743,7 +7044,7 @@ const NUMBERED_LIST_STYLE_TYPES = [
             if (itemToListHead.has(listHead)) {
                 return;
             }
-            for(// Cache previousSibling and reuse for performance reasons. See #6581.
+            for(// Cache previousSibling and reuse for performance reasons. See https://github.com/ckeditor/ckeditor5/issues/6581.
             let previousSibling = listHead.previousSibling; previousSibling && previousSibling.is('element', 'listItem'); previousSibling = listHead.previousSibling){
                 listHead = previousSibling;
                 if (itemToListHead.has(listHead)) {
@@ -7611,7 +7912,8 @@ const DEFAULT_LIST_TYPE = 'default';
                 listIndent: nextSibling.getAttribute('listIndent')
             });
             // The outermost list item may not exist while removing elements between lists with different value
-            // of the `listIndent` attribute. In such a case we don't want to update anything. See: #8073.
+            // of the `listIndent` attribute. In such a case we don't want to update anything.
+            // See: https://github.com/ckeditor/ckeditor5/issues/8073.
             if (!mostOuterItemList) {
                 return;
             }
@@ -7640,7 +7942,7 @@ const DEFAULT_LIST_TYPE = 'default';
                     direction: 'forward'
                 });
                 // If the selection ends in a non-list element, there are no <listItem>s that would require adjustments.
-                // See: #8642.
+                // See: https://github.com/ckeditor/ckeditor5/issues/8642.
                 if (!secondListMostOuterItem) {
                     firstMostOuterItem = null;
                     return;
@@ -7976,7 +8278,8 @@ const DEFAULT_LIST_TYPE = 'default';
                 // ■ Paragraph[]  // <-- The inserted item.
                 while(existingListItem.is('element', 'listItem') && existingListItem.getAttribute('listIndent') !== indent){
                     existingListItem = existingListItem.previousSibling;
-                    // If the item does not exist, most probably there is no other content in the editor. See: #8072.
+                    // If the item does not exist, most probably there is no other content in the editor.
+                    // See: https://github.com/ckeditor/ckeditor5/issues/8072.
                     if (!existingListItem) {
                         break;
                     }
@@ -7999,7 +8302,7 @@ const DEFAULT_LIST_TYPE = 'default';
                     wasFixed = true;
                 } else {
                     // Adjust the `listStyle`, `listReversed` and `listStart`
-                    // attributes for inserted (pasted) items. See #8160.
+                    // attributes for inserted (pasted) items. See https://github.com/ckeditor/ckeditor5/issues/8160.
                     //
                     // ■ List item 1. // [listStyle="square", listType="bulleted"]
                     //     ○ List item 1.1. // [listStyle="circle", listType="bulleted"]