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_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 _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 ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
    if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) {
            symbols = symbols.filter(function(sym) {
                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
            });
        }
        keys.push.apply(keys, symbols);
    }
    return keys;
}
function _object_spread_props(target, source) {
    source = source != null ? source : {};
    if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
        ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
}
function _to_consumable_array(arr) {
    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
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);
}
/* eslint-disable @typescript-eslint/no-loop-func */ /* eslint-disable no-case-declarations */ /* eslint-disable no-param-reassign */ /* eslint-disable @typescript-eslint/no-use-before-define */ import { Node } from "slate";
import stringWidth from "string-width";
import { debugInfo } from "../../../Utils/debugUtils";
import { JINJA_DOLLAR_PLACEHOLDER } from "./constants";
import { getMediaType } from "../utils/dom";
var inlineNode = new Set([
    'break'
]);
/**
 * 尝试使用插件转换节点
 */ var tryPluginConversion = function tryPluginConversion(node, preString, parent, plugins) {
    if (!(plugins === null || plugins === void 0 ? void 0 : plugins.length)) return null;
    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
    try {
        for(var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
            var plugin = _step.value;
            var _plugin_toMarkdown;
            var rule = (_plugin_toMarkdown = plugin.toMarkdown) === null || _plugin_toMarkdown === void 0 ? void 0 : _plugin_toMarkdown.find(function(r) {
                return r.match(node);
            });
            if (!rule) continue;
            var converted = rule.convert(node);
            return convertPluginNode(converted, preString, parent, plugins);
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally{
        try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
            }
        } finally{
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
    return null;
};
/**
 * 转换插件节点为 Markdown 字符串
 */ var convertPluginNode = function convertPluginNode(converted, preString, parent, plugins) {
    switch(converted.type){
        case 'code':
            return convertCodeNode(converted, preString);
        case 'blockquote':
            return convertBlockquoteNode(converted, preString, parent, plugins);
        case 'paragraph':
            return convertParagraphNode(converted, preString, parent, plugins);
        case 'heading':
            return convertHeadingNode(converted, preString, parent, plugins);
        case 'text':
            return converted.value || '';
        default:
            return '';
    }
};
/**
 * 转换代码节点
 */ var convertCodeNode = function convertCodeNode(codeNode, preString) {
    var language = codeNode.lang || '';
    var value = codeNode.value || '';
    if (!(value === null || value === void 0 ? void 0 : value.trim())) {
        return "".concat(preString, "```").concat(language, "\n").concat(preString, "```");
    }
    var codeLines = value.split('\n');
    var indentedCode = codeLines.map(function(line, index) {
        var isFirstOrLast = index === 0 || index === codeLines.length - 1;
        return isFirstOrLast ? line : preString + line;
    }).join('\n');
    return "".concat(preString, "```").concat(language, "\n").concat(indentedCode, "\n").concat(preString, "```");
};
/**
 * 转换引用节点
 */ var convertBlockquoteNode = function convertBlockquoteNode(blockquoteNode, preString, parent, plugins) {
    return '> ' + parserSlateNodeToMarkdown(blockquoteNode.children || [], preString, _to_consumable_array(parent).concat([
        _object_spread_props(_object_spread({}, blockquoteNode), {
            converted: true
        })
    ]), plugins);
};
/**
 * 转换段落节点
 */ var convertParagraphNode = function convertParagraphNode(paragraphNode, preString, parent, plugins) {
    return preString + parserSlateNodeToMarkdown(paragraphNode.children || [], preString, _to_consumable_array(parent).concat([
        _object_spread_props(_object_spread({}, paragraphNode), {
            converted: true
        })
    ]), plugins);
};
/**
 * 转换标题节点
 */ var convertHeadingNode = function convertHeadingNode(headingNode, preString, parent, plugins) {
    var level = headingNode.depth || 1;
    var content = parserSlateNodeToMarkdown(headingNode.children || [], preString, _to_consumable_array(parent).concat([
        _object_spread_props(_object_spread({}, headingNode), {
            converted: true
        })
    ]), plugins);
    return '#'.repeat(level) + ' ' + content.replace(/\n+$/, '');
};
/**
 * 解析单个 Slate 节点并转换为对应的 Markdown 字符串
 *
 * @param node - 要解析的 Slate 节点，包含 type、children、value 等属性
 * @param preString - 前缀字符串，用于处理缩进和格式化，默认为空字符串
 * @param parent - 父节点数组，用于上下文信息和嵌套处理，默认为空数组
 * @param plugins - 可选的插件数组，用于自定义转换逻辑
 * @returns 解析后的 Markdown 字符串
 *
 * @description
 * 该函数是 Slate 节点到 Markdown 转换的核心处理器，支持以下节点类型：
 *
 * **容器节点：**
 * - `card`: 卡片容器，递归处理子节点
 * - `paragraph`: 段落节点，添加前缀并处理子节点
 * - `blockquote`: 引用块，递归处理子节点
 * - `list`: 列表容器，递归处理列表项
 * - `list-item`: 列表项，递归处理子节点
 *
 * **标题节点：**
 * - `head`: 标题节点，根据 level 生成对应级别的 Markdown 标题
 *
 * **代码节点：**
 * - `code`: 代码块，支持三种模式：
 *   - HTML 渲染模式（language='html' && render=true）
 *   - Frontmatter 模式（frontmatter=true）
 *   - 普通代码块模式（默认）
 *
 * **媒体节点：**
 * - `image`: 图片节点，支持 width、height、block 参数，URL 参数化
 * - `media`: 多媒体节点，根据类型生成 video、img 或 iframe 标签
 * - `attach`: 附件节点，生成下载链接
 *
 * **表格节点：**
 * - `table`: 表格节点，调用 table 函数处理
 * - `chart`: 图表节点，以表格形式渲染
 * - `column-group`: 列组节点，以表格形式渲染
 * - `description`: 描述列表，转换为表格格式
 *
 * **其他节点：**
 * - `schema`: 模式定义，生成 schema 代码块
 * - `link-card`: 链接卡片，生成 Markdown 链接格式
 * - `hr`: 水平分割线，生成 `***`
 * - `break`: 换行节点，生成 `<br/>` 标签
 * - `footnoteDefinition`: 脚注定义，生成脚注引用格式
 * - 文本节点：调用 composeText 函数处理文本样式
 *
 * **空节点：**
 * - `card-before`, `card-after`: 卡片前后占位符，不输出内容
 *
 * @example
 * ```typescript
 * // 解析段落节点
 * const paragraphNode = { type: 'paragraph', children: [{ text: 'Hello' }] };
 * const result = parserNode(paragraphNode, '', []);
 * // 输出: "Hello"
 *
 * // 解析标题节点
 * const headNode = { type: 'head', level: 2, children: [{ text: 'Title' }] };
 * const result = parserNode(headNode, '', []);
 * // 输出: "## Title"
 *
 * // 解析代码块
 * const codeNode = { type: 'code', language: 'javascript', value: 'console.log("hello");' };
 * const result = parserNode(codeNode, '', []);
 * // 输出: "```javascript\nconsole.log(\"hello\");\n```"
 * ```
 */ var parserNode = function parserNode(node) {
    var preString = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : '', parent = arguments.length > 2 ? arguments[2] : void 0, plugins = arguments.length > 3 ? arguments[3] : void 0;
    var _parent_;
    var str = '';
    if (!node) {
        debugInfo('parserSlateNodeToMarkdown.parserNode - 空节点');
        return str;
    }
    debugInfo('parserSlateNodeToMarkdown.parserNode - 开始解析节点', {
        nodeType: node.type,
        preString: preString,
        parentType: (_parent_ = parent[parent.length - 1]) === null || _parent_ === void 0 ? void 0 : _parent_.type
    });
    // 首先尝试使用插件处理
    var pluginResult = tryPluginConversion(node, preString, parent, plugins);
    if (pluginResult !== null) {
        debugInfo('parserSlateNodeToMarkdown.parserNode - 使用插件转换', {
            resultLength: pluginResult.length
        });
        return pluginResult;
    }
    switch(node.type){
        case 'card-before':
        case 'card-after':
            break;
        case 'card':
            str += handleCard(node, preString, parent, plugins);
            break;
        case 'paragraph':
            str += handleParagraph(node, preString, parent, plugins);
            break;
        case 'head':
            str += handleHead(node, preString, parent, plugins);
            break;
        case 'code':
        case 'apaasify':
            str += handleCode(node, preString);
            break;
        case 'attach':
            str += handleAttach(node);
            break;
        case 'blockquote':
            str += handleBlockquote(node, preString, parent, plugins);
            break;
        case 'image':
            str += handleImage(node);
            break;
        case 'media':
            str += handleMedia(node);
            break;
        case 'bulleted-list':
        case 'numbered-list':
        case 'list':
            str += '\n' + handleList(node, preString, parent, plugins) + '\n\n';
            break;
        case 'list-item':
            str += handleListItem(node, preString, parent, plugins);
            break;
        case 'table':
            str += table(node, parent, plugins);
            break;
        case 'chart':
            str += table(node, parent, plugins);
            break;
        case 'schema':
            str += handleSchema(node);
            break;
        case 'link-card':
            str += handleLinkCard(node);
            break;
        case 'hr':
            str += handleHr(preString);
            break;
        case 'break':
            str += handleBreak(preString);
            break;
        case 'footnoteDefinition':
            str += handleFootnoteDefinition(node);
            break;
        default:
            str += handleDefault(node, parent);
            break;
    }
    debugInfo('parserSlateNodeToMarkdown.parserNode - 节点解析完成', {
        nodeType: node.type,
        resultLength: str.length,
        resultPreview: str.substring(0, 50)
    });
    return str;
};
/**
 * 将 Slate 节点树解析为 Markdown 字符串。
 *
 * @param tree - Slate 节点树。
 * @param preString - 前缀字符串，默认为空字符串。
 * @param parent - 父节点数组，默认为包含一个根节点的数组。
 * @returns 解析后的 Markdown 字符串。
 *
 * 该函数遍历 Slate 节点树，并根据节点类型和属性生成相应的 Markdown 字符串。
 * 对于具有其他属性的节点，会将这些属性转换为 JSON 字符串并作为注释插入。
 * 对于列表项、引用块、段落等不同类型的节点，会根据其特定的格式生成相应的 Markdown。
 */ export var parserSlateNodeToMarkdown = function parserSlateNodeToMarkdown(tree) {
    var _loop = function(i) {
        var _tree_, _tree_1, _tree_2, _tree_3, _tree_4, _tree_5;
        var node = tree[i];
        debugInfo("parserSlateNodeToMarkdown - 处理节点 ".concat(i, "/").concat(tree.length), {
            nodeType: node === null || node === void 0 ? void 0 : node.type,
            hasOtherProps: !!(node === null || node === void 0 ? void 0 : node.otherProps),
            otherPropsKeys: (node === null || node === void 0 ? void 0 : node.otherProps) ? Object.keys(node.otherProps) : []
        });
        if (node.otherProps && Object.keys(node.otherProps).length) {
            debugInfo("parserSlateNodeToMarkdown - 处理 otherProps ".concat(i), {
                nodeType: node.type,
                originalOtherProps: node.otherProps
            });
            var configProps = _object_spread({}, node.otherProps);
            delete configProps['columns'];
            delete configProps['dataSource'];
            delete configProps['finished'];
            // paragraph/head 的 align 已输出到 <p align> / <h align>，不再写入注释
            if (node.type === 'paragraph' || node.type === 'head') {
                delete configProps['align'];
            }
            if (node.type === 'link-card') {
                configProps.type = 'card';
                configProps.url = encodeURI(node === null || node === void 0 ? void 0 : node.url);
                configProps.name = node.name || node.title || configProps.name;
                configProps.description = node.description || configProps.description;
                configProps.icon = node.icon || configProps.icon;
                debugInfo("parserSlateNodeToMarkdown - link-card 转换 ".concat(i), {
                    configProps: configProps
                });
            }
            Object.keys(configProps).forEach(function(key) {
                if (_type_of(configProps[key]) === 'object' && configProps[key]) {
                    if (Array.isArray(configProps[key]) && configProps[key].length === 0) {
                        delete configProps[key];
                        return;
                    }
                    if (Object.keys(configProps[key]).length === 0) {
                        delete configProps[key];
                        return;
                    }
                }
            });
            // 只有当 configProps 不为空对象时才生成注释
            // 检查 configProps 是否为空对象（删除 finished 后可能变成空对象）
            var hasValidProps = Object.keys(configProps).length > 0;
            if (hasValidProps) {
                /**
         * 将对象转换为数组（处理 {0: {...}, 1: {...}} 这种错误格式）
         * @param obj - 要转换的对象
         * @returns 转换后的数组，如果不是数字键对象则返回原对象
         */ var convertObjectToArray = function convertObjectToArray(obj) {
                    if (!obj || (typeof obj === "undefined" ? "undefined" : _type_of(obj)) !== 'object' || Array.isArray(obj)) {
                        return obj;
                    }
                    var keys = Object.keys(obj);
                    // 检查是否所有键都是数字字符串（如 "0", "1", "2"）
                    var allNumericKeys = keys.length > 0 && keys.every(function(key) {
                        return /^\d+$/.test(key);
                    });
                    if (allNumericKeys) {
                        // 按数字顺序排序并转换为数组
                        var sortedKeys = keys.sort(function(a, b) {
                            return parseInt(a, 10) - parseInt(b, 10);
                        });
                        return sortedKeys.map(function(key) {
                            return obj[key];
                        });
                    }
                    return obj;
                };
                // 对于图表类型，配置应该总是以数组形式存储在 config 中
                if (node.type === 'chart') {
                    debugInfo("parserSlateNodeToMarkdown - 处理图表节点 ".concat(i), {
                        originalConfig: configProps.config,
                        hasChartType: !!configProps.chartType
                    });
                    var chartConfig = configProps.config;
                    // 如果 config 不存在，但 configProps 看起来像图表配置（有 chartType），使用 configProps
                    if (!chartConfig && configProps.chartType) {
                        chartConfig = configProps;
                    }
                    // 如果 chartConfig 是对象且键都是数字（如 {0: {...}}），转换为数组
                    chartConfig = convertObjectToArray(chartConfig);
                    debugInfo("parserSlateNodeToMarkdown - 图表配置转换后 ".concat(i), {
                        chartConfig: chartConfig,
                        isArray: Array.isArray(chartConfig)
                    });
                    // 如果 chartConfig 还不是数组，将其包装为数组
                    // 这样可以确保即使只有一个配置项，也会被放入数组中
                    if (!Array.isArray(chartConfig)) {
                        // 如果 chartConfig 是对象，检查是否是 {0: {...}} 格式但转换失败的情况
                        if (chartConfig && (typeof chartConfig === "undefined" ? "undefined" : _type_of(chartConfig)) === 'object') {
                            var keys = Object.keys(chartConfig);
                            // 如果只有一个键且是数字，提取该值
                            if (keys.length === 1 && /^\d+$/.test(keys[0])) {
                                chartConfig = [
                                    chartConfig[keys[0]]
                                ];
                            } else if (chartConfig.chartType) {
                                // 如果 chartConfig 有 chartType，说明是单个配置对象
                                chartConfig = [
                                    chartConfig
                                ];
                            } else {
                                // 其他情况，也包装为数组
                                chartConfig = [
                                    chartConfig
                                ];
                            }
                        } else if (chartConfig) {
                            chartConfig = [
                                chartConfig
                            ];
                        } else {
                            chartConfig = [];
                        }
                    }
                    // 序列化为 { config: [...] } 格式
                    if (chartConfig.length > 0) {
                        str += "<!--".concat(JSON.stringify({
                            config: chartConfig
                        }), "-->\n");
                    }
                } else {
                    // 非图表类型，使用原有逻辑
                    var nodeConfig = configProps;
                    // 如果 nodeConfig 是对象且键都是数字（如 {0: {...}}），转换为数组
                    nodeConfig = convertObjectToArray(nodeConfig);
                    var propsToSerialize = void 0;
                    // 如果 nodeConfig 是数组，直接使用数组
                    if (Array.isArray(nodeConfig)) {
                        propsToSerialize = nodeConfig;
                    } else {
                        // 如果是对象，过滤掉 undefined 值，但保留 false 值
                        propsToSerialize = Object.keys(nodeConfig).reduce(function(acc, key) {
                            if (nodeConfig[key] !== undefined) {
                                acc[key] = nodeConfig[key];
                            }
                            return acc;
                        }, {});
                    }
                    // 对于数组，直接序列化；对于对象，检查是否为空
                    if (Array.isArray(propsToSerialize)) {
                        if (propsToSerialize.length > 0) {
                            str += "<!--".concat(JSON.stringify({
                                config: propsToSerialize
                            }), "-->\n");
                        }
                    } else if (propsToSerialize && (typeof propsToSerialize === "undefined" ? "undefined" : _type_of(propsToSerialize)) === 'object' && Object.keys(propsToSerialize).length > 0) {
                        str += "<!--".concat(JSON.stringify(propsToSerialize), "-->\n");
                    }
                }
            }
        }
        var p = parent.at(-1) || {};
        if (p.type === 'list-item') {
            str += parserNode(node, '', parent, plugins);
        // if (i !== tree.length - 1) {
        //   str += '\n';
        // }
        } else if (p.type === 'blockquote') {
            str += parserNode(node, preString + '> ', parent, plugins);
            if (i !== tree.length - 1) {
                str += '\n' + preString + '> ';
            }
        } else if (node.type === 'blockquote') {
            var _node_children, _node_children1;
            debugInfo("parserSlateNodeToMarkdown - 处理引用块 ".concat(i), {
                childrenCount: (_node_children = node.children) === null || _node_children === void 0 ? void 0 : _node_children.length,
                hasNestedBlockquote: (_node_children1 = node.children) === null || _node_children1 === void 0 ? void 0 : _node_children1.some(function(c) {
                    return c.type === 'blockquote';
                })
            });
            // Handle blockquotes
            var blockquoteContent = node.children.map(function(child) {
                if (child.type === 'blockquote') {
                    // For nested blockquotes, increase the level
                    return parserNode(child, '> ', _to_consumable_array(parent).concat([
                        node
                    ]), plugins);
                } else {
                    // For regular content, maintain the current level
                    var content = parserNode(child, '', _to_consumable_array(parent).concat([
                        node
                    ]), plugins);
                    if (!content.trim()) {
                        // For empty lines, just add the blockquote marker
                        return '>';
                    }
                    // For regular content, add blockquote marker and handle multi-line content
                    return content.split('\n').map(function(line) {
                        return '> ' + line;
                    }).join('\n');
                }
            }).join('\n');
            str += blockquoteContent;
            debugInfo("parserSlateNodeToMarkdown - 引用块处理完成 ".concat(i), {
                contentLength: blockquoteContent.length
            });
        } else if (node.type === 'bulleted-list' || node.type === 'numbered-list' || node.type === 'list' // 向后兼容
        ) {
            var _node_children2;
            debugInfo("parserSlateNodeToMarkdown - 处理列表 ".concat(i), {
                type: node.type,
                isOrdered: node.type === 'numbered-list' || node.order,
                start: node.start,
                childrenCount: (_node_children2 = node.children) === null || _node_children2 === void 0 ? void 0 : _node_children2.length
            });
            // Handle lists
            var isOrdered = node.type === 'numbered-list' || node.type === 'list' && node.order;
            var listItems = node.children.map(function(item, index) {
                var prefix = isOrdered ? "".concat(index + (node.start || 1), ".") : '-';
                return prefix + ' ' + parserNode(item, '', _to_consumable_array(parent).concat([
                    node
                ]), plugins).trimEnd();
            }).join('\n');
            if (listItems.trim()) {
                str += '\n\n';
                str += listItems;
                if (i !== tree.length - 1) {
                    str += '\n\n';
                }
            }
            debugInfo("parserSlateNodeToMarkdown - 列表处理完成 ".concat(i), {
                listItemsLength: listItems.length,
                hasContent: !!listItems.trim()
            });
        } else if (node.type === 'paragraph' && (((_tree_ = tree[i - 1]) === null || _tree_ === void 0 ? void 0 : _tree_.type) === 'list' || ((_tree_1 = tree[i - 1]) === null || _tree_1 === void 0 ? void 0 : _tree_1.type) === 'bulleted-list' || ((_tree_2 = tree[i - 1]) === null || _tree_2 === void 0 ? void 0 : _tree_2.type) === 'numbered-list') && (((_tree_3 = tree[i + 1]) === null || _tree_3 === void 0 ? void 0 : _tree_3.type) === 'list' || ((_tree_4 = tree[i + 1]) === null || _tree_4 === void 0 ? void 0 : _tree_4.type) === 'bulleted-list' || ((_tree_5 = tree[i + 1]) === null || _tree_5 === void 0 ? void 0 : _tree_5.type) === 'numbered-list')) {
            var _Node_string;
            if (!((_Node_string = Node.string(node)) === null || _Node_string === void 0 ? void 0 : _Node_string.replace(/\s|\t/g, ''))) {
                str += '<br/>\n\n';
            } else {
                var _parserNode;
                str += preString + ((_parserNode = parserNode(node, preString, parent, plugins)) === null || _parserNode === void 0 ? void 0 : _parserNode.replace(/^[\s\t]+/g, '')) + '\n\n';
            }
        } else {
            str += parserNode(node, preString, parent, plugins);
            // Special handling for different node types
            if (node.type && !inlineNode.has(node.type)) {
                // Tables should not have extra newlines between rows
                if (node.type === 'table-row') {
                    str += '\n';
                } else if (node.type === 'code' || node.type === 'media') {
                    str += '\n\n';
                } else if (node.type === 'list' || node.type === 'bulleted-list' || node.type === 'numbered-list') {
                    str += '\n\n';
                } else if (i !== tree.length - 1) {
                    // Card 节点不添加额外的换行符，让其子节点自行处理
                    if (node.type !== 'card') {
                        str += '\n\n';
                    }
                }
            }
        }
    };
    var preString = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : '', parent = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
        {
            root: true
        }
    ], plugins = arguments.length > 3 ? arguments[3] : void 0;
    var _parent_;
    debugInfo('parserSlateNodeToMarkdown - 开始转换', {
        treeLength: tree === null || tree === void 0 ? void 0 : tree.length,
        preString: preString,
        parentType: ((_parent_ = parent[parent.length - 1]) === null || _parent_ === void 0 ? void 0 : _parent_.type) || 'root',
        hasPlugins: !!plugins && plugins.length > 0
    });
    var str = '';
    for(var i = 0; i < tree.length; i++)_loop(i);
    // Clean up trailing newlines and handle special cases
    if (str) {
        var _parent_1;
        debugInfo('parserSlateNodeToMarkdown - 开始清理换行符', {
            strLength: str.length,
            trailingNewlines: (str.match(/\n+$/) || [
                ''
            ])[0].length
        });
        // Remove all trailing newlines first
        str = str.replace(/\n+$/, '');
        // Only add newlines in specific cases
        var lastNode = tree[tree.length - 1];
        var isRoot = parent.length === 1 && parent[0].root;
        var isConverted = lastNode === null || lastNode === void 0 ? void 0 : lastNode.converted;
        var parentType = (_parent_1 = parent[parent.length - 1]) === null || _parent_1 === void 0 ? void 0 : _parent_1.type;
        var nextNode = tree[tree.indexOf(lastNode) + 1];
        var isLastNodeInParent = !nextNode;
        debugInfo('parserSlateNodeToMarkdown - 换行符处理上下文', {
            lastNodeType: lastNode === null || lastNode === void 0 ? void 0 : lastNode.type,
            isRoot: isRoot,
            isConverted: isConverted,
            parentType: parentType,
            isLastNodeInParent: isLastNodeInParent
        });
        if (lastNode && lastNode.type && !isConverted) {
            if (parentType === 'blockquote') {
                // Only add trailing blockquote marker if this is not the last node in a nested blockquote
                if (!isLastNodeInParent || parent.some(function(p) {
                    return p.type === 'blockquote' && p !== parent[parent.length - 1];
                })) {
                    str += '\n> ';
                }
            } else if (lastNode.type === 'table') {
                // Do not add any newlines for tables and description lists
                str = str.replace(/\n+$/, '');
            } else if (lastNode.type === 'code' || lastNode.type === 'media') {
                // Add double newlines for code blocks and media, but not if it's the last node
                if (!isLastNodeInParent) {
                    str += '\n\n';
                }
            } else if (!inlineNode.has(lastNode.type) && !isRoot && ![
                'list-item',
                'table-row'
            ].includes(lastNode.type)) {
                // Don't add newlines for list items and table rows
                // Only add newlines if the next node is not a heading
                if (!(lastNode.type === 'head' && (nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === 'head')) {
                    str += '\n\n';
                }
            }
        }
    }
    // Clean up multiple consecutive newlines
    var beforeCleanup = str.length;
    str = str.replace(/\n{3,}/g, '\n\n');
    debugInfo('parserSlateNodeToMarkdown - 清理连续换行符', {
        beforeLength: beforeCleanup,
        afterLength: str.length
    });
    // Remove leading newlines for root level content
    if (parent.length === 1 && parent[0].root) {
        var beforeLeading = str.length;
        str = str.replace(/^\n+/, '');
        debugInfo('parserSlateNodeToMarkdown - 清理前导换行符', {
            beforeLength: beforeLeading,
            afterLength: str.length
        });
    }
    debugInfo('parserSlateNodeToMarkdown - 转换完成', {
        finalLength: str.length,
        finalPreview: str.substring(0, 100)
    });
    return str;
};
export var isMix = function isMix(t) {
    return Object.keys(t).filter(function(key) {
        return [
            'bold',
            'code',
            'italic',
            'strikethrough'
        ].includes(key);
    }).length > 1;
};
/**
 * Converts a Text object to an HTML string with appropriate formatting.
 *
 * @param {Text} t - The Text object to be converted.
 * @returns {string} - The formatted HTML string.
 *
 * The function applies the following HTML tags based on the properties of the Text object:
 * - `<span style="color:{highColor}">` if `highColor` is defined.
 * - `<code>` if `code` is true.
 * - `<i>` if `italic` is true.
 * - `<b>` if `bold` is true.
 * - `<del>` if `strikethrough` is true.
 * - `<a href="{url}">` if `url` is defined.
 */ var textHtml = function textHtml(t) {
    var str = (t.text || '').split(JINJA_DOLLAR_PLACEHOLDER).join('$');
    if (t.highColor) str = '<span style="color:'.concat(t.highColor, '">').concat(str, "</span>");
    if (t.code) str = "<code>".concat(str, "</code>");
    if (t.italic) str = "<i>".concat(str, "</i>");
    if (t.bold) str = "<b>".concat(str, "</b>");
    if (t.strikethrough) str = "<del>".concat(str, "</del>");
    if (t === null || t === void 0 ? void 0 : t.url) str = '<a href="'.concat(t === null || t === void 0 ? void 0 : t.url, '">').concat(str, "</a>");
    if ((t === null || t === void 0 ? void 0 : t.identifier) || (t === null || t === void 0 ? void 0 : t.fnc)) str = "[^".concat(str, "]");
    return str;
};
/**
 * 将文本对象格式化为带有适当样式的 Markdown 字符串
 *
 * @param t - 要格式化的文本对象
 * @returns 格式化后的 Markdown 字符串
 *
 * 该函数根据文本对象的属性应用以下 Markdown 样式：
 * - `code`: 使用反引号(`)包裹文本
 * - `italic`: 使用单个星号(*)包裹文本
 * - `bold`: 使用双星号(**)包裹文本
 * - `strikethrough`: 使用双波浪线(~~)包裹文本
 *
 * 此外，还会：
 * - 转义反斜杠
 * - 将换行符转换为 Markdown 换行符
 * - 保留文本前后的空白字符
 */ var textStyle = function textStyle(t) {
    var _split_join;
    if (!t.text && !t.tag) return '';
    var str = ((_split_join = ((t === null || t === void 0 ? void 0 : t.text) || '').split(JINJA_DOLLAR_PLACEHOLDER).join('$')) === null || _split_join === void 0 ? void 0 : _split_join.replace(RegExp("(?<!\\\\)\\\\", "g"), '\\').replace(/\n/g, '  \n')) || '';
    var preStr = '', afterStr = '';
    // Apply formats in a consistent order:
    // 1. Code (most specific)
    // 2. Bold (strong emphasis)
    // 3. Italic (emphasis)
    // 4. Strikethrough (modification)
    if (t.code && !t.tag) {
        // Extract whitespace for non-tag code
        if (t.code || t.bold || t.strikethrough || t.italic) {
            var _str_match, _str_match1;
            preStr = ((_str_match = str.match(/^\s+/)) === null || _str_match === void 0 ? void 0 : _str_match[0]) || '';
            afterStr = ((_str_match1 = str.match(/\s+$/)) === null || _str_match1 === void 0 ? void 0 : _str_match1[0]) || '';
            str = str.trim();
        }
        str = "`".concat(str, "`");
    } else if (t.tag) {
        // 如果是 tag，优先检查是否有 value，如果有 value 则使用 value 和 placeholder
        // 如果没有 value 但有 text（且不为空），则使用 text
        // 如果没有 text 也没有 value，则使用 placeholder
        // 对于 tag，如果 text 只是空白字符，不保留空白字符
        var trimmedStr = str.trim();
        if (t.value) {
            // 有 value，优先使用 value 和 placeholder（即使有 text 也使用 value）
            str = "`${placeholder:".concat((t === null || t === void 0 ? void 0 : t.placeholder) || '-', ",value:").concat(t.value, "}`");
        } else if (trimmedStr) {
            // 没有 value 但有 text 且不为空，提取空白字符并使用 text
            if (t.code || t.bold || t.strikethrough || t.italic) {
                var _str_match2, _str_match3;
                preStr = ((_str_match2 = str.match(/^\s+/)) === null || _str_match2 === void 0 ? void 0 : _str_match2[0]) || '';
                afterStr = ((_str_match3 = str.match(/\s+$/)) === null || _str_match3 === void 0 ? void 0 : _str_match3[0]) || '';
            }
            str = "`".concat(trimmedStr, "`");
        } else if (t.placeholder) {
            // 没有 text 也没有 value，使用 placeholder（不保留空白字符）
            str = "`${placeholder:".concat(t.placeholder, "}`");
        } else {
            // 都没有，使用默认值（不保留空白字符）
            str = "`${placeholder:-}`";
        }
    } else {
        // Extract whitespace for other formats
        if (t.bold || t.strikethrough || t.italic) {
            var _str_match4, _str_match5;
            preStr = ((_str_match4 = str.match(/^\s+/)) === null || _str_match4 === void 0 ? void 0 : _str_match4[0]) || '';
            afterStr = ((_str_match5 = str.match(/\s+$/)) === null || _str_match5 === void 0 ? void 0 : _str_match5[0]) || '';
            str = str.trim();
        }
    }
    // For mixed formats, we want to ensure proper nesting
    if (t.bold && t.italic) {
        str = "***".concat(str, "***"); // Combined bold and italic
    } else {
        if (t.bold) str = "**".concat(str, "**");
        if (t.italic) str = "*".concat(str, "*");
    }
    if (t.strikethrough) str = "~~".concat(str, "~~");
    // Preserve exact whitespace
    return preStr + str + afterStr;
};
/**
 * 根据给定的文本节点及其父节点生成格式化的文本字符串
 *
 * @param t - 要处理的文本节点
 * @param parent - 父节点数组，用于上下文信息
 * @returns 处理后的文本字符串。如果文本节点没有内容，返回空字符串
 *
 * 该函数处理不同的文本样式和格式：
 * - 如果文本有 highColor 属性或者同时具有删除线和其他样式（粗体、斜体、代码），返回 HTML 格式的文本
 * - 如果文本有 URL，返回 Markdown 链接格式
 * - 如果文本有多种样式且不在句子末尾，确保单词之间有适当的空格
 *
 * 特殊处理：
 * - 高亮颜色：使用 span 标签和 style 属性
 * - 脚注标识：使用 [^] 语法
 * - 混合样式：确保相邻文本之间的空格正确
 */ var composeText = function composeText(t, parent) {
    var _parent_;
    if (!t.text && !t.tag) return '';
    if (t.highColor || t.identifier || t.fnc || t.strikethrough && (t.bold || t.italic || t.code)) return textHtml(t);
    var siblings = (_parent_ = parent[parent.length - 1]) === null || _parent_ === void 0 ? void 0 : _parent_.children;
    // @ts-ignore
    var index = siblings === null || siblings === void 0 ? void 0 : siblings.findIndex(function(n) {
        return n === t;
    });
    var str = textStyle(t);
    if (t === null || t === void 0 ? void 0 : t.url) {
        str = "[".concat((t.text || '').split(JINJA_DOLLAR_PLACEHOLDER).join('$'), "](").concat(encodeURI(t === null || t === void 0 ? void 0 : t.url), ")");
    } else if (isMix(t) && index !== -1) {
        var next = siblings[index + 1];
        if (!str.endsWith(' ') && next && !Node.string(next).startsWith(' ')) {
            str += ' ';
        }
    }
    return str;
};
/**
 * 将类表格节点结构转换为 Markdown 表格字符串
 *
 * @param el - 表格节点，可以是 TableNode、ColumnNode、DescriptionNode 或 ChartNode 类型
 * @param preString - 前缀字符串，用于在表格每行前添加缩进
 * @param parent - 父节点数组，用于提供上下文信息
 * @param plugins - 可选的插件数组，用于自定义转换逻辑
 * @returns 格式化后的 Markdown 表格字符串
 *
 * 该函数支持以下功能：
 * 1. 列宽处理
 *    - 自动计算每列的最大宽度
 *    - 使用空格填充单元格以对齐
 *
 * 2. 对齐方式
 *    - 左对齐：`:---`
 *    - 居中对齐：`:---:`
 *    - 右对齐：`---:`
 *
 * 3. 特殊节点处理
 *    - column-group：生成带有默认列标题的表格
 *    - table/chart：处理标准表格数据
 *    - description：将描述列表转换为两行表格
 *
 * 4. 格式化细节
 *    - 转义表格分隔符 |
 *    - 保持单元格间距一致
 *    - 处理空行和空单元格
 *
 * @example
 * 生成的表格格式如下：
 * ```markdown
 * | 列1 | 列2 | 列3 |
 * |:--- |:---:| ---:|
 * | 左对齐 | 居中 | 右对齐 |
 * ```
 */ var table = function table(el, parent, plugins) {
    var _el_children, _children_;
    debugInfo('parserSlateNodeToMarkdown.table - 开始处理表格', {
        elType: el.type,
        childrenCount: (_el_children = el.children) === null || _el_children === void 0 ? void 0 : _el_children.length
    });
    var children = el.children;
    var head = (_children_ = children[0]) === null || _children_ === void 0 ? void 0 : _children_.children;
    if (!children.length || !head.length) {
        debugInfo('parserSlateNodeToMarkdown.table - 空表格，返回空字符串');
        return '';
    }
    debugInfo('parserSlateNodeToMarkdown.table - 表格头部信息', {
        headLength: head.length,
        headCells: head.map(function(h) {
            return {
                type: h.type,
                align: h.align
            };
        })
    });
    var data = new Array(children.length);
    var maxColumns = 0;
    // 使用策略模式处理不同类型的表格
    var tableProcessors = {
        default: function _default() {
            var rowIndex = 0;
            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
            try {
                for(var _iterator = children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                    var c = _step.value;
                    if (!c) continue;
                    var processRow = function processRow(cells, processCell) {
                        var row = new Array(cells.length);
                        // 处理每个单元格，包括空单元格
                        for(var i = 0; i < cells.length; i++){
                            var cell = cells[i];
                            var content = processCell(cell);
                            row[i] = content; // 保持原始位置，不跳过空单元格
                        }
                        // 只要有单元格存在就添加这一行，即使所有单元格都是空的
                        if (cells.length > 0) {
                            data[rowIndex] = row;
                            maxColumns = Math.max(maxColumns, cells.length);
                            rowIndex++;
                        }
                    };
                    var cellProcessor = function cellProcessor(cell) {
                        if (cell.type !== 'table-cell') return '';
                        // 对于表格单元格，直接提取文本内容，避免段落格式化
                        return cell.children.map(function(child) {
                            if (child.type === 'paragraph') {
                                // 对于段落，直接处理其文本内容
                                return parserSlateNodeToMarkdown(child.children, '', _to_consumable_array(parent).concat([
                                    cell,
                                    child
                                ]), plugins);
                            }
                            return parserSlateNodeToMarkdown([
                                child
                            ], '', _to_consumable_array(parent).concat([
                                cell
                            ]), plugins);
                        }).join('').trim();
                    };
                    if (c.type === 'table-row' && (c === null || c === void 0 ? void 0 : c.children)) {
                        processRow(c.children, cellProcessor);
                    } else if (c.type === 'table-cell') {
                        processRow([
                            c
                        ], cellProcessor);
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally{
                try {
                    if (!_iteratorNormalCompletion && _iterator.return != null) {
                        _iterator.return();
                    }
                } finally{
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
            return rowIndex;
        }
    };
    var processor = tableProcessors[el.type] || tableProcessors.default;
    var rowCount = processor();
    data.length = rowCount;
    debugInfo('parserSlateNodeToMarkdown.table - 表格数据处理完成', {
        rowCount: rowCount,
        maxColumns: maxColumns,
        dataPreview: data.slice(0, 2).map(function(row) {
            return row.slice(0, 3);
        })
    });
    // 计算列宽
    var colLength = new Array(maxColumns).fill(0);
    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
    try {
        for(var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
            var row = _step.value;
            for(var i = 0; i < row.length; i++){
                colLength[i] = Math.max(colLength[i], stringWidth(row[i] || ''));
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally{
        try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
            }
        } finally{
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
    // 对齐策略表
    var alignStrategies = {
        right: function right(str, diff) {
            return ' '.repeat(diff) + str;
        },
        center: function center(str, diff) {
            var pre = Math.floor(diff / 2);
            return ' '.repeat(pre) + str + ' '.repeat(diff - pre);
        },
        left: function left(str, diff) {
            return str + ' '.repeat(diff);
        },
        default: function _default(str, diff) {
            return str + ' '.repeat(diff);
        }
    };
    // 修改分隔符策略表
    var separatorStrategies = {
        left: function left(length) {
            return ':' + '-'.repeat(Math.max(3, length - 1));
        },
        center: function center(length) {
            return ':' + '-'.repeat(Math.max(3, length - 2)) + ':';
        },
        right: function right(length) {
            return '-'.repeat(Math.max(3, length - 1)) + ':';
        },
        default: function _default(length) {
            return ':' + '-'.repeat(Math.max(3, length - 1));
        }
    };
    var output = [];
    // 构建表格内容
    for(var i1 = 0; i1 < data.length; i1++){
        var cells = new Array(maxColumns);
        var row1 = data[i1];
        // 处理单元格
        for(var j = 0; j < maxColumns; j++){
            var _head_j, _head_j1;
            var str = row1[j] || '';
            var strLength = stringWidth(str);
            var length = Math.max(3, colLength[j]);
            var diff = length - strLength;
            // 检查是否有明确的对齐信息
            var hasExplicitAlignment = ((_head_j = head[j]) === null || _head_j === void 0 ? void 0 : _head_j.align) !== undefined;
            str = diff > 0 && hasExplicitAlignment ? (alignStrategies[(_head_j1 = head[j]) === null || _head_j1 === void 0 ? void 0 : _head_j1.align] || alignStrategies.default)(str, diff) : str;
            cells[j] = str.replace(/\|/g, '\\|');
        }
        output.push("| ".concat(cells.join(' | '), " |"));
        // 处理分隔行
        if (i1 === 0) {
            var separators = new Array(maxColumns);
            for(var j1 = 0; j1 < maxColumns; j1++){
                var _head_j2;
                var minLength = Math.max(3, colLength[j1]); // 确保至少有3个字符的长度
                separators[j1] = (separatorStrategies[(_head_j2 = head[j1]) === null || _head_j2 === void 0 ? void 0 : _head_j2.align] || separatorStrategies.default)(minLength);
            }
            output.push("| ".concat(separators.join(' | '), " |"));
        }
    }
    var result = output.join('\n');
    debugInfo('parserSlateNodeToMarkdown.table - 表格转换完成', {
        outputRows: output.length,
        resultLength: result.length,
        resultPreview: result.substring(0, 200)
    });
    return result;
};
/**
 * 处理卡片节点，递归处理其子节点
 * @param node - 卡片节点
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 字符串
 */ var handleCard = function handleCard(node, preString, parent, plugins) {
    return parserSlateNodeToMarkdown(node === null || node === void 0 ? void 0 : node.children, preString, _to_consumable_array(parent).concat([
        node
    ]), plugins);
};
/**
 * 处理段落节点，添加前缀并处理其子节点
 * @param node - 段落节点
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 字符串
 */ var handleParagraph = function handleParagraph(node, preString, parent, plugins) {
    var _node_align;
    var _node_otherProps;
    var str = '';
    // 如果有对齐属性，使用 HTML 标签包裹以支持对齐（兼容 align 在 otherProps 的情况）
    var align = (_node_align = node.align) !== null && _node_align !== void 0 ? _node_align : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.align;
    if (align) {
        // 递归处理子节点
        var content = parserSlateNodeToMarkdown(node === null || node === void 0 ? void 0 : node.children, '', _to_consumable_array(parent).concat([
            node
        ]), plugins);
        return '<p align="'.concat(align, '">').concat(content, "</p>");
    }
    str += parserSlateNodeToMarkdown(node === null || node === void 0 ? void 0 : node.children, preString, _to_consumable_array(parent).concat([
        node
    ]), plugins);
    return str;
};
/**
 * 处理标题节点，根据级别生成对应的 Markdown 标题
 * @param node - 标题节点，包含 level 属性
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 标题字符串
 */ var handleHead = function handleHead(node, preString, parent, plugins) {
    var _node_align;
    var _node_otherProps;
    var str = '';
    // 如果有对齐属性，使用 HTML 标签包裹以支持对齐（兼容 align 在 otherProps 的情况）
    var align = (_node_align = node.align) !== null && _node_align !== void 0 ? _node_align : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.align;
    if (align) {
        // 递归处理子节点
        var content = parserSlateNodeToMarkdown(node === null || node === void 0 ? void 0 : node.children, '', _to_consumable_array(parent).concat([
            node
        ]), plugins);
        return "<h".concat(node.level, ' align="').concat(align, '">').concat(content, "</h").concat(node.level, ">");
    }
    str += '#'.repeat(node.level) + ' ' + parserSlateNodeToMarkdown(node === null || node === void 0 ? void 0 : node.children, preString, _to_consumable_array(parent).concat([
        node
    ]), plugins);
    return str;
};
/**
 * 处理代码节点，支持三种模式：HTML渲染、Frontmatter、普通代码块
 * @param node - 代码节点，包含 language、value、render、frontmatter 等属性
 * @param preString - 前缀字符串，用于处理缩进
 * @returns 处理后的代码块字符串
 */ var handleCode = function handleCode(node, preString) {
    var code = (node === null || node === void 0 ? void 0 : node.value) || '';
    // 如果 code 是对象，则转换为 JSON 字符串，实现对 apaasify 等节点的支持
    if ((typeof code === "undefined" ? "undefined" : _type_of(code)) === 'object') {
        try {
            code = JSON.stringify(code, null, 2);
        } catch (e) {
            console.warn('Invalid code object', e);
        }
    }
    // 如果语言是 think，转换为 <think> 标签
    if (node.language === 'think') {
        // 恢复内容中的代码块特殊标记为 Markdown 格式
        var marker = '\u200B'; // 零宽空格
        var restoredCode = code.replace(new RegExp("".concat(marker, "【CODE_BLOCK:([\\w]*)】\\n?([\\s\\S]*?)\\n?【/CODE_BLOCK】").concat(marker), 'g'), function(_, lang, codeContent) {
            return "```".concat(lang, "\n").concat(codeContent, "\n```");
        });
        return "<think>".concat(restoredCode, "</think>");
    }
    if (node.language === 'html' && node.render) {
        return code;
    }
    if (node.frontmatter) {
        return "".concat(preString, "---\n").concat(code, "\n").concat(preString, "---");
    }
    var language = node.language || '';
    if (!code.trim()) {
        return "".concat(preString, "```").concat(language, "\n").concat(preString, "```");
    }
    var codeLines = code.split('\n');
    var indentedCode = codeLines.map(function(line, index) {
        if (index === 0 || index === codeLines.length - 1) {
            return line;
        }
        return preString + line;
    }).join('\n');
    return "".concat(preString, "```").concat(language, "\n").concat(indentedCode, "\n").concat(preString, "```");
};
/**
 * 处理附件节点，生成带下载属性的链接标签
 * @param node - 附件节点，包含 url、size、name 属性
 * @returns 处理后的 HTML 链接标签字符串
 */ var handleAttach = function handleAttach(node) {
    return '<a href="'.concat(encodeURI(node === null || node === void 0 ? void 0 : node.url), '" download data-size="').concat(node.size, '">').concat(node.name, "</a>");
};
/**
 * 处理引用块节点，递归处理其子节点
 * @param node - 引用块节点
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 引用字符串
 */ var handleBlockquote = function handleBlockquote(node, preString, parent, plugins) {
    // Handle empty blockquotes
    if (!node.children || node.children.length === 0) {
        return '> ';
    }
    // Process each child node
    var blockquoteContent = node.children.map(function(child) {
        if (child.type === 'blockquote') {
            // For nested blockquotes, increase the level
            var nestedContent = parserNode(child, '', _to_consumable_array(parent).concat([
                node
            ]), plugins);
            return nestedContent.split('\n').map(function(line) {
                return '> ' + line;
            }).join('\n');
        } else {
            // For regular content
            var content = parserNode(child, '', _to_consumable_array(parent).concat([
                node
            ]), plugins);
            if (!content.trim()) {
                return '> ';
            }
            // Add blockquote marker and handle multi-line content
            return content.split('\n').map(function(line) {
                return '> ' + line;
            }).join('\n');
        }
    }).join('\n');
    return blockquoteContent;
};
/**
 * 处理图片节点，支持宽度、高度和块级显示参数
 * @param node - 图片节点，包含 url、width、height、block、alt 属性
 * @returns 处理后的 Markdown 图片字符串
 */ var handleImage = function handleImage(node) {
    try {
        var nodeImageUrl = new URL(node === null || node === void 0 ? void 0 : node.url);
        if (node.width) {
            nodeImageUrl.searchParams.set('width', node.width);
        }
        if (node.height) {
            nodeImageUrl.searchParams.set('height', node.height);
        }
        if (node.block) {
            nodeImageUrl.searchParams.set('block', node.block);
        }
        return "![".concat(node.alt || '', "](").concat(nodeImageUrl.toString(), ")");
    } catch (e) {
        console.warn('Invalid image URL:', node === null || node === void 0 ? void 0 : node.url, e);
        return "![".concat(node.alt || '', "](").concat(encodeURI(node === null || node === void 0 ? void 0 : node.url), ")");
    }
};
/**
 * 处理媒体节点，支持视频、图片和 iframe
 * @param node - 媒体节点，包含 url、mediaType、height、align、alt 属性
 * @returns 处理后的 HTML 媒体标签或 Markdown 图片字符串
 */ var handleMedia = function handleMedia(node) {
    var nodeUrl = node === null || node === void 0 ? void 0 : node.url;
    var type = node.mediaType || getMediaType(nodeUrl, node === null || node === void 0 ? void 0 : node.alt);
    if (node.height) {
        if (type === 'video') {
            return '<video src="'.concat(encodeURI(nodeUrl), '" alt="" height="').concat(node.height || '', '"/>');
        } else if (type === 'image' || type === 'media') {
            return '<img src="'.concat(encodeURI(nodeUrl), '" alt="" height="').concat(node.height || '', '" ').concat(node.align ? 'data-align="'.concat(node.align, '"') : '', "/>");
        }
    } else {
        if (type === 'video') {
            return '<video src="'.concat(encodeURI(nodeUrl), '"/>');
        } else if (type === 'image' || type === 'media') {
            if (node.align) {
                return '<img src="'.concat(encodeURI(nodeUrl), '" alt="" ').concat(node.align ? 'data-align="'.concat(node.align, '"') : '', "/>");
            } else {
                return "![".concat(node.alt || '', "](").concat(encodeURI(nodeUrl), ")");
            }
        } else {
            return '<iframe src="'.concat(encodeURI(nodeUrl), '"/>');
        }
    }
    return '';
};
/**
 * 处理列表节点，递归处理其子节点
 * @param node - 列表节点（bulleted-list、numbered-list 或 list）
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 列表字符串
 */ var handleList = function handleList(node, preString, parent, plugins) {
    var _parent_;
    // 检查是否在嵌套列表中（父节点是 list-item）
    var isNested = parent.length > 0 && ((_parent_ = parent[parent.length - 1]) === null || _parent_ === void 0 ? void 0 : _parent_.type) === 'list-item';
    // 如果是嵌套列表，需要添加缩进
    var indent = isNested ? '  ' : '';
    // 递归处理列表项，每个列表项都会添加缩进前缀
    var listItems = node.children.map(function(item, index) {
        var isOrdered = node.type === 'numbered-list' || node.type === 'list' && node.order;
        var prefix = isOrdered ? "".concat(index + (node.start || 1), ".") : '-';
        // 处理列表项内容，如果是嵌套列表，需要额外缩进
        var itemContent = parserNode(item, indent + preString, _to_consumable_array(parent).concat([
            node
        ]), plugins).trimEnd();
        return indent + prefix + ' ' + itemContent;
    }).join('\n' + indent);
    return listItems;
};
/**
 * 处理列表项节点，递归处理其子节点
 * @param node - 列表项节点
 * @param preString - 前缀字符串，用于处理缩进
 * @param parent - 父节点数组
 * @param plugins - 可选的插件数组
 * @returns 处理后的 Markdown 列表项字符串
 */ var handleListItem = function handleListItem(node, preString, parent, plugins) {
    // 列表项的第一个子节点应该是段落或其他块级元素
    // 后续子节点可能是嵌套的列表
    var result = [];
    for(var i = 0; i < node.children.length; i++){
        var child = node.children[i];
        var childResult = parserNode(child, preString, _to_consumable_array(parent).concat([
            node
        ]), plugins);
        if (i === 0) {
            // 第一个子节点是主要内容
            result.push(childResult);
        } else {
            // 后续子节点可能是嵌套列表，需要换行并添加缩进
            if (child.type === 'bulleted-list' || child.type === 'numbered-list' || child.type === 'list') {
                result.push('\n' + childResult);
            } else {
                // 其他块级元素也需要换行
                result.push('\n' + childResult);
            }
        }
    }
    return result.join('');
};
/**
 * 处理模式定义节点，生成 schema 代码块
 * @param node - 模式定义节点，包含 otherProps 属性
 * @returns 处理后的 schema 代码块字符串
 */ var handleSchema = function handleSchema(node) {
    return '```schema\n' + JSON.stringify(node.otherProps, null, 2) + '\n```';
};
/**
 * 处理链接卡片节点，生成 Markdown 链接格式
 * @param node - 链接卡片节点，包含 name、url 属性
 * @returns 处理后的 Markdown 链接字符串
 */ var handleLinkCard = function handleLinkCard(node) {
    return "[".concat(node.name, "](").concat(node === null || node === void 0 ? void 0 : node.url, ' "').concat(node.name, '")');
};
/**
 * 处理水平分割线节点
 * @param preString - 前缀字符串，用于处理缩进
 * @returns 处理后的 Markdown 分割线字符串
 */ var handleHr = function handleHr(preString) {
    return preString + '***';
};
/**
 * 处理换行节点
 * @param preString - 前缀字符串，用于处理缩进
 * @returns 处理后的 HTML 换行标签字符串
 */ var handleBreak = function handleBreak(preString) {
    return preString + '<br/>';
};
/**
 * 处理脚注定义节点
 * @param node - 脚注定义节点，包含 identifier、value、url 属性
 * @returns 处理后的 Markdown 脚注字符串
 */ var handleFootnoteDefinition = function handleFootnoteDefinition(node) {
    return "[^".concat(node.identifier, "]: [").concat(node.value, "](").concat(node.url, ")\n");
};
/**
 * 处理默认文本节点
 * @param node - 文本节点
 * @param parent - 父节点数组
 * @returns 处理后的文本字符串
 */ var handleDefault = function handleDefault(node, parent) {
    if (node.text || node.tag) return composeText(node, parent);
    return '';
};
