@limetech/lime-elements 39.44.6 → 39.45.1

package/dist/cjs/limel-text-editor-link-menu.cjs.entry.js

@@ -93,11 +93,11 @@ const TextEditorLinkMenu = class {
         document.removeEventListener('keyup', this.handleCancel);
     }
     componentDidLoad() {
-        this.focusOnTextInput();
+        this.focusOnLinkInput();
     }
-    focusOnTextInput() {
-        if (this.textInput) {
-            const inputField = this.textInput.shadowRoot.querySelector('input');
+    focusOnLinkInput() {
+        if (this.linkInput) {
+            const inputField = this.linkInput.shadowRoot.querySelector('input');
             if (inputField) {
                 requestAnimationFrame(() => {
                     inputField.focus();
@@ -109,8 +109,8 @@ const TextEditorLinkMenu = class {
         var _a, _b;
         const isValid = this.isValid(this.link.href);
         return [
-            index.h("limel-input-field", { key: '0416f2d94ec54c569455938babfebee34bc1b17c', label: this.getTranslation('editor-link-menu.text'), value: ((_a = this.link) === null || _a === void 0 ? void 0 : _a.text) || '', leadingIcon: "text_cursor", onChange: this.handleLinkTitleChange, onKeyDown: this.handleKeyDown, ref: (el) => (this.textInput = el) }),
-            index.h("limel-input-field", { key: '6dfb8808eee203e9aa9e87e3bf3720aae217c5e0', label: this.getTranslation('editor-link-menu.link'), value: ((_b = this.link) === null || _b === void 0 ? void 0 : _b.href) || '', type: "text", leadingIcon: "-lime-text-link", trailingIcon: "external_link", invalid: !isValid, onChange: this.handleLinkValueChange, onAction: this.handleLinkInputAction, onKeyDown: this.handleKeyDown }),
+            index.h("limel-input-field", { key: '8da44ef5f8141c0b7e4cadf75babd07a62614674', label: this.getTranslation('editor-link-menu.text'), value: ((_a = this.link) === null || _a === void 0 ? void 0 : _a.text) || '', leadingIcon: "text_cursor", onChange: this.handleLinkTitleChange, onKeyDown: this.handleKeyDown }),
+            index.h("limel-input-field", { key: 'a16f2a13564809011551bf96e34e100b0683493c', label: this.getTranslation('editor-link-menu.link'), value: ((_b = this.link) === null || _b === void 0 ? void 0 : _b.href) || '', type: "text", leadingIcon: "-lime-text-link", trailingIcon: "external_link", invalid: !isValid, onChange: this.handleLinkValueChange, onAction: this.handleLinkInputAction, onKeyDown: this.handleKeyDown, ref: (el) => (this.linkInput = el) }),
             index.h("div", { key: 'ee392b700a4293eb2b2121d08bfef852f8b4404e', class: "actions" }, index.h("limel-button", { key: 'be9f4711edf45a69f8087341e61fc4183c59ba2d', label: this.getTranslation('cancel'), onClick: this.handleCancel }), index.h("limel-button", { key: 'b958cae7915cc42133e5143589d4f454f8bb2ffa', primary: true, label: this.getTranslation('save'), disabled: !isValid, onClick: this.handleSave, ref: (el) => (this.saveButton = el), slot: "button" })),
         ];
     }

package/dist/cjs/{markdown-parser-ChnRAxpZ.js → markdown-parser-YH5HSSgF.js}

@@ -33093,7 +33093,7 @@ function rehypeRaw(options) {
 
 // http://www.w3.org/TR/CSS21/grammar.html
 // https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
-var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+var COMMENT_REGEX = /\/\*(?:[^*]|\*(?!\/))*\*\//g;
 
 var NEWLINE_REGEX = /\n/g;
 var WHITESPACE_REGEX = /^\s*/;
@@ -33101,12 +33101,10 @@ var WHITESPACE_REGEX = /^\s*/;
 // declaration
 var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
 var COLON_REGEX = /^:\s*/;
-var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+var VALUE_REGEX =
+  /^((?:'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|url\((?:'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|[^)]*)\)|[^};])+)/;
 var SEMICOLON_REGEX = /^[;\s]*/;
 
-// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill
-var TRIM_REGEX = /^\s+|\s+$/g;
-
 // strings
 var NEWLINE = '\n';
 var FORWARD_SLASH = '/';
@@ -33230,16 +33228,13 @@ function index (style, options) {
   /**
    * Parse comments.
    *
-   * @param {Object[]} [rules]
+   * @param {Object[]} rules
    * @return {Object[]}
    */
   function comments(rules) {
     var c;
-    rules = rules || [];
     while ((c = comment())) {
-      if (c !== false) {
-        rules.push(c);
-      }
+      rules.push(c);
     }
     return rules;
   }
@@ -33301,9 +33296,9 @@ function index (style, options) {
 
     var ret = pos({
       type: TYPE_DECLARATION,
-      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+      property: prop[0].replace(COMMENT_REGEX, EMPTY_STRING).trim(),
       value: val
-        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))
+        ? val[0].replace(COMMENT_REGEX, EMPTY_STRING).trim()
         : EMPTY_STRING
     });
 
@@ -33326,10 +33321,8 @@ function index (style, options) {
     // declarations
     var decl;
     while ((decl = declaration())) {
-      if (decl !== false) {
-        decls.push(decl);
-        comments(decls);
-      }
+      decls.push(decl);
+      comments(decls);
     }
 
     return decls;
@@ -33339,47 +33332,34 @@ function index (style, options) {
   return declarations();
 }
 
-/**
- * Trim `str`.
- *
- * @param {String} str
- * @return {String}
- */
-function trim(str) {
-  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
-}
-
-/**
- * Parses inline style to object.
- *
- * @param style - Inline style.
- * @param iterator - Iterator.
- * @returns - Style object or null.
- *
- * @example Parsing inline style to object:
- *
- * ```js
- * import parse from 'style-to-object';
- * parse('line-height: 42;'); // { 'line-height': '42' }
- * ```
- */
+//#region src/index.ts
+/**
+* Parses inline style to object.
+*
+* @param style - Inline style.
+* @param iterator - Iterator.
+* @returns - Style object or null.
+*
+* @example Parsing inline style to object:
+*
+* ```js
+* import parse from 'style-to-object';
+* parse('line-height: 42;'); // { 'line-height': '42' }
+* ```
+*/
 function StyleToObject(style, iterator) {
-    let styleObject = null;
-    if (!style || typeof style !== 'string') {
-        return styleObject;
-    }
-    const declarations = index(style);
-    declarations.forEach((declaration) => {
-        if (declaration.type !== 'declaration') {
-            return;
-        }
-        const { property, value } = declaration;
-        if (value) {
-            styleObject = styleObject || {};
-            styleObject[property] = value;
-        }
-    });
-    return styleObject;
+	let styleObject = null;
+	if (!style || typeof style !== "string") return styleObject;
+	const declarations = index(style);
+	declarations.forEach((declaration) => {
+		if (declaration.type !== "declaration") return;
+		const { property, value } = declaration;
+		if (value) {
+			styleObject = styleObject ?? {};
+			styleObject[property] = value;
+		}
+	});
+	return styleObject;
 }
 
 var colorName$1;

package/dist/collection/components/text-editor/link-menu/editor-link-menu.js

@@ -90,11 +90,11 @@ export class TextEditorLinkMenu {
         document.removeEventListener('keyup', this.handleCancel);
     }
     componentDidLoad() {
-        this.focusOnTextInput();
+        this.focusOnLinkInput();
     }
-    focusOnTextInput() {
-        if (this.textInput) {
-            const inputField = this.textInput.shadowRoot.querySelector('input');
+    focusOnLinkInput() {
+        if (this.linkInput) {
+            const inputField = this.linkInput.shadowRoot.querySelector('input');
             if (inputField) {
                 requestAnimationFrame(() => {
                     inputField.focus();
@@ -106,8 +106,8 @@ export class TextEditorLinkMenu {
         var _a, _b;
         const isValid = this.isValid(this.link.href);
         return [
-            h("limel-input-field", { key: '0416f2d94ec54c569455938babfebee34bc1b17c', label: this.getTranslation('editor-link-menu.text'), value: ((_a = this.link) === null || _a === void 0 ? void 0 : _a.text) || '', leadingIcon: "text_cursor", onChange: this.handleLinkTitleChange, onKeyDown: this.handleKeyDown, ref: (el) => (this.textInput = el) }),
-            h("limel-input-field", { key: '6dfb8808eee203e9aa9e87e3bf3720aae217c5e0', label: this.getTranslation('editor-link-menu.link'), value: ((_b = this.link) === null || _b === void 0 ? void 0 : _b.href) || '', type: "text", leadingIcon: "-lime-text-link", trailingIcon: "external_link", invalid: !isValid, onChange: this.handleLinkValueChange, onAction: this.handleLinkInputAction, onKeyDown: this.handleKeyDown }),
+            h("limel-input-field", { key: '8da44ef5f8141c0b7e4cadf75babd07a62614674', label: this.getTranslation('editor-link-menu.text'), value: ((_a = this.link) === null || _a === void 0 ? void 0 : _a.text) || '', leadingIcon: "text_cursor", onChange: this.handleLinkTitleChange, onKeyDown: this.handleKeyDown }),
+            h("limel-input-field", { key: 'a16f2a13564809011551bf96e34e100b0683493c', label: this.getTranslation('editor-link-menu.link'), value: ((_b = this.link) === null || _b === void 0 ? void 0 : _b.href) || '', type: "text", leadingIcon: "-lime-text-link", trailingIcon: "external_link", invalid: !isValid, onChange: this.handleLinkValueChange, onAction: this.handleLinkInputAction, onKeyDown: this.handleKeyDown, ref: (el) => (this.linkInput = el) }),
             h("div", { key: 'ee392b700a4293eb2b2121d08bfef852f8b4404e', class: "actions" }, h("limel-button", { key: 'be9f4711edf45a69f8087341e61fc4183c59ba2d', label: this.getTranslation('cancel'), onClick: this.handleCancel }), h("limel-button", { key: 'b958cae7915cc42133e5143589d4f454f8bb2ffa', primary: true, label: this.getTranslation('save'), disabled: !isValid, onClick: this.handleSave, ref: (el) => (this.saveButton = el), slot: "button" })),
         ];
     }

package/dist/collection/components/text-editor/prosemirror-adapter/editor-config.js

@@ -11,6 +11,7 @@ import { createImageInserterPlugin } from "./plugins/image/inserter";
 import { createImageViewPlugin } from "./plugins/image/view";
 import { createMenuStateTrackingPlugin } from "./plugins/menu-state-tracking-plugin";
 import { createActionBarInteractionPlugin } from "./plugins/menu-action-interaction-plugin";
+import { createListKeyHandlerPlugin } from "./plugins/list-key-handler";
 import { createTriggerPlugin } from "./plugins/trigger/factory";
 import { getTableNodes, getTableEditingPlugins } from "./plugins/table-plugin";
 import { getImageNode } from "./plugins/image/node";
@@ -62,7 +63,16 @@ export function buildEditorSchema(options) {
 export function buildEditorPlugins(options) {
     const { schema, menuCommandFactory, contentConverter, language, contentType, triggerCharacters, inlineImages, onNewLinkSelection, onImagePasted, onActiveItemsChange, } = options;
     return [
-        ...exampleSetup({ schema: schema, menuBar: false }),
+        // 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,
+            menuBar: false,
+            mapKeys: { 'Shift-Ctrl-8': false, 'Shift-Ctrl-9': false },
+        }),
         keymap(menuCommandFactory.buildKeymap()),
         createTriggerPlugin(triggerCharacters, contentConverter),
         createLinkPlugin(onNewLinkSelection),
@@ -70,6 +80,7 @@ export function buildEditorPlugins(options) {
         createImageViewPlugin(language),
         createMenuStateTrackingPlugin(editorMenuTypesArray, menuCommandFactory, onActiveItemsChange),
         createActionBarInteractionPlugin(menuCommandFactory),
+        createListKeyHandlerPlugin(schema),
         ...getTableEditingPlugins(contentType === 'html'),
     ];
 }

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-command-utils/active-state-utils.js

@@ -0,0 +1,36 @@
+import { LevelMapping } from "../types";
+export const setActiveMethodForMark = (command, markType) => {
+    command.active = (state) => {
+        const { from, $from, to, empty } = state.selection;
+        if (empty) {
+            return !!markType.isInSet(state.storedMarks || $from.marks());
+        }
+        return state.doc.rangeHasMark(from, to, markType);
+    };
+};
+export const setActiveMethodForNode = (command, nodeType, level) => {
+    command.active = (state) => {
+        const { $from } = state.selection;
+        const node = $from.node($from.depth);
+        if (node && node.type.name === nodeType.name) {
+            if (nodeType.name === LevelMapping.Heading && level) {
+                return node.attrs.level === level;
+            }
+            return true;
+        }
+        return false;
+    };
+};
+export 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;
+    };
+};

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-command-utils/list-utils.js

@@ -0,0 +1,270 @@
+var __rest = (this && this.__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;
+};
+import { NodeRange, } from "prosemirror-model";
+import { canSplit, findWrapping } from "prosemirror-transform";
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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 { order } = attrs, 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 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;
+        }
+        joinSameTypeBoundary(tr, targetType, joinPos);
+    }
+};

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-command-utils/node-utils.js

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export const findAncestorDepthOfType = ($pos, type) => {
+    for (let depth = $pos.depth; depth > 0; depth--) {
+        if ($pos.node(depth).type === type) {
+            return depth;
+        }
+    }
+    return null;
+};