@limetech/lime-elements 39.44.5 → 39.45.0

package/dist/cjs/limel-prosemirror-adapter.cjs.entry.js

@@ -2,7 +2,7 @@
 
 var index$1 = require('./index-DYg_7kkT.js');
 var types = require('./types-C7gNcwzE.js');
-var markdownParser = require('./markdown-parser-ChnRAxpZ.js');
+var markdownParser = require('./markdown-parser-YH5HSSgF.js');
 var cloneDeep = require('./cloneDeep-hE40Q8aw.js');
 var translations = require('./translations-Bnw00bkf.js');
 var index = require('./index-ETPz91V5.js');
@@ -13403,15 +13403,266 @@ Depending on the detected platform, this will hold
 */
 const baseKeymap = mac$3 ? macBaseKeymap : pcBaseKeymap;
 
+const olDOM = ["ol", 0], ulDOM = ["ul", 0], liDOM = ["li", 0];
+/**
+An ordered list [node spec](https://prosemirror.net/docs/ref/#model.NodeSpec). Has a single
+attribute, `order`, which determines the number at which the list
+starts counting, and defaults to 1. Represented as an `<ol>`
+element.
+*/
+const orderedList = {
+    attrs: { order: { default: 1 } },
+    parseDOM: [{ tag: "ol", getAttrs(dom) {
+                return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
+            } }],
+    toDOM(node) {
+        return node.attrs.order == 1 ? olDOM : ["ol", { start: node.attrs.order }, 0];
+    }
+};
+/**
+A bullet list node spec, represented in the DOM as `<ul>`.
+*/
+const bulletList = {
+    parseDOM: [{ tag: "ul" }],
+    toDOM() { return ulDOM; }
+};
+/**
+A list item (`<li>`) spec.
+*/
+const listItem = {
+    parseDOM: [{ tag: "li" }],
+    toDOM() { return liDOM; },
+    defining: true
+};
+function add(obj, props) {
+    let copy = {};
+    for (let prop in obj)
+        copy[prop] = obj[prop];
+    for (let prop in props)
+        copy[prop] = props[prop];
+    return copy;
+}
+/**
+Convenience function for adding list-related node types to a map
+specifying the nodes for a schema. Adds
+[`orderedList`](https://prosemirror.net/docs/ref/#schema-list.orderedList) as `"ordered_list"`,
+[`bulletList`](https://prosemirror.net/docs/ref/#schema-list.bulletList) as `"bullet_list"`, and
+[`listItem`](https://prosemirror.net/docs/ref/#schema-list.listItem) as `"list_item"`.
+
+`itemContent` determines the content expression for the list items.
+If you want the commands defined in this module to apply to your
+list structure, it should have a shape like `"paragraph block*"` or
+`"paragraph (ordered_list | bullet_list)*"`. `listGroup` can be
+given to assign a group name to the list node types, for example
+`"block"`.
+*/
+function addListNodes(nodes, itemContent, listGroup) {
+    return nodes.append({
+        ordered_list: add(orderedList, { content: "list_item+", group: listGroup }),
+        bullet_list: add(bulletList, { content: "list_item+", group: listGroup }),
+        list_item: add(listItem, { content: itemContent })
+    });
+}
+/**
+Returns a command function that wraps the selection in a list with
+the given type an attributes. If `dispatch` is null, only return a
+value to indicate whether this is possible, but don't actually
+perform the change.
+*/
+function wrapInList(listType, attrs = null) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to), doJoin = false, outerRange = range;
+        if (!range)
+            return false;
+        // This is at the top of an existing list item
+        if (range.depth >= 2 && $from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+            // Don't do anything if this is the top of the list
+            if ($from.index(range.depth - 1) == 0)
+                return false;
+            let $insert = state.doc.resolve(range.start - 2);
+            outerRange = new NodeRange($insert, $insert, range.depth);
+            if (range.endIndex < range.parent.childCount)
+                range = new NodeRange($from, state.doc.resolve($to.end(range.depth)), range.depth);
+            doJoin = true;
+        }
+        let wrap = findWrapping(outerRange, listType, attrs, range);
+        if (!wrap)
+            return false;
+        if (dispatch)
+            dispatch(doWrapInList(state.tr, range, wrap, doJoin, listType).scrollIntoView());
+        return true;
+    };
+}
+function doWrapInList(tr, range, wrappers, joinBefore, listType) {
+    let content = Fragment.empty;
+    for (let i = wrappers.length - 1; i >= 0; i--)
+        content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+    tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
+    let found = 0;
+    for (let i = 0; i < wrappers.length; i++)
+        if (wrappers[i].type == listType)
+            found = i + 1;
+    let splitDepth = wrappers.length - found;
+    let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
+    for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
+        if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+            tr.split(splitPos, splitDepth);
+            splitPos += 2 * splitDepth;
+        }
+        splitPos += parent.child(i).nodeSize;
+    }
+    return tr;
+}
+/**
+Build a command that splits a non-empty textblock at the top level
+of a list item by also splitting that list item.
+*/
+function splitListItem(itemType, itemAttrs) {
+    return function (state, dispatch) {
+        let { $from, $to, node } = state.selection;
+        if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to))
+            return false;
+        let grandParent = $from.node(-1);
+        if (grandParent.type != itemType)
+            return false;
+        if ($from.parent.content.size == 0 && $from.node(-1).childCount == $from.indexAfter(-1)) {
+            // In an empty block. If this is a nested list, the wrapping
+            // list item should be split. Otherwise, bail out and let next
+            // command handle lifting.
+            if ($from.depth == 3 || $from.node(-3).type != itemType ||
+                $from.index(-2) != $from.node(-2).childCount - 1)
+                return false;
+            if (dispatch) {
+                let wrap = Fragment.empty;
+                let depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+                // Build a fragment containing empty versions of the structure
+                // from the outer list item to the parent node of the cursor
+                for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--)
+                    wrap = Fragment.from($from.node(d).copy(wrap));
+                let depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1
+                    : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
+                // Add a second list item with an empty default start node
+                wrap = wrap.append(Fragment.from(itemType.createAndFill()));
+                let start = $from.before($from.depth - (depthBefore - 1));
+                let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+                let sel = -1;
+                tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
+                    if (sel > -1)
+                        return false;
+                    if (node.isTextblock && node.content.size == 0)
+                        sel = pos + 1;
+                });
+                if (sel > -1)
+                    tr.setSelection(Selection.near(tr.doc.resolve(sel)));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+        let nextType = $to.pos == $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
+        let tr = state.tr.delete($from.pos, $to.pos);
+        let types = nextType ? [null, { type: nextType }] : undefined;
+        if (!canSplit(tr.doc, $from.pos, 2, types))
+            return false;
+        if (dispatch)
+            dispatch(tr.split($from.pos, 2, types).scrollIntoView());
+        return true;
+    };
+}
+/**
+Create a command to lift the list item around the selection up into
+a wrapping list.
+*/
+function liftListItem(itemType) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        if (!dispatch)
+            return true;
+        if ($from.node(range.depth - 1).type == itemType) // Inside a parent list
+            return liftToOuterList(state, dispatch, itemType, range);
+        else // Outer list node
+            return liftOutOfList(state, dispatch, range);
+    };
+}
+function liftToOuterList(state, dispatch, itemType, range) {
+    let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
+    if (end < endOfList) {
+        // There are siblings after the lifted items, which must become
+        // children of the last item
+        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
+        range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+    }
+    const target = liftTarget(range);
+    if (target == null)
+        return false;
+    tr.lift(range, target);
+    let after = tr.mapping.map(end, -1) - 1;
+    if (canJoin(tr.doc, after))
+        tr.join(after);
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+function liftOutOfList(state, dispatch, range) {
+    let tr = state.tr, list = range.parent;
+    // Merge the list items into a single big item
+    for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+        pos -= list.child(i).nodeSize;
+        tr.delete(pos - 1, pos + 1);
+    }
+    let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;
+    if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize)
+        return false;
+    let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;
+    let parent = $start.node(-1), indexBefore = $start.index(-1);
+    if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))
+        return false;
+    let start = $start.pos, end = start + item.nodeSize;
+    // Strip off the surrounding list. At the sides where we're not at
+    // the end of the list, the existing list is closed. At sides where
+    // this is the end, it is overwritten to its end.
+    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))
+        .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+/**
+Create a command to sink the list item around the selection down
+into an inner list.
+*/
+function sinkListItem(itemType) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        let startIndex = range.startIndex;
+        if (startIndex == 0)
+            return false;
+        let parent = range.parent, nodeBefore = parent.child(startIndex - 1);
+        if (nodeBefore.type != itemType)
+            return false;
+        if (dispatch) {
+            let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
+            let inner = Fragment.from(nestedBefore ? itemType.create() : null);
+            let slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+            let before = range.start, after = range.end;
+            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+
 const setActiveMethodForMark = (command, markType) => {
     command.active = (state) => {
         const { from, $from, to, empty } = state.selection;
         if (empty) {
             return !!markType.isInSet(state.storedMarks || $from.marks());
         }
-        else {
-            return state.doc.rangeHasMark(from, to, markType);
-        }
+        return state.doc.rangeHasMark(from, to, markType);
     };
 };
 const setActiveMethodForNode = (command, nodeType, level) => {
@@ -13424,24 +13675,292 @@ const setActiveMethodForNode = (command, nodeType, level) => {
             }
             return true;
         }
-        return false;
-    };
+        return false;
+    };
+};
+const setActiveMethodForWrap = (command, nodeType) => {
+    command.active = (state) => {
+        const { from, to } = state.selection;
+        let found = false;
+        state.doc.nodesBetween(from, to, (node) => {
+            if (node.type === nodeType) {
+                found = true;
+            }
+            return !found;
+        });
+        return found;
+    };
+};
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Whether the selection touches top-level blocks that cannot become list
+ * items (list_item requires a leading paragraph, so headings, blockquotes,
+ * code blocks and tables are not listable).
+ *
+ * @param state - the current editor state
+ * @returns true when a non-listable block intersects the selection
+ */
+const selectionHasNonListableBlock = (state) => {
+    const { from, to } = state.selection;
+    const { schema } = state;
+    let found = false;
+    state.doc.nodesBetween(from, to, (node, _pos, parent) => {
+        if (found) {
+            return false;
+        }
+        const isTopLevelBlock = (parent === null || parent === void 0 ? void 0 : parent.type) === schema.topNodeType;
+        const listable = node.type === schema.nodes.paragraph ||
+            node.type === schema.nodes.list_item ||
+            isListNode(node, schema);
+        if (isTopLevelBlock && !listable) {
+            found = true;
+            return false;
+        }
+        return !isTopLevelBlock || isListNode(node, schema);
+    });
+    return found;
+};
+/**
+ * Classifies the selection for the list command ladder.
+ *
+ * @param state - the current editor state
+ * @param listType - the list type the command targets
+ * @returns the ladder branch to take, plus the innermost list depth when
+ * the selection sits inside a list
+ */
+const resolveListContext = (state, listType) => {
+    const { $from, $to } = state.selection;
+    const fromDepth = innermostListDepth(state);
+    const sameTopLevelBlock = state.selection.empty ||
+        $from.sameParent($to) ||
+        $from.node(1) === $to.node(1);
+    if (fromDepth !== null && sameTopLevelBlock) {
+        return listContextAt($from, fromDepth, listType);
+    }
+    if (fromDepth === null && sameTopLevelBlock) {
+        return { kind: 'no-list', listDepth: null, singleBlock: true };
+    }
+    // The range spans multiple top-level blocks: uniform paragraphs mean a
+    // plain wrap; lists that are all of the target type mean a toggle;
+    // any other list in the mix means unification.
+    const listTypes = new Set();
+    let sawParagraph = false;
+    const startIndex = $from.index(0);
+    const endIndex = Math.min($to.index(0), state.doc.childCount - 1);
+    for (let i = startIndex; i <= endIndex; i++) {
+        const child = state.doc.child(i);
+        if (isListNode(child, state.schema)) {
+            listTypes.add(child.type);
+        }
+        else if (child.type === state.schema.nodes.paragraph) {
+            sawParagraph = true;
+        }
+    }
+    const uniformTargetLists = !sawParagraph && listTypes.size === 1 && listTypes.has(listType);
+    if (uniformTargetLists && fromDepth !== null) {
+        return listContextAt($from, fromDepth, listType);
+    }
+    if (listTypes.size > 0) {
+        return { kind: 'mixed', listDepth: null };
+    }
+    return { kind: 'no-list', listDepth: null, singleBlock: false };
+};
+/**
+ * Converts the innermost list around the selection to the target list type.
+ * bullet_list and ordered_list share the list_item+ content model, so the
+ * node can change type in place.
+ *
+ * @param state - the current editor state
+ * @param listDepth - depth of the list node, from resolveListContext
+ * @param targetType - the list type to convert to
+ * @param dispatch - the dispatch function; omit for a dry-run capability check
+ * @returns true when the conversion applies
+ */
+const convertInnermostList = (state, listDepth, targetType, dispatch) => {
+    const { $from } = state.selection;
+    const pos = $from.before(listDepth);
+    const node = state.doc.nodeAt(pos);
+    if (!node) {
+        return false;
+    }
+    if (dispatch) {
+        dispatch(state.tr
+            .setNodeMarkup(pos, targetType, listAttrsFor(targetType, node.attrs, state.schema))
+            .scrollIntoView());
+    }
+    return true;
+};
+/**
+ * Turns a mixed top-level selection (paragraphs and lists) into a single
+ * list of the target type: paragraph runs are wrapped, lists are converted
+ * in place, and adjacent same-type lists are joined. Nesting inside
+ * converted lists is preserved.
+ *
+ * @param state - the current editor state
+ * @param targetType - the list type to unify into
+ * @param dispatch - the dispatch function; omit for a dry-run capability check
+ * @returns true when the unification applies
+ */
+const unifyToList = (state, targetType, dispatch) => {
+    const { $from, $to } = state.selection;
+    if ($from.depth === 0 || $to.depth === 0) {
+        return false;
+    }
+    if (dispatch === undefined) {
+        return true;
+    }
+    const tr = state.tr;
+    convertListsAndWrapRuns(tr, state, targetType, $from.index(0), $to.index(0));
+    joinAdjacentLists(tr, targetType, tr.mapping.map($from.before(1)), mapKeepBefore(tr, $to.after(1)));
+    dispatch(tr.scrollIntoView());
+    return true;
+};
+/**
+ * Wraps a dispatch so that after a list is wrapped around the selection,
+ * adjacent top-level lists of the same type are joined with it.
+ *
+ * @param state - the editor state the wrap command runs on
+ * @param targetType - the list type being wrapped
+ * @param dispatch - the dispatch function; omitted for a dry-run capability check
+ * @returns the wrapped dispatch, or undefined when no dispatch was given
+ */
+const joinAdjacentListsOnDispatch = (state, targetType, dispatch) => {
+    if (!dispatch) {
+        return undefined;
+    }
+    const { $from, $to } = state.selection;
+    return (tr) => {
+        // The new list's outer boundaries: the start maps before the
+        // inserted wrapping, the end maps after it.
+        const start = mapKeepBefore(tr, $from.before(1));
+        const end = tr.mapping.map($to.after(1));
+        // Back to front, so the earlier boundary stays valid after a join.
+        joinSameTypeBoundary(tr, targetType, end);
+        joinSameTypeBoundary(tr, targetType, start);
+        dispatch(tr);
+    };
+};
+const joinSameTypeBoundary = (tr, targetType, boundary) => {
+    var _a, _b;
+    if (boundary <= 0 || boundary >= tr.doc.content.size) {
+        return;
+    }
+    const $boundary = tr.doc.resolve(boundary);
+    if (((_a = $boundary.nodeBefore) === null || _a === void 0 ? void 0 : _a.type) === targetType &&
+        ((_b = $boundary.nodeAfter) === null || _b === void 0 ? void 0 : _b.type) === targetType) {
+        tr.join(boundary);
+    }
+};
+const isListNode = (node, schema) => node.type === schema.nodes.bullet_list ||
+    node.type === schema.nodes.ordered_list;
+const innermostListDepth = (state) => {
+    const { $from } = state.selection;
+    for (let depth = $from.depth; depth > 0; depth--) {
+        if (isListNode($from.node(depth), state.schema)) {
+            return depth;
+        }
+    }
+    return null;
+};
+const listContextAt = ($from, listDepth, listType) => ({
+    kind: $from.node(listDepth).type === listType ? 'same-type' : 'other-type',
+    listDepth: listDepth,
+});
+const listAttrsFor = (targetType, attrs, schema) => {
+    var _a;
+    if (targetType === schema.nodes.ordered_list) {
+        return Object.assign(Object.assign({}, attrs), { order: (_a = attrs.order) !== null && _a !== void 0 ? _a : 1 });
+    }
+    const withoutOrder = __rest(attrs, ["order"]);
+    return withoutOrder;
+};
+const mapKeepBefore = (tr, position) => 
+// ProseMirror's Mapping.map takes (pos, assoc); the unicorn rule
+// misreads it as Array#map with a `this` argument.
+// eslint-disable-next-line unicorn/no-array-method-this-argument
+tr.mapping.map(position, -1);
+const wrapRunInList = (tr, targetType, runStart, runEnd) => {
+    const $start = tr.doc.resolve(tr.mapping.map(runStart) + 1);
+    const $end = tr.doc.resolve(mapKeepBefore(tr, runEnd) - 1);
+    const range = new NodeRange($start, $end, 0);
+    const wrapping = findWrapping(range, targetType);
+    if (!wrapping) {
+        return;
+    }
+    tr.wrap(range, wrapping);
+    // tr.wrap puts the whole run inside a single list_item; splitting at
+    // each block boundary gives one item per block, the same shape
+    // wrapInList produces.
+    const listIndex = wrapping.findIndex((entry) => entry.type === targetType);
+    const splitDepth = wrapping.length - (listIndex + 1);
+    let splitPos = range.start + wrapping.length;
+    for (let i = range.startIndex; i < range.endIndex; i++) {
+        if (i > range.startIndex && canSplit(tr.doc, splitPos, splitDepth)) {
+            tr.split(splitPos, splitDepth);
+            splitPos += 2 * splitDepth;
+        }
+        splitPos += range.parent.child(i).nodeSize;
+    }
+};
+const convertListsAndWrapRuns = (tr, state, targetType, startIndex, endIndex) => {
+    // Positions computed against the pre-transform doc are mapped through
+    // tr.mapping when applied.
+    const doc = state.doc;
+    let runStart = null;
+    let runEnd = null;
+    let pos = 0;
+    for (let i = 0; i < doc.childCount; i++) {
+        const child = doc.child(i);
+        const inRange = i >= startIndex && i <= endIndex;
+        const isList = isListNode(child, state.schema);
+        if (inRange && child.type === state.schema.nodes.paragraph) {
+            runStart = runStart !== null && runStart !== void 0 ? runStart : pos;
+            runEnd = pos + child.nodeSize;
+        }
+        else if (runStart !== null && runEnd !== null) {
+            wrapRunInList(tr, targetType, runStart, runEnd);
+            runStart = null;
+            runEnd = null;
+        }
+        if (inRange && isList && child.type !== targetType) {
+            tr.setNodeMarkup(tr.mapping.map(pos), targetType, listAttrsFor(targetType, child.attrs, state.schema));
+        }
+        pos += child.nodeSize;
+    }
+    if (runStart !== null && runEnd !== null) {
+        wrapRunInList(tr, targetType, runStart, runEnd);
+    }
 };
