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, Point, Range, Text, 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 match(m) {
            return Element.isElement(m);
        }
    });
}
/** 光标所在段落/标题；避免 getCurrentNodes 取到 list-item 等子块导致插入路径错误 */ function resolveParagraphOrHead(editor, preferred) {
    if ((preferred === null || preferred === void 0 ? void 0 : preferred[0]) && [
        'paragraph',
        'head'
    ].includes(preferred[0].type)) {
        return preferred;
    }
    var selection = editor.selection;
    if (selection) {
        var above = Editor.above(editor, {
            at: selection.anchor,
            match: function match(n) {
                return Element.isElement(n) && [
                    'paragraph',
                    'head'
                ].includes(n.type);
            }
        });
        if (above) {
            return above;
        }
    }
    var nodesResult = Editor.nodes(editor, {
        at: [],
        match: function match(n) {
            return Element.isElement(n) && [
                'paragraph',
                'head'
            ].includes(n.type);
        },
        mode: 'lowest'
    });
    if (Array.isArray(nodesResult) && nodesResult.length > 0) {
        var entry = nodesResult[0];
        if ((entry === null || entry === void 0 ? void 0 : entry[0]) && [
            'paragraph',
            'head'
        ].includes(entry[0].type)) {
            return entry;
        }
        return undefined;
    }
    var iter = nodesResult;
    if (iter && typeof iter.next === 'function') {
        var first = iter.next();
        return first.done ? undefined : first.value;
    }
    return undefined;
}
function firstLowestElement(editor) {
    var nodesResult = Editor.nodes(editor, {
        at: [],
        match: function match(n) {
            return Element.isElement(n);
        },
        mode: 'lowest'
    });
    if (Array.isArray(nodesResult) && nodesResult.length > 0) {
        return nodesResult[0];
    }
    var iter = nodesResult;
    if (iter && typeof iter.next === 'function') {
        var first = iter.next();
        return first.done ? undefined : first.value;
    }
    return undefined;
}
/**
 * 插入表格
 *
 * 在当前位置插入一个3x3的表格（包含表头行）。
 * 根据当前节点类型（段落、标题或列单元格）
 * 决定在何处插入表格及如何处理现有内容。
 *
 * @param editor Slate 编辑器实例
 * @param node 可选的节点，如果不提供则从编辑器获取
 */ export function insertTable(editor, node) {
    var _resolveParagraphOrHead;
    var _node_, _node_1, _currentNode_;
    if ((node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type) === 'column-cell') {
        NativeTableEditor.insertTable(editor, {
            rows: 3,
            cols: 3,
            at: _to_consumable_array(node[1]).concat([
                0
            ])
        });
        return;
    }
    if (node !== undefined && ![
        'paragraph',
        'head'
    ].includes((_node_1 = node[0]) === null || _node_1 === void 0 ? void 0 : _node_1.type)) {
        return;
    }
    var currentNode = node === undefined ? (_resolveParagraphOrHead = resolveParagraphOrHead(editor)) !== null && _resolveParagraphOrHead !== void 0 ? _resolveParagraphOrHead : firstLowestElement(editor) : resolveParagraphOrHead(editor, node);
    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, _currentNode_2;
        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]);
        // 使用原生表格编辑器插入表格
        NativeTableEditor.insertTable(editor, {
            rows: 3,
            cols: 3,
            at: path
        });
        if ((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])) {
            Transforms.delete(editor, {
                at: Path.next(path)
            });
        }
        Transforms.select(editor, Editor.start(editor, path));
    }
}
/**
 * 插入代码块
 *
 * 在当前位置插入代码块，并根据传入的类型设置语言和渲染模式。
 * 支持在列单元格内或普通段落/标题后插入代码块。
 *
 * @param editor Slate 编辑器实例
 * @param type 可选的代码块类型，'mermaid'表示流程图，'html'表示HTML渲染
 * @param node 可选的节点，如果不提供则从编辑器获取
 */ export function insertCodeBlock(editor, type, node) {
    var _resolveParagraphOrHead;
    var _node_;
    if (node !== undefined && ![
        'paragraph',
        'head'
    ].includes((_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type)) {
        return;
    }
    var currentNode = node === undefined ? (_resolveParagraphOrHead = resolveParagraphOrHead(editor)) !== null && _resolveParagraphOrHead !== void 0 ? _resolveParagraphOrHead : firstLowestElement(editor) : resolveParagraphOrHead(editor, node);
    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]
        });
    }
}
/**
 * 查找选区内的块级节点
 *
 * @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 match(n) {
            return Element.isElement(n) && !Editor.isInline(editor, n) && [
                'paragraph',
                'head'
            ].includes(n.type);
        }
    }));
    return blockNodes;
}
/**
 * 处理选区并设置标题格式
 *
 * @param editor - 编辑器实例
 * @param selection - 选区范围
 * @param level - 标题级别（1-3）
 */ function processSelectionForHeading(editor, selection, level) {
    var _Range_edges = _sliced_to_array(Range.edges(selection), 2), selStart = _Range_edges[0], selEnd = _Range_edges[1];
    // 找到所有涉及选中文本的段落/标题节点
    var blockNodes = findBlockNodesInSelection(editor, selection);
    if (blockNodes.length === 0) {
        return;
    }
    // 使用 withoutNormalizing 确保原子性操作
    Editor.withoutNormalizing(editor, function() {
        // 按路径倒序处理，从后往前，避免路径变化影响
        var sortedNodes = _to_consumable_array(blockNodes).sort(function(a, b) {
            return Path.compare(b[1], a[1]);
        });
        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
        try {
            for(var _iterator = sortedNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                var _step_value = _sliced_to_array(_step.value, 2), path = _step_value[1];
                if (!Editor.hasPath(editor, path)) {
                    continue;
                }
                var nodeStart = Editor.start(editor, path);
                var nodeEnd = Editor.end(editor, path);
                // 计算节点内的实际选区范围
                var actualStart = Point.isBefore(selStart, nodeStart) ? nodeStart : Point.isAfter(selStart, nodeEnd) ? nodeEnd : selStart;
                var actualEnd = Point.isAfter(selEnd, nodeEnd) ? nodeEnd : Point.isBefore(selEnd, nodeStart) ? nodeStart : selEnd;
                // 检查是否选中了整个节点
                var isWholeNodeSelected = (Point.isBefore(selStart, nodeStart) || Point.equals(selStart, nodeStart)) && (Point.isAfter(selEnd, nodeEnd) || Point.equals(selEnd, nodeEnd));
                if (isWholeNodeSelected) {
                    // 直接转换整个节点
                    Transforms.setNodes(editor, {
                        type: 'head',
                        level: level
                    }, {
                        at: path
                    });
                    continue;
                }
                // 如果选区不在节点内，跳过
                if (Point.isAfter(actualStart, actualEnd) || Point.equals(actualStart, actualEnd) || Point.isBefore(actualStart, nodeStart) || Point.isAfter(actualEnd, nodeEnd)) {
                    continue;
                }
                // 情况1: 选中了整个节点（从开始到结束）
                if (Point.equals(actualStart, nodeStart) && Point.equals(actualEnd, nodeEnd)) {
                    Transforms.setNodes(editor, {
                        type: 'head',
                        level: level
                    }, {
                        at: path
                    });
                    continue;
                }
                // 情况2: 只选中了节点的一部分，需要拆分
                var isAtStart = Point.equals(actualStart, nodeStart);
                var isAtEnd = Point.equals(actualEnd, nodeEnd);
                if (isAtStart && isAtEnd) {
                    continue;
                }
                // 获取原节点的属性
                var originalNode = Node.get(editor, path);
                if (!Element.isElement(originalNode)) {
                    continue;
                }
                if (isAtStart) {
                    // 选中在开始位置：拆分成两个节点（选中部分 + 剩余部分）
                    // 在 actualEnd 位置拆分节点
                    Transforms.splitNodes(editor, {
                        at: actualEnd
                    });
                    // 拆分后，原节点包含选中部分，新节点包含剩余部分
                    // 将原节点（选中部分）转换为标题
                    Transforms.setNodes(editor, {
                        type: 'head',
                        level: level
                    }, {
                        at: path
                    });
                } else if (isAtEnd) {
                    // 选中在结束位置：拆分成两个节点（前面部分 + 选中部分）
                    // 在 actualStart 位置拆分节点
                    Transforms.splitNodes(editor, {
                        at: actualStart
                    });
                    // 拆分后，原节点包含前面部分，新节点包含选中部分
                    // 将新节点（选中部分）转换为标题
                    var nextPath = Path.next(path);
                    if (Editor.hasPath(editor, nextPath)) {
                        Transforms.setNodes(editor, {
                            type: 'head',
                            level: level
                        }, {
                            at: nextPath
                        });
                    }
                } else {
                    // 选中在中间位置：拆分成三个节点（前面部分 + 选中部分 + 后面部分）
                    // 计算选中部分的长度（字符偏移量）
                    var selectionOffset = actualEnd.offset - actualStart.offset;
                    // 第一步：在 actualStart 位置拆分节点
                    Transforms.splitNodes(editor, {
                        at: actualStart
                    });
                    // 拆分后，原节点包含前面部分，新节点包含选中部分和后面部分
                    // 新节点的路径是 Path.next(path)
                    var middlePath = Path.next(path);
                    if (!Editor.hasPath(editor, middlePath)) {
                        continue;
                    }
                    // 第二步：在新节点内计算拆分点
                    // 使用偏移量来计算：在新节点开始位置 + 选中部分的长度
                    // 需要找到对应的文本节点和偏移量
                    var splitPoint = null;
                    // 遍历新节点内的文本节点，计算正确的拆分点
                    var textNodes = Array.from(Editor.nodes(editor, {
                        at: middlePath,
                        match: function match(n) {
                            return Text.isText(n);
                        }
                    }));
                    var currentOffset = 0;
                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                    try {
                        for(var _iterator1 = textNodes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
                            var _step_value1 = _sliced_to_array(_step1.value, 2), textNode = _step_value1[0], textPath = _step_value1[1];
                            if (!Text.isText(textNode)) {
                                continue;
                            }
                            var text = textNode.text;
                            if (typeof text !== 'string') {
                                continue;
                            }
                            var textLength = text.length;
                            var nextOffset = currentOffset + textLength;
                            // 如果选中结束位置在这个文本节点内
                            if (selectionOffset <= nextOffset) {
                                var offsetInText = selectionOffset - currentOffset;
                                splitPoint = {
                                    path: textPath,
                                    offset: offsetInText
                                };
                                break;
                            }
                            currentOffset = nextOffset;
                        }
                    } catch (err) {
                        _didIteratorError1 = true;
                        _iteratorError1 = err;
                    } finally{
                        try {
                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
                                _iterator1.return();
                            }
                        } finally{
                            if (_didIteratorError1) {
                                throw _iteratorError1;
                            }
                        }
                    }
                    // 如果找不到拆分点，使用新节点的结束位置
                    if (!splitPoint) {
                        var middleNodeEnd = Editor.end(editor, middlePath);
                        splitPoint = middleNodeEnd;
                    }
                    // 在新节点内的 splitPoint 位置拆分
                    Transforms.splitNodes(editor, {
                        at: splitPoint
                    });
                    // 拆分后，middlePath 包含选中部分，下一个节点包含后面部分
                    // 将 middlePath（选中部分）转换为标题
                    Transforms.setNodes(editor, {
                        type: 'head',
                        level: level
                    }, {
                        at: middlePath
                    });
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally{
            try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                    _iterator.return();
                }
            } finally{
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }
    });
}
/**
 * 设置标题级别
 *
 * 将当前段落或标题节点转换为指定级别的标题。
 * 如果级别为4，则转换为普通段落。
 * 如果存在选中文本，则只将选中的部分转换为标题，并拆分段落。
 *
 * @param editor Slate 编辑器实例
 * @param level 标题级别（1-3）或4（表示普通段落）
 */ export function setHeading(editor, level) {
    var _node_;
    var selection = editor.selection;
    // 如果级别为4，转换为段落
    if (level === 4) {
        convertToParagraph(editor);
        return;
    }
    // 如果有非折叠的选区，处理选中文本
    if (selection && !Range.isCollapsed(selection)) {
        processSelectionForHeading(editor, selection, level);
        return;
    }
    // 如果没有选区，保持原有行为：转换整个节点
    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])) {
        Transforms.setNodes(editor, {
            type: 'head',
            level: level
        }, {
            at: node[1]
        });
    }
}
export { convertToParagraph };
/**
 * 将标题节点转换为段落节点
 *
 * @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 match(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 match(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]
            });
        }
    }
}
