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 _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 _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 remarkFrontmatter from "remark-frontmatter";
import remarkGfm from "remark-gfm";
import remarkHtml from "remark-html";
import remarkMath from "remark-math";
import remarkParse from "remark-parse";
import { unified } from "unified";
import { visit } from "unist-util-visit";
/**
 * 提取段落节点的文本内容
 * @param paragraphNode - 段落节点
 * @returns 文本内容字符串
 */ function extractParagraphText(paragraphNode) {
    if (!paragraphNode.children || !Array.isArray(paragraphNode.children)) {
        return '';
    }
    return paragraphNode.children.map(function(child) {
        if (child.type === 'text') {
            return child.value || '';
        }
        // 处理嵌套节点（如 strong, emphasis 等）
        if (child.children && Array.isArray(child.children)) {
            return child.children.map(function(grandChild) {
                return grandChild.type === 'text' ? grandChild.value || '' : '';
            }).join('');
        }
        return '';
    }).join('').trim();
}
/**
 * 将段落节点转换为相应的节点类型（根据内容开头字符）
 * - ! 开头 → image
 * - | 开头 → table
 * - [ 开头 → link
 *
 * @returns {(tree: any) => void}
 *   Transformer function.
 */ export function convertParagraphToImage() {
    return function(tree) {
        // 使用 visit 访问 paragraph 节点，并通过 index 和 parent 来替换
        visit(tree, 'paragraph', function(paragraphNode, index, parent) {
            var _parent_children;
            var textContent = extractParagraphText(paragraphNode);
            if (!textContent || !index || !parent) {
                return;
            }
            var nextNode = parent === null || parent === void 0 ? void 0 : (_parent_children = parent.children) === null || _parent_children === void 0 ? void 0 : _parent_children[index + 1];
            // 检查是否以 ! 开头（图片）
            if (textContent.startsWith('!') && !nextNode) {
                // 提取 URL（去掉开头的 !）
                var imageUrl = textContent.slice(1).trim();
                // 如果 URL 不为空，则创建 image 节点并替换
                if (imageUrl) {
                    var imageNode = {
                        type: 'image',
                        url: imageUrl,
                        finished: false,
                        alt: ''
                    };
                    // 替换父节点中的 paragraph 节点为 image 节点
                    if (parent && Array.isArray(parent.children) && typeof index === 'number') {
                        parent.children[index] = imageNode;
                    }
                }
                return;
            }
            // 检查是否以 | 开头（表格）
            // 注意：如果 remark-gfm 已经正确解析了表格，表格节点应该是 'table' 类型，不会进入这里
            // 这里只处理未被解析的表格行（通常是不完整的表格输入）
            if (textContent.startsWith('|') && !nextNode) {
                // 只有不完整的表格输入（比如只有 | 开头，没有结束）才转换为表格节点
                // 创建不完整的表格节点（用于不完整的表格输入）
                var tableNode = {
                    type: 'table',
                    finished: false,
                    align: [],
                    children: [
                        {
                            type: 'tableRow',
                            children: [
                                {
                                    type: 'tableCell',
                                    children: [
                                        {
                                            type: 'paragraph',
                                            children: [
                                                {
                                                    type: 'text',
                                                    value: textContent
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                };
                // 替换父节点中的 paragraph 节点为 table 节点
                if (parent && Array.isArray(parent.children) && typeof index === 'number') {
                    parent.children[index] = tableNode;
                }
                return;
            }
            if (textContent.startsWith('[') && !nextNode) {
                // 检查是否匹配 [内容](url) 格式
                var linkPattern = /^\[([^\]]+)\]\(([^)]+)\)$/;
                var match = textContent.match(linkPattern);
                if (match) {
                    var linkNode = {
                        type: 'link',
                        url: match[2],
                        finished: false,
                        children: paragraphNode.children
                    };
                    if (parent && Array.isArray(parent.children) && typeof index === 'number') {
                        parent.children[index] = linkNode;
                    }
                }
            }
            return;
        });
    };
}
/**
 * Plugin to fix bold text containing special characters like **$9.698M**, **57%**, etc.
 *
 * @returns {(tree: any) => void}
 *   Transformer function.
 */ export function fixStrongWithSpecialChars() {
    // 返回转换器函数
    return function(tree) {
        // 先尝试处理段落中的原始文本
        visit(tree, 'paragraph', function(paragraphNode) {
            if (Array.isArray(paragraphNode.children)) {
                for(var i = 0; i < paragraphNode.children.length; i++){
                    var child = paragraphNode.children[i];
                    if (child.type === 'text' && child.value && typeof child.value === 'string') {
                        // 匹配完整的加粗文本（**text**）
                        var strongPattern = /\*\*([^*\n]*[$%#@&+\-=\w\d.，。、；：！？""''（）【】《》]+[^*\n]*?)\*\*/g;
                        // 匹配不完整的加粗文本（**text 但没有结束的 **）
                        var incompleteStrongPattern = /^\*\*([^*\n]+)$/;
                        var newNodes = [];
                        var lastIndex = 0;
                        var hasMatch = false;
                        // 先检查是否有完整的加粗文本
                        if (strongPattern.test(child.value)) {
                            // 重置正则表达式
                            strongPattern.lastIndex = 0;
                            hasMatch = true;
                            var match = void 0;
                            // 分割文本并创建新的节点结构
                            while((match = strongPattern.exec(child.value)) !== null){
                                // 添加匹配前的普通文本
                                if (match.index > lastIndex) {
                                    var beforeText = child.value.slice(lastIndex, match.index);
                                    if (beforeText) {
                                        newNodes.push({
                                            type: 'text',
                                            value: beforeText
                                        });
                                    }
                                }
                                // 添加加粗节点
                                newNodes.push({
                                    type: 'strong',
                                    children: [
                                        {
                                            type: 'text',
                                            value: match[1]
                                        }
                                    ]
                                });
                                lastIndex = match.index + match[0].length;
                            }
                            // 添加剩余的普通文本
                            if (lastIndex < child.value.length) {
                                var afterText = child.value.slice(lastIndex);
                                if (afterText) {
                                    // 检查剩余文本是否是不完整的加粗
                                    var incompleteMatch = incompleteStrongPattern.exec(afterText);
                                    if (incompleteMatch) {
                                        newNodes.push({
                                            type: 'strong',
                                            finished: false,
                                            children: [
                                                {
                                                    type: 'text',
                                                    value: incompleteMatch[1]
                                                }
                                            ]
                                        });
                                    } else {
                                        newNodes.push({
                                            type: 'text',
                                            value: afterText
                                        });
                                    }
                                }
                            }
                        } else if (incompleteStrongPattern.test(child.value)) {
                            var incompleteMatch1 = incompleteStrongPattern.exec(child.value);
                            if (incompleteMatch1) {
                                hasMatch = true;
                                newNodes.push({
                                    type: 'strong',
                                    finished: false,
                                    children: [
                                        {
                                            type: 'text',
                                            value: incompleteMatch1[1]
                                        }
                                    ]
                                });
                            }
                        }
                        // 替换当前文本节点
                        if (hasMatch && newNodes.length > 0) {
                            var _paragraphNode_children;
                            (_paragraphNode_children = paragraphNode.children).splice.apply(_paragraphNode_children, [
                                i,
                                1
                            ].concat(_to_consumable_array(newNodes)));
                            i += newNodes.length - 1; // 调整索引以跳过新插入的节点
                        }
                    }
                }
            }
        });
        // 处理所有文本节点（作为备用方案）
        visit(tree, 'text', function(node, index, parent) {
            if (node.value && typeof node.value === 'string') {
                // 匹配完整的加粗文本（**text**）
                var strongPattern = /\*\*([^*\n]*[$%#@&+\-=\w\d.，。、；：！？""''（）【】《》]+[^*\n]*?)\*\*/g;
                // 匹配不完整的加粗文本（**text 但没有结束的 **）
                var incompleteStrongPattern = /^\*\*([^*\n]+)$/;
                var newNodes = [];
                var lastIndex = 0;
                var hasMatch = false;
                // 先检查是否有完整的加粗文本
                if (strongPattern.test(node.value)) {
                    // 重置正则表达式
                    strongPattern.lastIndex = 0;
                    hasMatch = true;
                    var match;
                    // 分割文本并创建新的节点结构
                    while((match = strongPattern.exec(node.value)) !== null){
                        // 添加匹配前的普通文本
                        if (match.index > lastIndex) {
                            var beforeText = node.value.slice(lastIndex, match.index);
                            if (beforeText) {
                                newNodes.push({
                                    type: 'text',
                                    value: beforeText
                                });
                            }
                        }
                        // 添加加粗节点
                        newNodes.push({
                            type: 'strong',
                            children: [
                                {
                                    type: 'text',
                                    value: match[1]
                                }
                            ]
                        });
                        lastIndex = match.index + match[0].length;
                    }
                    // 添加剩余的普通文本
                    if (lastIndex < node.value.length) {
                        var afterText = node.value.slice(lastIndex);
                        if (afterText) {
                            // 检查剩余文本是否是不完整的加粗
                            var incompleteMatch = incompleteStrongPattern.exec(afterText);
                            if (incompleteMatch) {
                                newNodes.push({
                                    type: 'strong',
                                    finished: false,
                                    children: [
                                        {
                                            type: 'text',
                                            value: incompleteMatch[1]
                                        }
                                    ]
                                });
                            } else {
                                newNodes.push({
                                    type: 'text',
                                    value: afterText
                                });
                            }
                        }
                    }
                } else if (incompleteStrongPattern.test(node.value)) {
                    var incompleteMatch1 = incompleteStrongPattern.exec(node.value);
                    if (incompleteMatch1) {
                        hasMatch = true;
                        newNodes.push({
                            type: 'strong',
                            finished: false,
                            children: [
                                {
                                    type: 'text',
                                    value: incompleteMatch1[1]
                                }
                            ]
                        });
                    }
                }
                // 替换原节点
                if (hasMatch && newNodes.length > 0 && parent && Array.isArray(parent.children) && typeof index === 'number') {
                    var _parent_children;
                    (_parent_children = parent.children).splice.apply(_parent_children, [
                        index,
                        1
                    ].concat(_to_consumable_array(newNodes)));
                }
            }
        });
    };
}
// Markdown 解析器（用于解析 Markdown 为 mdast AST）
// 注意：这个解析器只用于解析，不包含 HTML 渲染相关的插件
var markdownParser = unified().use(remarkParse) // 解析 Markdown
.use(remarkHtml).use(remarkFrontmatter, [
    'yaml'
]) // 处理前置元数据
.use(remarkGfm, {
    singleTilde: false
}) // GFM 插件，禁用单波浪线删除线
.use(fixStrongWithSpecialChars) // 修复包含特殊字符的加粗文本
.use(convertParagraphToImage) // 将以 ! 开头的段落转换为图片,将 | 开头的段落转换为表格
.use(remarkMath, {
    singleDollarTextMath: true
});
// 默认导出解析器（用于解析 Markdown 为 mdast AST）
export default markdownParser;