-const setActiveMethodForWrap = (command, nodeType) => {
-    command.active = (state) => {
-        const { from, to } = state.selection;
-        for (let pos = from; pos <= to; pos++) {
-            const resolvedPos = state.doc.resolve(pos);
-            for (let i = resolvedPos.depth; i > 0; i--) {
-                const node = resolvedPos.node(i);
-                if (node && node.type.name === nodeType.name) {
-                    return true;
-                }
-            }
+const joinAdjacentLists = (tr, targetType, mappedFrom, mappedTo) => {
+    // Scan the transformed doc's top-level boundaries back to front, so
+    // earlier join positions stay valid as joins shrink the doc.
+    const boundaries = [];
+    let boundary = 0;
+    for (let i = 0; i < tr.doc.childCount; i++) {
+        boundary += tr.doc.child(i).nodeSize;
+        boundaries.push(boundary);
+    }
+    for (let i = boundaries.length - 1; i >= 0; i--) {
+        const joinPos = boundaries[i];
+        if (joinPos <= mappedFrom || joinPos > mappedTo + 1) {
+            continue;
         }
-        return false;
-    };
+        joinSameTypeBoundary(tr, targetType, joinPos);
+    }
 };
+
 const createInsertLinkCommand = (schema, _, link) => {
     const command = (state, dispatch) => {
         const { from, to } = state.selection;
@@ -13501,11 +14020,13 @@ const toggleNodeType = (schema, type, attrs = {}, shouldWrap = false) => {
     const paragraphType = schema.nodes.paragraph;
     return (state, dispatch) => {
         const { $from, $to } = state.selection;
-        const hasActiveWrap = $from.node($from.depth - 1).type === nodeType;
         if (state.selection instanceof TextSelection &&
             // Ensure selection is within the same parent block
             // We don't want toggling block types across multiple blocks
             $from.sameParent($from.doc.resolve($to.pos))) {
+            // Resolved only under the TextSelection guard: an AllSelection
+            // resolves at depth 0, where there is no parent node to read.
+            const hasActiveWrap = $from.node($from.depth - 1).type === nodeType;
             if ($from.parent.type === nodeType) {
                 if (dispatch) {
                     dispatch(state.tr.setBlockType($from.pos, $to.pos, paragraphType));
@@ -13562,40 +14083,85 @@ const createWrapInCommand = (schema, nodeType) => {
     setActiveMethodForWrap(command, type);
     return command;
 };
-const toggleList = (listType) => {
-    return (state, dispatch) => {
-        const { $from, $to } = state.selection;
-        const range = $from.blockRange($to);
-        if (!range) {
+// Select-all produces an AllSelection, whose endpoints resolve at the
+// document level where list commands cannot operate. Re-anchoring it as
+// a TextSelection over the same content lets the list ladder (and the
+// delegated prosemirror-schema-list commands) treat select-all like any
+// other full-content selection.
+const withTextSelection = (state) => {
+    if (!(state.selection instanceof AllSelection)) {
+        return state;
+    }
+    const selection = TextSelection.between(state.doc.resolve(0), state.doc.resolve(state.doc.content.size));
+    // A plugin-free scratch state on the shared doc: only feed it
+    // commands driven by doc and selection.
+    return EditorState.create({
+        doc: state.doc,
+        selection: selection,
+        storedMarks: state.storedMarks,
+    });
+};
+/**
+ * Creates a command for toggling list types.
+ *
+ * @param schema - The ProseMirror schema.
+ * @param listTypeName - The name of the list type to toggle.
+ * @returns A command for toggling list types.
+ */
+const createListCommand = (schema, listTypeName) => {
+    const type = schema.nodes[listTypeName];
+    if (!type) {
+        throw new Error(`List type "${listTypeName}" not found in schema`);
+    }
+    const itemType = schema.nodes.list_item;
+    if (!itemType) {
+        throw new Error('Node type "list_item" not found in schema');
+    }
+    // The keymap invokes the command directly, so the command body applies
+    // the same applicability rules as `allowed` to keep keyboard and
+    // toolbar behavior identical.
+    const command = (state, dispatch) => {
+        state = withTextSelection(state);
+        if (!(state.selection instanceof TextSelection)) {
             return false;
         }
-        const wrapping = range && findWrapping(range, listType);
-        if (wrapping) {
-            // Wrap the selection in a list
-            if (dispatch) {
-                dispatch(state.tr.wrap(range, wrapping).scrollIntoView());
-            }
-            return true;
+        const context = resolveListContext(state, type);
+        if (context.kind === 'same-type') {
+            return liftListItem(itemType)(state, dispatch);
         }
-        else {
-            // Check if we are in a list item and lift out of the list
-            const liftRange = range && liftTarget(range);
-            if (liftRange !== null) {
-                if (dispatch) {
-                    dispatch(state.tr.lift(range, liftRange).scrollIntoView());
-                }
-                return true;
+        if (context.kind === 'other-type') {
+            return convertInnermostList(state, context.listDepth, type, dispatch);
+        }
+        if (context.kind === 'no-list') {
+            // For a single block the schema decides, through the wrap
+            // command itself; multi-block selections keep the stricter
+            // gate so unify cannot half-apply.
+            if (!context.singleBlock && selectionHasNonListableBlock(state)) {
+                return false;
             }
+            return wrapInList(type)(state, joinAdjacentListsOnDispatch(state, type, dispatch));
+        }
+        if (selectionHasNonListableBlock(state)) {
             return false;
         }
+        return unifyToList(state, type, dispatch);
+    };
+    command.allowed = (state) => {
+        state = withTextSelection(state);
+        if (!(state.selection instanceof TextSelection)) {
+            return false;
+        }
+        const context = resolveListContext(state, type);
+        // Inside a list, toggling or converting is always applicable, even
+        // when a non-listable ancestor wraps the list.
+        if (context.kind === 'same-type' || context.kind === 'other-type') {
+            return true;
+        }
+        if (context.kind === 'no-list' && context.singleBlock) {
+            return wrapInList(type)(state);
+        }
+        return !selectionHasNonListableBlock(state);
     };
-};
-const createListCommand = (schema, listType) => {
-    const type = schema.nodes[listType];
-    if (!type) {
-        throw new Error(`List type "${listType}" not found in schema`);
-    }
-    const command = toggleList(type);
     setActiveMethodForWrap(command, type);
     return command;
 };
@@ -13632,6 +14198,8 @@ class MenuCommandFactory {
             'Mod-Shift-1': this.getCommand(types.EditorMenuTypes.HeaderLevel1),
             'Mod-Shift-2': this.getCommand(types.EditorMenuTypes.HeaderLevel2),
             'Mod-Shift-3': this.getCommand(types.EditorMenuTypes.HeaderLevel3),
+            'Mod-Shift-7': this.getCommand(types.EditorMenuTypes.OrderedList),
+            'Mod-Shift-8': this.getCommand(types.EditorMenuTypes.BulletList),
             'Mod-Shift-X': this.getCommand(types.EditorMenuTypes.Strikethrough),
             'Mod-`': this.getCommand(types.EditorMenuTypes.Code),
             'Mod-Shift-C': this.getCommand(types.EditorMenuTypes.CodeBlock),
@@ -23083,356 +23651,103 @@ const nodes = {
     `alt`, and `href` attributes. The latter two default to the empty
     string.
     */
-    image: {
-        inline: true,
-        attrs: {
-            src: { validate: "string" },
-            alt: { default: null, validate: "string|null" },
-            title: { default: null, validate: "string|null" }
-        },
-        group: "inline",
-        draggable: true,
-        parseDOM: [{ tag: "img[src]", getAttrs(dom) {
-                    return {
-                        src: dom.getAttribute("src"),
-                        title: dom.getAttribute("title"),
-                        alt: dom.getAttribute("alt")
-                    };
-                } }],
-        toDOM(node) { let { src, alt, title } = node.attrs; return ["img", { src, alt, title }]; }
-    },
-    /**
-    A hard line break, represented in the DOM as `<br>`.
-    */
-    hard_break: {
-        inline: true,
-        group: "inline",
-        selectable: false,
-        parseDOM: [{ tag: "br" }],
-        toDOM() { return brDOM; }
-    }
-};
-const emDOM = ["em", 0], strongDOM = ["strong", 0], codeDOM = ["code", 0];
-/**
-[Specs](https://prosemirror.net/docs/ref/#model.MarkSpec) for the marks in the schema.
-*/
-const marks = {
-    /**
-    A link. Has `href` and `title` attributes. `title`
-    defaults to the empty string. Rendered and parsed as an `<a>`
-    element.
-    */
-    link: {
-        attrs: {
-            href: { validate: "string" },
-            title: { default: null, validate: "string|null" }
-        },
-        inclusive: false,
-        parseDOM: [{ tag: "a[href]", getAttrs(dom) {
-                    return { href: dom.getAttribute("href"), title: dom.getAttribute("title") };
-                } }],
-        toDOM(node) { let { href, title } = node.attrs; return ["a", { href, title }, 0]; }
-    },
-    /**
-    An emphasis mark. Rendered as an `<em>` element. Has parse rules
-    that also match `<i>` and `font-style: italic`.
-    */
-    em: {
-        parseDOM: [
-            { tag: "i" }, { tag: "em" },
-            { style: "font-style=italic" },
-            { style: "font-style=normal", clearMark: m => m.type.name == "em" }
-        ],
-        toDOM() { return emDOM; }
-    },
-    /**
-    A strong mark. Rendered as `<strong>`, parse rules also match
-    `<b>` and `font-weight: bold`.
-    */
-    strong: {
-        parseDOM: [
-            { tag: "strong" },
-            // This works around a Google Docs misbehavior where
-            // pasted content will be inexplicably wrapped in `<b>`
-            // tags with a font-weight normal.
-            { tag: "b", getAttrs: (node) => node.style.fontWeight != "normal" && null },
-            { style: "font-weight=400", clearMark: m => m.type.name == "strong" },
-            { style: "font-weight", getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null },
-        ],
-        toDOM() { return strongDOM; }
-    },
-    /**
-    Code font mark. Represented as a `<code>` element.
-    */
-    code: {
-        code: true,
-        parseDOM: [{ tag: "code" }],
-        toDOM() { return codeDOM; }
-    }
-};
-/**
-This schema roughly corresponds to the document schema used by
-[CommonMark](http://commonmark.org/), minus the list elements,
-which are defined in the [`prosemirror-schema-list`](https://prosemirror.net/docs/ref/#schema-list)
-module.
-
-To reuse elements from this schema, extend or read from its
-`spec.nodes` and `spec.marks` [properties](https://prosemirror.net/docs/ref/#model.Schema.spec).
-*/
-const schema = new Schema({ nodes, marks });
-
-const olDOM = ["ol", 0], ulDOM = ["ul", 0], liDOM = ["li", 0];
-/**
-An ordered list [node spec](https://prosemirror.net/docs/ref/#model.NodeSpec). Has a single
-attribute, `order`, which determines the number at which the list
-starts counting, and defaults to 1. Represented as an `<ol>`
-element.
-*/
-const orderedList = {
-    attrs: { order: { default: 1 } },
-    parseDOM: [{ tag: "ol", getAttrs(dom) {
-                return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
-            } }],
-    toDOM(node) {
-        return node.attrs.order == 1 ? olDOM : ["ol", { start: node.attrs.order }, 0];
-    }
-};
-/**
-A bullet list node spec, represented in the DOM as `<ul>`.
-*/
-const bulletList = {
-    parseDOM: [{ tag: "ul" }],
-    toDOM() { return ulDOM; }
-};
-/**
-A list item (`<li>`) spec.
-*/
-const listItem = {
-    parseDOM: [{ tag: "li" }],
-    toDOM() { return liDOM; },
-    defining: true
-};
-function add(obj, props) {
-    let copy = {};
-    for (let prop in obj)
-        copy[prop] = obj[prop];
-    for (let prop in props)
-        copy[prop] = props[prop];
-    return copy;
-}
-/**
-Convenience function for adding list-related node types to a map
-specifying the nodes for a schema. Adds
-[`orderedList`](https://prosemirror.net/docs/ref/#schema-list.orderedList) as `"ordered_list"`,
-[`bulletList`](https://prosemirror.net/docs/ref/#schema-list.bulletList) as `"bullet_list"`, and
-[`listItem`](https://prosemirror.net/docs/ref/#schema-list.listItem) as `"list_item"`.
-
-`itemContent` determines the content expression for the list items.
-If you want the commands defined in this module to apply to your
-list structure, it should have a shape like `"paragraph block*"` or
-`"paragraph (ordered_list | bullet_list)*"`. `listGroup` can be
-given to assign a group name to the list node types, for example
-`"block"`.
-*/
-function addListNodes(nodes, itemContent, listGroup) {
-    return nodes.append({
-        ordered_list: add(orderedList, { content: "list_item+", group: listGroup }),
-        bullet_list: add(bulletList, { content: "list_item+", group: listGroup }),
-        list_item: add(listItem, { content: itemContent })
-    });
-}
-/**
-Returns a command function that wraps the selection in a list with
-the given type an attributes. If `dispatch` is null, only return a
-value to indicate whether this is possible, but don't actually
-perform the change.
-*/
-function wrapInList(listType, attrs = null) {
-    return function (state, dispatch) {
-        let { $from, $to } = state.selection;
-        let range = $from.blockRange($to), doJoin = false, outerRange = range;
-        if (!range)
-            return false;
-        // This is at the top of an existing list item
-        if (range.depth >= 2 && $from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
-            // Don't do anything if this is the top of the list
-            if ($from.index(range.depth - 1) == 0)
-                return false;
-            let $insert = state.doc.resolve(range.start - 2);
-            outerRange = new NodeRange($insert, $insert, range.depth);
-            if (range.endIndex < range.parent.childCount)
-                range = new NodeRange($from, state.doc.resolve($to.end(range.depth)), range.depth);
-            doJoin = true;
-        }
-        let wrap = findWrapping(outerRange, listType, attrs, range);
-        if (!wrap)
-            return false;
-        if (dispatch)
-            dispatch(doWrapInList(state.tr, range, wrap, doJoin, listType).scrollIntoView());
-        return true;
-    };
-}
-function doWrapInList(tr, range, wrappers, joinBefore, listType) {
-    let content = Fragment.empty;
-    for (let i = wrappers.length - 1; i >= 0; i--)
-        content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
-    tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
-    let found = 0;
-    for (let i = 0; i < wrappers.length; i++)
-        if (wrappers[i].type == listType)
-            found = i + 1;
-    let splitDepth = wrappers.length - found;
-    let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
-    for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
-        if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
-            tr.split(splitPos, splitDepth);
-            splitPos += 2 * splitDepth;
-        }
-        splitPos += parent.child(i).nodeSize;
+    image: {
+        inline: true,
+        attrs: {
+            src: { validate: "string" },
+            alt: { default: null, validate: "string|null" },
+            title: { default: null, validate: "string|null" }
+        },
+        group: "inline",
+        draggable: true,
+        parseDOM: [{ tag: "img[src]", getAttrs(dom) {
+                    return {
+                        src: dom.getAttribute("src"),
+                        title: dom.getAttribute("title"),
+                        alt: dom.getAttribute("alt")
+                    };
+                } }],
+        toDOM(node) { let { src, alt, title } = node.attrs; return ["img", { src, alt, title }]; }
+    },
+    /**
+    A hard line break, represented in the DOM as `<br>`.
+    */
+    hard_break: {
+        inline: true,
+        group: "inline",
+        selectable: false,
+        parseDOM: [{ tag: "br" }],
+        toDOM() { return brDOM; }
     }
-    return tr;
-}
-/**
-Build a command that splits a non-empty textblock at the top level
-of a list item by also splitting that list item.
-*/
-function splitListItem(itemType, itemAttrs) {
-    return function (state, dispatch) {
-        let { $from, $to, node } = state.selection;
-        if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to))
-            return false;
-        let grandParent = $from.node(-1);
-        if (grandParent.type != itemType)
-            return false;
-        if ($from.parent.content.size == 0 && $from.node(-1).childCount == $from.indexAfter(-1)) {
-            // In an empty block. If this is a nested list, the wrapping
-            // list item should be split. Otherwise, bail out and let next
-            // command handle lifting.
-            if ($from.depth == 3 || $from.node(-3).type != itemType ||
-                $from.index(-2) != $from.node(-2).childCount - 1)
-                return false;
-            if (dispatch) {
-                let wrap = Fragment.empty;
-                let depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-                // Build a fragment containing empty versions of the structure
-                // from the outer list item to the parent node of the cursor
-                for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--)
-                    wrap = Fragment.from($from.node(d).copy(wrap));
-                let depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1
-                    : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-                // Add a second list item with an empty default start node
-                wrap = wrap.append(Fragment.from(itemType.createAndFill()));
-                let start = $from.before($from.depth - (depthBefore - 1));
-                let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
-                let sel = -1;
-                tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
-                    if (sel > -1)
-                        return false;
-                    if (node.isTextblock && node.content.size == 0)
-                        sel = pos + 1;
-                });
-                if (sel > -1)
-                    tr.setSelection(Selection.near(tr.doc.resolve(sel)));
-                dispatch(tr.scrollIntoView());
-            }
-            return true;
-        }
-        let nextType = $to.pos == $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-        let tr = state.tr.delete($from.pos, $to.pos);
-        let types = nextType ? [null, { type: nextType }] : undefined;
-        if (!canSplit(tr.doc, $from.pos, 2, types))
-            return false;
-        if (dispatch)
-            dispatch(tr.split($from.pos, 2, types).scrollIntoView());
-        return true;
-    };
-}
+};
+const emDOM = ["em", 0], strongDOM = ["strong", 0], codeDOM = ["code", 0];
 /**
-Create a command to lift the list item around the selection up into
-a wrapping list.
+[Specs](https://prosemirror.net/docs/ref/#model.MarkSpec) for the marks in the schema.
 */
-function liftListItem(itemType) {
-    return function (state, dispatch) {
-        let { $from, $to } = state.selection;
-        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
-        if (!range)
-            return false;
-        if (!dispatch)
-            return true;
-        if ($from.node(range.depth - 1).type == itemType) // Inside a parent list
-            return liftToOuterList(state, dispatch, itemType, range);
-        else // Outer list node
-            return liftOutOfList(state, dispatch, range);
-    };
-}
-function liftToOuterList(state, dispatch, itemType, range) {
-    let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
-    if (end < endOfList) {
-        // There are siblings after the lifted items, which must become
-        // children of the last item
-        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
-        range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
-    }
-    const target = liftTarget(range);
-    if (target == null)
-        return false;
-    tr.lift(range, target);
-    let after = tr.mapping.map(end, -1) - 1;
-    if (canJoin(tr.doc, after))
-        tr.join(after);
-    dispatch(tr.scrollIntoView());
-    return true;
-}
-function liftOutOfList(state, dispatch, range) {
-    let tr = state.tr, list = range.parent;
-    // Merge the list items into a single big item
-    for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
-        pos -= list.child(i).nodeSize;
-        tr.delete(pos - 1, pos + 1);
+const marks = {
+    /**
+    A link. Has `href` and `title` attributes. `title`
+    defaults to the empty string. Rendered and parsed as an `<a>`
+    element.
+    */
+    link: {
+        attrs: {
+            href: { validate: "string" },
+            title: { default: null, validate: "string|null" }
+        },
+        inclusive: false,
+        parseDOM: [{ tag: "a[href]", getAttrs(dom) {
+                    return { href: dom.getAttribute("href"), title: dom.getAttribute("title") };
+                } }],
+        toDOM(node) { let { href, title } = node.attrs; return ["a", { href, title }, 0]; }
+    },
+    /**
+    An emphasis mark. Rendered as an `<em>` element. Has parse rules
+    that also match `<i>` and `font-style: italic`.
+    */
+    em: {
+        parseDOM: [
+            { tag: "i" }, { tag: "em" },
+            { style: "font-style=italic" },
+            { style: "font-style=normal", clearMark: m => m.type.name == "em" }
+        ],
+        toDOM() { return emDOM; }
+    },
+    /**
+    A strong mark. Rendered as `<strong>`, parse rules also match
+    `<b>` and `font-weight: bold`.
+    */
+    strong: {
+        parseDOM: [
+            { tag: "strong" },
+            // This works around a Google Docs misbehavior where
+            // pasted content will be inexplicably wrapped in `<b>`
+            // tags with a font-weight normal.
+            { tag: "b", getAttrs: (node) => node.style.fontWeight != "normal" && null },
+            { style: "font-weight=400", clearMark: m => m.type.name == "strong" },
+            { style: "font-weight", getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null },
+        ],
+        toDOM() { return strongDOM; }
+    },
+    /**
+    Code font mark. Represented as a `<code>` element.
+    */
+    code: {
+        code: true,
+        parseDOM: [{ tag: "code" }],
+        toDOM() { return codeDOM; }
     }
-    let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;
-    if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize)
-        return false;
-    let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;
-    let parent = $start.node(-1), indexBefore = $start.index(-1);
-    if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))
-        return false;
-    let start = $start.pos, end = start + item.nodeSize;
-    // Strip off the surrounding list. At the sides where we're not at
-    // the end of the list, the existing list is closed. At sides where
-    // this is the end, it is overwritten to its end.
-    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))
-        .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
-    dispatch(tr.scrollIntoView());
-    return true;
-}
+};
 /**
-Create a command to sink the list item around the selection down
-into an inner list.
+This schema roughly corresponds to the document schema used by
+[CommonMark](http://commonmark.org/), minus the list elements,
+which are defined in the [`prosemirror-schema-list`](https://prosemirror.net/docs/ref/#schema-list)
+module.
+
+To reuse elements from this schema, extend or read from its
+`spec.nodes` and `spec.marks` [properties](https://prosemirror.net/docs/ref/#model.Schema.spec).
 */
-function sinkListItem(itemType) {
-    return function (state, dispatch) {
-        let { $from, $to } = state.selection;
-        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
-        if (!range)
-            return false;
-        let startIndex = range.startIndex;
-        if (startIndex == 0)
-            return false;
-        let parent = range.parent, nodeBefore = parent.child(startIndex - 1);
-        if (nodeBefore.type != itemType)
-            return false;
-        if (dispatch) {
-            let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
-            let inner = Fragment.from(nestedBefore ? itemType.create() : null);
-            let slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
-            let before = range.start, after = range.end;
-            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
-                .scrollIntoView());
-        }
-        return true;
-    };
-}
+const schema = new Schema({ nodes, marks });
 
 var base = {
   8: "Backspace",
@@ -25990,6 +26305,64 @@ const createActionBarInteractionPlugin = (menuCommandFactory) => {
     });
 };
 
+/**
+ * Finds the depth of the nearest ancestor of a given node type.
+ *
+ * @param $pos - The resolved position in the document.
+ * @param type - The node type to search for.
+ * @returns The depth at which the node is found, or null if not found.
+ */
+const findAncestorDepthOfType = ($pos, type) => {
+    for (let depth = $pos.depth; depth > 0; depth--) {
+        if ($pos.node(depth).type === type) {
+            return depth;
+        }
+    }
+    return null;
+};
+
+const listKeyHandlerPluginKey = new PluginKey('listKeyHandlerPlugin');
+/**
+ * Creates a plugin for handling Tab and Shift+Tab inside list items:
+ * Tab indents the item and Shift+Tab outdents it. Enter and Backspace
+ * are handled by the base keymap (splitListItem and joinBackward), which
+ * runs before this plugin.
+ *
+ * @param schema - The document schema
+ * @returns A ProseMirror plugin for handling list-specific key events
+ */
+function createListKeyHandlerPlugin(schema) {
+    return new Plugin({
+        key: listKeyHandlerPluginKey,
+        props: {
+            handleKeyDown: (view, event) => {
+                if (event.key !== 'Tab') {
+                    return false;
+                }
+                const { state } = view;
+                const { $from } = state.selection;
+                const inListItem = findAncestorDepthOfType($from, schema.nodes.list_item) !==
+                    null;
+                if (!inListItem) {
+                    return false;
+                }
+                // Inside a list item, Tab and Shift+Tab are always handled
+                // so focus never leaves the editor mid-list, even when the
+                // indent or outdent itself cannot apply.
+                event.preventDefault();
+                if (event.shiftKey) {
+                    liftListItem(schema.nodes.list_item)(state, view.dispatch);
+                    return true;
+                }
+                // Sinking fails on first items (no preceding sibling to
+                // become the parent); Tab is still swallowed.
+                sinkListItem(schema.nodes.list_item)(state, view.dispatch);
+                return true;
+            },
+        },
+    });
+}
+
 const createHtmlInserter = (view, contentConverter, trigger, dispatchTransaction) => {
     const schema = view.state.schema;
     return async (input) => {
@@ -27539,7 +27912,15 @@ function buildEditorSchema(options) {
 function buildEditorPlugins(options) {
     const { schema, menuCommandFactory, contentConverter, language, contentType, triggerCharacters, inlineImages, onNewLinkSelection, onImagePasted, onActiveItemsChange, } = options;
     return [
-        ...exampleSetup({ schema: schema}),
+        // exampleSetup binds Shift-Ctrl-8/9 to a plain wrapInList. On
+        // Windows/Linux those are the same physical keys as our
+        // Mod-Shift-8/7 list commands, and exampleSetup's keymap runs
+        // first, so its bindings are suppressed to let the context-aware
+        // list commands own the shortcuts on every platform.
+        ...exampleSetup({
+            schema: schema,
+            mapKeys: { 'Shift-Ctrl-8': false, 'Shift-Ctrl-9': false },
+        }),
         keymap(menuCommandFactory.buildKeymap()),
         createTriggerPlugin(triggerCharacters, contentConverter),
         createLinkPlugin(onNewLinkSelection),
@@ -27547,6 +27928,7 @@ function buildEditorPlugins(options) {
         createImageViewPlugin(language),
         createMenuStateTrackingPlugin(types.editorMenuTypesArray, menuCommandFactory, onActiveItemsChange),
         createActionBarInteractionPlugin(menuCommandFactory),
+        createListKeyHandlerPlugin(schema),
         ...getTableEditingPlugins(contentType === 'html'),
     ];
 }
@@ -27734,13 +28116,14 @@ const ProsemirrorAdapter = class {
             return newItem;
         };
         this.updateActiveActionBarItems = (activeTypes, allowedTypes) => {
-            const newItems = getTextEditorMenuItems().map((item) => {
+            this.actionBarItems = getTextEditorMenuItems()
+                .map(this.getTranslatedItem)
+                .map((item) => {
                 if (isItem.isItem(item)) {
-                    return Object.assign(Object.assign({}, item), { selected: activeTypes[item.value], allowed: allowedTypes[item.value] });
+                    return Object.assign(Object.assign({}, item), { selected: activeTypes[item.value], disabled: !allowedTypes[item.value] });
                 }
                 return item;
             });
-            this.actionBarItems = newItems.filter((item) => isItem.isItem(item) ? item.allowed : true);
         };
         this.handleTransaction = (transaction) => {
             this.transactionFired = true;