@ant-design/agentic-ui 2.29.7 → 2.29.8

package/dist/MarkdownEditor/editor/utils/editorCommands.js

@@ -0,0 +1,966 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { Editor, Element, Node, Path, Range, Transforms } from "slate";
+import { NativeTableEditor } from "../../utils/native-table";
+import { getListType, isListType } from "../plugins/withListsPlugin";
+import { EditorUtils } from "./editorUtils";
+/**
+ * 获取当前编辑器中的最低层级元素节点
+ */ export function getCurrentNodes(editor) {
+    return Editor.nodes(editor, {
+        mode: 'lowest',
+        match: function(m) {
+            return Element.isElement(m);
+        }
+    });
+}
+/**
+ * 插入表格
+ *
+ * 在当前位置插入一个3x3的表格（包含表头行）。
+ * 根据当前节点类型（段落、标题或列单元格）
+ * 决定在何处插入表格及如何处理现有内容。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */ export function insertTable(editor, node) {
+    var _currentNode_, _currentNode_1;
+    var currentNode = node || Array.from(getCurrentNodes(editor))[0];
+    if (currentNode && [
+        'paragraph',
+        'head'
+    ].includes(currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_ = currentNode[0]) === null || _currentNode_ === void 0 ? void 0 : _currentNode_.type)) {
+        var _currentNode_2, _currentNode_3;
+        var path = (currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_2 = currentNode[0]) === null || _currentNode_2 === void 0 ? void 0 : _currentNode_2.type) === 'paragraph' && !Node.string(currentNode[0]) ? currentNode[1] : Path.next(currentNode[1]);
+        // 使用原生表格编辑器插入表格
+        NativeTableEditor.insertTable(editor, {
+            rows: 3,
+            cols: 3,
+            at: path
+        });
+        if ((currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_3 = currentNode[0]) === null || _currentNode_3 === void 0 ? void 0 : _currentNode_3.type) === 'paragraph' && !Node.string(currentNode[0])) {
+            Transforms.delete(editor, {
+                at: Path.next(path)
+            });
+        }
+        Transforms.select(editor, Editor.start(editor, path));
+    }
+    if (currentNode && [
+        'column-cell'
+    ].includes(currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_1 = currentNode[0]) === null || _currentNode_1 === void 0 ? void 0 : _currentNode_1.type)) {
+        NativeTableEditor.insertTable(editor, {
+            rows: 3,
+            cols: 3,
+            at: _to_consumable_array(currentNode[1]).concat([
+                0
+            ])
+        });
+    }
+}
+/**
+ * 插入代码块
+ *
+ * 在当前位置插入代码块，并根据传入的类型设置语言和渲染模式。
+ * 支持在列单元格内或普通段落/标题后插入代码块。
+ *
+ * @param editor Slate 编辑器实例
+ * @param type 可选的代码块类型，'mermaid'表示流程图，'html'表示HTML渲染
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */ export function insertCodeBlock(editor, type, node) {
+    var currentNode = node || Array.from(getCurrentNodes(editor))[0];
+    if (currentNode && currentNode[0] && [
+        'paragraph',
+        'head'
+    ].includes(currentNode[0].type)) {
+        var path = currentNode[0].type === 'paragraph' && !Node.string(currentNode[0]) ? currentNode[1] : Path.next(currentNode[1]);
+        var lang = '';
+        if (type === 'mermaid') {
+            lang = 'mermaid';
+        }
+        Transforms.insertNodes(editor, {
+            type: 'code',
+            language: lang ? lang : undefined,
+            children: [
+                {
+                    text: "flowchart TD\n    Start --> Stop"
+                }
+            ],
+            render: type === 'html' ? true : undefined
+        }, {
+            at: path
+        });
+        Transforms.select(editor, Editor.end(editor, path));
+    }
+}
+/**
+ * 插入或移除引用块
+ *
+ * 如果当前节点已在引用块中，则移除引用块；
+ * 否则，将当前节点转换为引用块。
+ * 如果当前节点是标题，先将其转换为普通段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */ export function toggleQuote(editor, node) {
+    var _currentNode_, _currentNode_1;
+    var currentNode = node || Array.from(getCurrentNodes(editor))[0];
+    if (!currentNode || ![
+        'paragraph',
+        'head'
+    ].includes(currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_ = currentNode[0]) === null || _currentNode_ === void 0 ? void 0 : _currentNode_.type)) return;
+    if (Node.parent(editor, currentNode[1]).type === 'blockquote') {
+        Transforms.unwrapNodes(editor, {
+            at: Path.parent(currentNode[1])
+        });
+        return;
+    }
+    if ((currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_1 = currentNode[0]) === null || _currentNode_1 === void 0 ? void 0 : _currentNode_1.type) === 'head') {
+        Transforms.setNodes(editor, {
+            type: 'paragraph'
+        }, {
+            at: currentNode[1]
+        });
+    }
+    Transforms.wrapNodes(editor, {
+        type: 'blockquote',
+        children: []
+    });
+}
+/**
+ * 插入水平分割线
+ *
+ * 在当前位置插入水平分割线，并将光标定位到分割线后的位置。
+ * 如果分割线后没有内容，则自动插入一个空段落并将光标定位到该段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */ export function insertHorizontalLine(editor, node) {
+    var _currentNode_;
+    var currentNode = node || Array.from(getCurrentNodes(editor))[0];
+    if (currentNode && [
+        'paragraph',
+        'head'
+    ].includes(currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_ = currentNode[0]) === null || _currentNode_ === void 0 ? void 0 : _currentNode_.type)) {
+        var _currentNode_1;
+        var path = (currentNode === null || currentNode === void 0 ? void 0 : (_currentNode_1 = currentNode[0]) === null || _currentNode_1 === void 0 ? void 0 : _currentNode_1.type) === 'paragraph' && !Node.string(currentNode[0]) ? currentNode[1] : Path.next(currentNode[1]);
+        Transforms.insertNodes(editor, {
+            type: 'hr',
+            children: [
+                {
+                    text: ''
+                }
+            ]
+        }, {
+            at: path
+        });
+        if (Editor.hasPath(editor, Path.next(path))) {
+            Transforms.select(editor, Editor.start(editor, Path.next(path)));
+        } else {
+            Transforms.insertNodes(editor, {
+                type: 'paragraph',
+                children: [
+                    {
+                        text: ''
+                    }
+                ]
+            }, {
+                at: Path.next(path),
+                select: true
+            });
+        }
+    }
+}
+/**
+ * 将标题转换为普通段落
+ *
+ * 如果当前节点是标题类型，将其转换为普通段落
+ *
+ * @param editor Slate 编辑器实例
+ */ function convertToParagraph(editor) {
+    var _node_;
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
+    if (node && [
+        'head'
+    ].includes(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type)) {
+        Transforms.setNodes(editor, {
+            type: 'paragraph'
+        }, {
+            at: node[1]
+        });
+    }
+}
+/**
+ * 设置标题级别
+ *
+ * 将当前段落或标题节点转换为指定级别的标题。
+ * 如果级别为4，则转换为普通段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param level 标题级别（1-3）或4（表示普通段落）
+ */ export function setHeading(editor, level) {
+    var _node_;
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
+    if (level === 4) {
+        convertToParagraph(editor);
+        return;
+    }
+    if (node && [
+        'paragraph',
+        'head'
+    ].includes(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type) && EditorUtils.isTop(editor, node[1])) {
+        Transforms.setNodes(editor, {
+            type: 'head',
+            level: level
+        }, {
+            at: node[1]
+        });
+    }
+}
+export { convertToParagraph };
+/**
+ * 查找选区内的块级节点
+ *
+ * @param editor - 编辑器实例
+ * @param selection - 当前选区
+ * @returns 找到的块级节点数组，每个元素包含 [node, path]
+ */ function findBlockNodesInSelection(editor, selection) {
+    if (!selection) {
+        return [];
+    }
+    var blockNodes = Array.from(Editor.nodes(editor, {
+        at: selection,
+        match: function(n) {
+            return Element.isElement(n) && !Editor.isInline(editor, n) && [
+                'paragraph',
+                'head'
+            ].includes(n.type);
+        }
+    }));
+    return blockNodes;
+}
+/**
+ * 将标题节点转换为段落节点
+ *
+ * @param editor - 编辑器实例
+ * @param path - 标题节点的路径
+ */ function convertHeadingToParagraph(editor, path) {
+    Transforms.setNodes(editor, {
+        type: 'paragraph'
+    }, {
+        at: path
+    });
+    // 移除 level 属性
+    Transforms.unsetNodes(editor, 'level', {
+        at: path
+    });
+}
+/**
+ * 检查路径是否有后一个兄弟节点
+ * 注意：Path.hasNext 在 Slate 中不存在，所以需要自定义实现
+ */ function hasNext(editor, path) {
+    if (path.length === 0) {
+        return false;
+    }
+    try {
+        var parentPath = Path.parent(path);
+        if (!Editor.hasPath(editor, parentPath)) {
+            return false;
+        }
+        var parentNode = Node.get(editor, parentPath);
+        if (!Element.isElement(parentNode)) {
+            return false;
+        }
+        var index = path[path.length - 1];
+        return index < parentNode.children.length - 1;
+    } catch (unused) {
+        return false;
+    }
+}
+/**
+ * 查找相邻的列表节点
+ *
+ * @param editor - 编辑器实例
+ * @param path - 当前路径
+ * @param listType - 目标列表类型
+ * @returns 相邻列表的路径，如果不存在则返回 null
+ */ function findAdjacentList(editor, path, listType) {
+    // 如果是根路径，无法查找相邻节点
+    if (path.length === 0) {
+        return null;
+    }
+    // 检查前一个兄弟节点（使用 Slate 的 Path.hasPrevious）
+    if (Path.hasPrevious(path)) {
+        var prevPath = Path.previous(path);
+        if (Editor.hasPath(editor, prevPath)) {
+            var prevNode = Node.get(editor, prevPath);
+            if (isListType(prevNode) && prevNode.type === listType) {
+                return prevPath;
+            }
+        }
+    }
+    // 检查后一个兄弟节点（使用自定义 hasNext）
+    if (hasNext(editor, path)) {
+        var nextPath = Path.next(path);
+        if (Editor.hasPath(editor, nextPath)) {
+            var nextNode = Node.get(editor, nextPath);
+            if (isListType(nextNode) && nextNode.type === listType) {
+                return nextPath;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 合并列表项到相邻列表
+ *
+ * @param editor - 编辑器实例
+ * @param listItemPaths - 要合并的列表项路径数组
+ * @param targetListPath - 目标列表路径
+ */ function mergeIntoAdjacentList(editor, listItemPaths, targetListPath) {
+    var targetList = Node.get(editor, targetListPath);
+    if (!isListType(targetList)) {
+        return;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        // 按路径倒序处理，避免路径变化影响
+        for(var _iterator = listItemPaths.reverse()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var listItemPath = _step.value;
+            if (Editor.hasPath(editor, listItemPath)) {
+                var targetIndex = targetList.children.length;
+                Transforms.moveNodes(editor, {
+                    at: listItemPath,
+                    to: _to_consumable_array(targetListPath).concat([
+                        targetIndex
+                    ])
+                });
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * 解包列表为段落
+ *
+ * @param editor - 编辑器实例
+ * @param listItemPath - 列表项路径
+ * @param listPath - 列表路径
+ */ function unwrapListToParagraph(editor, listItemPath, listPath) {
+    // 先解包 list-item，保留其内容
+    Transforms.unwrapNodes(editor, {
+        at: listItemPath
+    });
+    // 如果列表为空，删除列表容器
+    var list = Node.get(editor, listPath);
+    if (isListType(list) && list.children.length === 0) {
+        Transforms.removeNodes(editor, {
+            at: listPath
+        });
+    }
+}
+/**
+ * 更新列表类型
+ *
+ * @param editor - 编辑器实例
+ * @param listPath - 列表路径
+ * @param mode - 列表类型模式
+ */ function updateListType(editor, listPath, mode) {
+    var listType = getListType(mode === 'ordered');
+    // 更新列表类型
+    Transforms.setNodes(editor, _object_spread({
+        type: listType
+    }, mode === 'ordered' && {
+        start: 1
+    }, mode === 'task' && {
+        task: true
+    }), {
+        at: listPath
+    });
+    // 移除旧的 order 属性（如果存在）
+    var listNode = Node.get(editor, listPath);
+    if (listNode.order !== undefined) {
+        Transforms.unsetNodes(editor, 'order', {
+            at: listPath
+        });
+    }
+    // 如果是任务列表，更新所有列表项的 checked 状态
+    if (mode === 'task') {
+        var listItems = Array.from(Editor.nodes(editor, {
+            match: function(n) {
+                return n.type === 'list-item';
+            },
+            at: listPath,
+            reverse: true,
+            mode: 'lowest'
+        }));
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = listItems[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), item = _step_value[0], itemPath = _step_value[1];
+                Transforms.setNodes(editor, {
+                    checked: item.checked || false
+                }, {
+                    at: itemPath
+                });
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+}
+/**
+ * 创建或转换列表
+ *
+ * 将当前段落或标题转换为指定类型的列表。
+ * 如果已经是列表项，则根据情况切换类型或解包。
+ *
+ * @param editor Slate 编辑器实例
+ * @param mode 列表类型 'ordered'(有序列表), 'unordered'(无序列表), 'task'(任务列表)
+ */ export function createList(editor, mode) {
+    var selection = editor.selection;
+    if (!selection) {
+        return;
+    }
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), curNode = _getCurrentNodes[0];
+    if (!curNode) {
+        return;
+    }
+    var targetListType = getListType(mode === 'ordered');
+    // 情况1: 当前节点已经是 list-item，处理反向转换或类型切换
+    if (curNode[0].type === 'list-item') {
+        var listItemPath = curNode[1];
+        var listPath = Path.parent(listItemPath);
+        var listNode = Node.get(editor, listPath);
+        if (isListType(listNode)) {
+            // 如果列表类型与目标类型相同，执行解包
+            if (listNode.type === targetListType && mode !== 'task') {
+                Editor.withoutNormalizing(editor, function() {
+                    unwrapListToParagraph(editor, listItemPath, listPath);
+                });
+                return;
+            }
+            // 否则更新列表类型
+            Editor.withoutNormalizing(editor, function() {
+                updateListType(editor, listPath, mode);
+            });
+            return;
+        }
+    }
+    // 情况2: 当前节点在 list-item 中（paragraph 在 list-item 内）
+    if ([
+        'paragraph',
+        'head'
+    ].includes(curNode[0].type)) {
+        var parent = Editor.parent(editor, curNode[1]);
+        if (parent && Element.isElement(parent[0]) && parent[0].type === 'list-item' && !Path.hasPrevious(curNode[1])) {
+            var listParent = Editor.parent(editor, parent[1]);
+            if (listParent && Element.isElement(listParent[0]) && isListType(listParent[0])) {
+                // 如果列表类型与目标类型相同，且不是任务列表，执行解包
+                var isTaskList = listParent[0].type === 'bulleted-list' && listParent[0].task === true;
+                if (listParent[0].type === targetListType && mode !== 'task' && !isTaskList) {
+                    Editor.withoutNormalizing(editor, function() {
+                        unwrapListToParagraph(editor, parent[1], listParent[1]);
+                    });
+                    return;
+                }
+                // 否则更新列表类型
+                Editor.withoutNormalizing(editor, function() {
+                    updateListType(editor, listParent[1], mode);
+                });
+                return;
+            }
+        }
+    }
+    // 情况3: 将节点转换为列表
+    if (![
+        'paragraph',
+        'head'
+    ].includes(curNode[0].type)) {
+        return;
+    }
+    // 查找需要转换的块级节点
+    var blockNodes = findBlockNodesInSelection(editor, selection);
+    // 如果没有找到节点，且选区已折叠，使用当前节点
+    if (blockNodes.length === 0 && Range.isCollapsed(selection)) {
+        if ([
+            'paragraph',
+            'head'
+        ].includes(curNode[0].type)) {
+            blockNodes.push(curNode);
+        } else {
+            return;
+        }
+    }
+    // 处理部分选中：如果选区只选中了节点的一部分文本，转换整个节点
+    if (blockNodes.length === 0 && selection && !Range.isCollapsed(selection)) {
+        // 尝试获取选区覆盖的所有块级节点
+        var _Range_edges = _sliced_to_array(Range.edges(selection), 2), start = _Range_edges[0], end = _Range_edges[1];
+        var startPath = start.path;
+        var endPath = end.path;
+        // 如果起始和结束在同一路径，说明是单个节点的部分选中
+        if (Path.equals(startPath.slice(0, -1), endPath.slice(0, -1))) {
+            var parentPath = Path.parent(startPath);
+            var parentNode = Node.get(editor, parentPath);
+            if (Element.isElement(parentNode) && [
+                'paragraph',
+                'head'
+            ].includes(parentNode.type)) {
+                blockNodes.push([
+                    parentNode,
+                    parentPath
+                ]);
+            }
+        } else {
+            // 跨节点选中，查找所有涉及的块级节点
+            var allBlockNodes = Array.from(Editor.nodes(editor, {
+                at: selection,
+                match: function(n) {
+                    return Element.isElement(n) && !Editor.isInline(editor, n) && [
+                        'paragraph',
+                        'head'
+                    ].includes(n.type);
+                }
+            }));
+            blockNodes = allBlockNodes;
+        }
+    }
+    if (blockNodes.length === 0) {
+        return;
+    }
+    // 过滤掉已经在列表中的节点（避免重复包装）
+    blockNodes = blockNodes.filter(function(param) {
+        var _param = _sliced_to_array(param, 2), path = _param[1];
+        var parent = Editor.parent(editor, path);
+        return !Element.isElement(parent[0]) || parent[0].type !== 'list-item';
+    });
+    if (blockNodes.length === 0) {
+        return;
+    }
+    // 使用 withoutNormalizing 确保原子性
+    Editor.withoutNormalizing(editor, function() {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // 步骤1: 处理标题降级和空节点
+            for(var _iterator = blockNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), node = _step_value[0], path = _step_value[1];
+                if (!node || !Element.isElement(node)) {
+                    continue;
+                }
+                if (node.type === 'head') {
+                    convertHeadingToParagraph(editor, path);
+                }
+                // 处理空节点：确保节点有内容
+                // 注意：convertHeadingToParagraph 可能改变了节点，需要重新获取
+                if (!Editor.hasPath(editor, path)) {
+                    continue;
+                }
+                var currentNode = Node.get(editor, path);
+                if (currentNode && Element.isElement(currentNode) && currentNode.type === 'paragraph' && Node.string(currentNode).trim() === '') {
+                // 空节点保持原样，后续会正常包装
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        // 步骤2: 包装节点为 list-item
+        var listItemPaths = [];
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = blockNodes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var _step_value1 = _sliced_to_array(_step1.value, 2), path1 = _step_value1[1];
+                // 检查节点是否已经是 list-item（可能在转换过程中变化）
+                var currentNode1 = Node.get(editor, path1);
+                if (Element.isElement(currentNode1) && currentNode1.type === 'list-item') {
+                    listItemPaths.push(path1);
+                    continue;
+                }
+                // 检查路径是否有效且不是根路径
+                if (!Editor.hasPath(editor, path1) || path1.length === 0) {
+                    continue;
+                }
+                // 包装为 list-item
+                var listItemProps = _object_spread({
+                    type: 'list-item',
+                    mentions: [],
+                    id: ''
+                }, mode === 'task' && {
+                    checked: false
+                });
+                Transforms.wrapNodes(editor, listItemProps, {
+                    at: path1
+                });
+                // 更新路径（因为包装后路径会变化）
+                // wrapNodes 后，list-item 的路径就是原来的 path
+                // 原节点现在在 [path, 0] 位置
+                // 所以 list-item 的路径就是 path
+                if (Editor.hasPath(editor, path1)) {
+                    var listItemNode = Node.get(editor, path1);
+                    if (Element.isElement(listItemNode) && listItemNode.type === 'list-item') {
+                        listItemPaths.push(path1);
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        // 步骤3: 包装 list-item 为列表
+        if (listItemPaths.length === 0) {
+            return;
+        }
+        // 检查第一个节点前后是否有相同类型的列表
+        var firstPath = listItemPaths[0];
+        // 验证路径有效性
+        if (!Editor.hasPath(editor, firstPath)) {
+            return;
+        }
+        // 获取第一个 list-item 的父路径（可能是容器）
+        var firstListItemParentPath;
+        try {
+            // 检查路径是否有效且不是根路径
+            if (firstPath.length === 0) {
+                // 如果是根路径，无法创建列表，直接返回
+                return;
+            }
+            var firstListItemParent = Editor.parent(editor, firstPath);
+            if (firstListItemParent && firstListItemParent[1]) {
+                firstListItemParentPath = firstListItemParent[1];
+            } else {
+                // 如果无法获取父路径，使用 Path.parent
+                firstListItemParentPath = Path.parent(firstPath);
+            }
+        } catch (error) {
+            // 如果无法获取父路径，使用 Path.parent
+            if (firstPath.length > 0) {
+                firstListItemParentPath = Path.parent(firstPath);
+            } else {
+                // 根路径无法创建列表
+                return;
+            }
+        }
+        // 检查相邻列表（在同一个父容器层级）
+        var adjacentListPath = findAdjacentList(editor, firstListItemParentPath, targetListType);
+        if (adjacentListPath) {
+            // 合并到相邻列表
+            mergeIntoAdjacentList(editor, listItemPaths, adjacentListPath);
+            // 删除空的列表容器（如果有）
+            var processedListPaths = new Set();
+            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+            try {
+                for(var _iterator2 = listItemPaths[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                    var listItemPath = _step2.value;
+                    if (Editor.hasPath(editor, listItemPath)) {
+                        var listItemParent = Editor.parent(editor, listItemPath);
+                        if (Element.isElement(listItemParent[0]) && isListType(listItemParent[0])) {
+                            var listPath = listItemParent[1];
+                            if (!processedListPaths.has(listPath)) {
+                                processedListPaths.add(listPath);
+                                var list = listItemParent[0];
+                                if (list.children.length === 0) {
+                                    Transforms.removeNodes(editor, {
+                                        at: listPath
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                _didIteratorError2 = true;
+                _iteratorError2 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                        _iterator2.return();
+                    }
+                } finally{
+                    if (_didIteratorError2) {
+                        throw _iteratorError2;
+                    }
+                }
+            }
+        } else {
+            // 创建新列表
+            var listProps = _object_spread({
+                type: targetListType
+            }, mode === 'ordered' && {
+                start: 1
+            }, mode === 'task' && {
+                task: true
+            });
+            // 包装第一个 list-item
+            Transforms.wrapNodes(editor, listProps, {
+                at: firstPath
+            });
+            // 将其他 list-item 移动到同一个列表中
+            // 包装后，list 的路径是 firstPath 的父路径
+            if (firstPath.length === 0) {
+                return; // 根路径无法创建列表
+            }
+            var listPath1 = Path.parent(firstPath);
+            // 验证列表路径有效
+            if (!Editor.hasPath(editor, listPath1)) {
+                return;
+            }
+            for(var i = 1; i < listItemPaths.length; i++){
+                var listItemPath1 = listItemPaths[i];
+                if (Editor.hasPath(editor, listItemPath1)) {
+                    // 检查是否已经在列表中
+                    var listItemParent1 = Editor.parent(editor, listItemPath1);
+                    if (Element.isElement(listItemParent1[0]) && isListType(listItemParent1[0])) {
+                        // 已经在列表中，移动到目标列表
+                        var targetList = Node.get(editor, listPath1);
+                        if (isListType(targetList)) {
+                            var targetIndex = targetList.children.length;
+                            Transforms.moveNodes(editor, {
+                                at: listItemPath1,
+                                to: _to_consumable_array(listPath1).concat([
+                                    targetIndex
+                                ])
+                            });
+                        }
+                    } else {
+                        // 包装为列表，然后移动到目标列表
+                        Transforms.wrapNodes(editor, listProps, {
+                            at: listItemPath1
+                        });
+                        if (listItemPath1.length === 0) {
+                            continue; // 跳过根路径
+                        }
+                        var newListPath = Path.parent(listItemPath1);
+                        var targetList1 = Node.get(editor, listPath1);
+                        if (isListType(targetList1)) {
+                            var targetIndex1 = targetList1.children.length;
+                            Transforms.moveNodes(editor, {
+                                at: listItemPath1,
+                                to: _to_consumable_array(listPath1).concat([
+                                    targetIndex1
+                                ])
+                            });
+                            // 删除空的列表容器
+                            if (Editor.hasPath(editor, newListPath)) {
+                                var emptyList = Node.get(editor, newListPath);
+                                if (isListType(emptyList) && emptyList.children.length === 0) {
+                                    Transforms.removeNodes(editor, {
+                                        at: newListPath
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // 步骤4: 更新光标位置
+        if (listItemPaths.length > 0) {
+            var firstListItemPath = listItemPaths[0];
+            if (Editor.hasPath(editor, firstListItemPath)) {
+                Transforms.select(editor, Editor.start(editor, firstListItemPath));
+            }
+        }
+    });
+}
+/**
+ * 增加标题级别（使标题变小）
+ *
+ * 将段落转换为4级标题，
+ * 或将标题级别从1级改为普通段落，
+ * 或将其他级别标题升级一级（数字变小）
+ *
+ * @param editor Slate 编辑器实例
+ */ export function increaseHeadingLevel(editor) {
+    var _node_;
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
+    if (node && [
+        'paragraph',
+        'head'
+    ].includes(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type) && EditorUtils.isTop(editor, node[1])) {
+        var _node_1;
+        if ((node === null || node === void 0 ? void 0 : (_node_1 = node[0]) === null || _node_1 === void 0 ? void 0 : _node_1.type) === 'paragraph') {
+            Transforms.setNodes(editor, {
+                type: 'head',
+                level: 4
+            }, {
+                at: node[1]
+            });
+        } else if (node[0].level === 1) {
+            Transforms.setNodes(editor, {
+                type: 'paragraph'
+            }, {
+                at: node[1]
+            });
+        } else {
+            Transforms.setNodes(editor, {
+                level: node[0].level - 1
+            }, {
+                at: node[1]
+            });
+        }
+    }
+}
+/**
+ * 降低标题级别（使标题变大）
+ *
+ * 将段落转换为1级标题，
+ * 或将4级标题改为普通段落，
+ * 或将其他级别标题降级一级（数字变大）
+ *
+ * @param editor Slate 编辑器实例
+ */ export function decreaseHeadingLevel(editor) {
+    var _node_;
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
+    if (node && [
+        'paragraph',
+        'head'
+    ].includes(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type) && EditorUtils.isTop(editor, node[1])) {
+        var _node_1;
+        if ((node === null || node === void 0 ? void 0 : (_node_1 = node[0]) === null || _node_1 === void 0 ? void 0 : _node_1.type) === 'paragraph') {
+            Transforms.setNodes(editor, {
+                type: 'head',
+                level: 1
+            }, {
+                at: node[1]
+            });
+        } else if (node[0].level === 4) {
+            Transforms.setNodes(editor, {
+                type: 'paragraph'
+            }, {
+                at: node[1]
+            });
+        } else {
+            Transforms.setNodes(editor, {
+                level: node[0].level + 1
+            }, {
+                at: node[1]
+            });
+        }
+    }
+}