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 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 _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 _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);
}
import json5 from "json5";
import { htmlToFragmentList } from "../../plugins/insertParsedHtmlNodes";
import { EditorUtils } from "../../utils";
import partialJsonParse from "../json-parse";
/**
 * 规范标签名必须与 `preprocessSpecialTags(markdown, 'think')` 一致：该函数用 `<${tagName}>` / `</${tagName}>`，
 * 即字面量 `<think>`…`</think>`，再包成 `` ```think ``。若此处改名须同步改 `parserSlateNodeToMarkdown` 里 think 序列化。
 */ var THINK_TAG_CANONICAL_OPEN = '<think>';
var THINK_TAG_CANONICAL_CLOSE = '</think>';
/** 部分模型输出的外壳别名；拼接避免与规范标签在源码中混淆 */ var REDACTED_THINKING_ALIAS_OPEN = '<' + 'redacted_' + 'thinking' + '>';
var REDACTED_THINKING_ALIAS_CLOSE = '</' + 'redacted_' + 'thinking' + '>';
var THINKING_ALIAS_OPEN = '<' + 'thinking' + '>';
var THINKING_ALIAS_CLOSE = '</' + 'thinking' + '>';
var escapeRegExp = function escapeRegExp(value) {
    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
};
/** 仅替换「成对」别名标签，避免正文里偶然出现的孤立字面量被误换 */ var REDACTED_THINKING_ALIAS_PAIR_REGEX = new RegExp("".concat(escapeRegExp(REDACTED_THINKING_ALIAS_OPEN), "([\\s\\S]*?)").concat(escapeRegExp(REDACTED_THINKING_ALIAS_CLOSE)), 'gi');
var THINKING_ALIAS_PAIR_REGEX = new RegExp("".concat(escapeRegExp(THINKING_ALIAS_OPEN), "([\\s\\S]*?)").concat(escapeRegExp(THINKING_ALIAS_CLOSE)), 'gi');
var FIND_THINK_CANONICAL_BLOCK_RE = new RegExp("^\\s*".concat(escapeRegExp(THINK_TAG_CANONICAL_OPEN), "([\\s\\S]*?)").concat(escapeRegExp(THINK_TAG_CANONICAL_CLOSE), "\\s*$"), 'i');
var FIND_THINK_ALIAS_BLOCK_RE = new RegExp("^\\s*(?:".concat(escapeRegExp(REDACTED_THINKING_ALIAS_OPEN), "|").concat(escapeRegExp(THINKING_ALIAS_OPEN), ")([\\s\\S]*?)(?:").concat(escapeRegExp(REDACTED_THINKING_ALIAS_CLOSE), "|").concat(escapeRegExp(THINKING_ALIAS_CLOSE), ")\\s*$"), 'i');
/**
 * 将成对的别名标签 `<think>`…`</think>` 归一为与 `preprocessSpecialTags(..., 'think')` 契约一致的规范标签。
 * 否则 `preprocessThinkTags` 无法把思考区内的 ``` 围栏换成 【CODE_BLOCK】，内层 JSON 会变成顶层独立 code 节点。
 */ export function normalizeThinkTagAliases(markdown) {
    if (!markdown) return markdown;
    var replaceToCanonical = function replaceToCanonical(_match, inner) {
        return "".concat(THINK_TAG_CANONICAL_OPEN).concat(inner).concat(THINK_TAG_CANONICAL_CLOSE);
    };
    var result = markdown;
    if (result.indexOf(REDACTED_THINKING_ALIAS_OPEN) !== -1) {
        result = result.replace(REDACTED_THINKING_ALIAS_PAIR_REGEX, replaceToCanonical);
    }
    if (result.indexOf(THINKING_ALIAS_OPEN) !== -1) {
        result = result.replace(THINKING_ALIAS_PAIR_REGEX, replaceToCanonical);
    }
    return result;
}
/**
 * 解码 URI 组件，处理错误情况
 */ export var decodeURIComponentUrl = function decodeURIComponentUrl(url) {
    try {
        return decodeURIComponent(url);
    } catch (e) {
        console.error('Failed to decode URI component:', e);
        return url;
    }
};
/**
 * 检测和解析 think 标签
 * @param str - 要检测的字符串
 * @returns think 标签的内容，如果不是 think 标签则返回 null
 */ var findThinkElement = function findThinkElement(str) {
    try {
        var thinkMatch = str.match(FIND_THINK_CANONICAL_BLOCK_RE) || str.match(FIND_THINK_ALIAS_BLOCK_RE);
        if (thinkMatch) {
            return {
                content: thinkMatch[1].trim()
            };
        }
        return null;
    } catch (e) {
        if (process.env.NODE_ENV !== 'production') {
            console.warn('[parseHtml] findThinkElement failed', e);
        }
        return null;
    }
};
/**
 * 检测和解析 answer 标签
 * @param str - 要检测的字符串
 * @returns answer 标签的内容，如果不是 answer 标签则返回 null
 */ var findAnswerElement = function findAnswerElement(str) {
    try {
        // 匹配 <answer>内容</answer> 格式
        var answerMatch = str.match(/^\s*<answer>([\s\S]*?)<\/answer>\s*$/);
        if (answerMatch) {
            return {
                content: answerMatch[1].trim()
            };
        }
        return null;
    } catch (e) {
        return null;
    }
};
/**
 * 从 HTML 字符串中提取媒体元素属性
 */ var extractMediaAttributes = function extractMediaAttributes(str) {
    var _str_match, _str_match1, _str_match2, _str_match3, _str_match4;
    return {
        height: (_str_match = str.match(/height="(\d+)"/)) === null || _str_match === void 0 ? void 0 : _str_match[1],
        width: (_str_match1 = str.match(/width="(\d+)"/)) === null || _str_match1 === void 0 ? void 0 : _str_match1[1],
        align: (_str_match2 = str.match(/data-align="(\w+)"/)) === null || _str_match2 === void 0 ? void 0 : _str_match2[1],
        alt: (_str_match3 = str.match(/alt="([^"\n]+)"/)) === null || _str_match3 === void 0 ? void 0 : _str_match3[1],
        controls: str.match(/controls/),
        autoplay: str.match(/autoplay/),
        loop: str.match(/loop/),
        muted: str.match(/muted/),
        poster: (_str_match4 = str.match(/poster="([^"\n]+)"/)) === null || _str_match4 === void 0 ? void 0 : _str_match4[1]
    };
};
/**
 * 构建媒体元素对象
 */ var buildMediaElement = function buildMediaElement(url, tagName, attrs) {
    var result = {
        url: url,
        align: attrs.align,
        alt: attrs.alt,
        tagName: tagName,
        controls: !!attrs.controls,
        autoplay: !!attrs.autoplay,
        loop: !!attrs.loop,
        muted: !!attrs.muted,
        poster: attrs.poster
    };
    // 只有当值存在时才设置，避免类型错误
    if (attrs.height) {
        result.height = +attrs.height;
    }
    if (attrs.width) {
        result.width = +attrs.width;
    }
    return result;
};
/**
 * 从字符串中提取视频源 URL
 */ var extractVideoSource = function extractVideoSource(str, tagName) {
    // 首先尝试从标签本身获取 src 属性
    var url = str.match(/src="([^"\n]+)"/);
    // 如果是 video 标签且没有找到 src，尝试从 source 标签中获取
    if (tagName === 'video' && !url) {
        var sourceMatch = str.match(/<source[^>]*src="([^"\n]+)"[^>]*>/);
        if (sourceMatch) {
            url = sourceMatch;
        }
    }
    return url === null || url === void 0 ? void 0 : url[1];
};
/**
 * 查找并解析媒体元素（img/video/iframe）
 */ export var findImageElement = function findImageElement(str) {
    try {
        // 首先尝试匹配包含 source 标签的 video 格式
        var videoWithSourceMatch = str.match(/^\s*<video[^>\n]*>[\s\S]*?<source[^>]*src="([^"\n]+)"[^>]*>[\s\S]*?<\/video>\s*$/);
        if (videoWithSourceMatch) {
            var attrs = extractMediaAttributes(str);
            return buildMediaElement(videoWithSourceMatch[1], 'video', attrs);
        }
        // 尝试匹配各种媒体标签格式
        var patterns = [
            /^\s*<(img|video|iframe)[^>\n]*>.*?<\/(?:img|video|iframe)>\s*$/,
            /^\s*<(img|video|iframe)[^>\n]*\/?>(.*<\/(?:img|video|iframe)>)?\s*$/,
            /^\s*<(img|video|iframe)[^>\n]*\/>\s*$/,
            /^\s*<(img|video|iframe)[^>\n]*>\s*$/
        ];
        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
        try {
            for(var _iterator = patterns[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                var pattern = _step.value;
                var match = str.match(pattern);
                if (match) {
                    var _match__match;
                    var tagName = (_match__match = match[0].match(/<(img|video|iframe)/)) === null || _match__match === void 0 ? void 0 : _match__match[1];
                    var url = extractVideoSource(match[0], tagName);
                    var attrs1 = extractMediaAttributes(match[0]);
                    return buildMediaElement(url, tagName, attrs1);
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally{
            try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                    _iterator.return();
                }
            } finally{
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }
        return null;
    } catch (e) {
        console.error('Failed to parse media element:', e);
        return null;
    }
};
/**
 * 根据媒体元素信息创建编辑器节点
 */ export var createMediaNodeFromElement = function createMediaNodeFromElement(mediaElement) {
    if (!mediaElement) return null;
    // 根据标签类型确定媒体类型
    var mediaTypeMap = {
        video: 'video',
        iframe: 'iframe',
        img: 'image'
    };
    var mediaType = mediaTypeMap[mediaElement.tagName] || 'image';
    return EditorUtils.createMediaNode(decodeURIComponentUrl(mediaElement.url || ''), mediaType, {
        align: mediaElement.align,
        alt: mediaElement.alt,
        height: mediaElement.height,
        width: mediaElement.width,
        controls: mediaElement.controls,
        autoplay: mediaElement.autoplay,
        loop: mediaElement.loop,
        muted: mediaElement.muted,
        poster: mediaElement.poster
    });
};
/**
 * 标准 HTML 元素列表
 * 这些标签会被正常解析为 HTML，其他标签会被当作普通文本处理
 */ export var STANDARD_HTML_ELEMENTS = new Set([
    // 文档结构
    'html',
    'head',
    'body',
    'title',
    'meta',
    'link',
    'style',
    'script',
    // 内容分区
    'header',
    'nav',
    'main',
    'section',
    'article',
    'aside',
    'footer',
    'h1',
    'h2',
    'h3',
    'h4',
    'h5',
    'h6',
    // 文本内容
    'div',
    'p',
    'hr',
    'pre',
    'blockquote',
    // 列表
    'ul',
    'ol',
    'li',
    'dl',
    'dt',
    'dd',
    // 表格
    'table',
    'thead',
    'tbody',
    'tfoot',
    'tr',
    'th',
    'td',
    'caption',
    'colgroup',
    'col',
    // 表单
    'form',
    'input',
    'textarea',
    'button',
    'select',
    'option',
    'label',
    'fieldset',
    'legend',
    // 内联文本语义
    'a',
    'em',
    'strong',
    'small',
    'mark',
    'del',
    'ins',
    'sub',
    'sup',
    'i',
    'b',
    'u',
    's',
    'code',
    'kbd',
    'samp',
    'var',
    'span',
    'br',
    'wbr',
    // 图片和多媒体
    'img',
    'video',
    'audio',
    'source',
    'track',
    'iframe',
    'embed',
    'object',
    'param',
    'picture',
    // 其他
    'canvas',
    'svg',
    'math',
    'details',
    'summary',
    'dialog',
    'menu',
    'menuitem',
    // 字体
    'font'
]);
/**
 * 检查 HTML 标签是否为标准元素
 * @param htmlString - HTML 字符串
 * @returns 是否为标准 HTML 元素
 */ export function isStandardHtmlElement(htmlString) {
    // 提取标签名（支持开始标签和结束标签）
    var tagMatch = htmlString.match(/<\/?(\w+)/);
    if (!tagMatch) return false;
    var tagName = tagMatch[1].toLowerCase();
    return STANDARD_HTML_ELEMENTS.has(tagName);
}
/**
 * 解析 HTML 注释中的上下文属性
 */ var parseCommentContextProps = function parseCommentContextProps(value, processedValue) {
    var _processedValue_trim, _processedValue_trim1;
    var isComment = value && (processedValue === null || processedValue === void 0 ? void 0 : (_processedValue_trim = processedValue.trim()) === null || _processedValue_trim === void 0 ? void 0 : _processedValue_trim.endsWith('-->')) && ((_processedValue_trim1 = processedValue.trim()) === null || _processedValue_trim1 === void 0 ? void 0 : _processedValue_trim1.startsWith('<!--'));
    if (!isComment) {
        return {};
    }
    var trimmedValue = value.trim();
    if (!trimmedValue) {
        return {};
    }
    var looksLikeJson = trimmedValue.startsWith('{') || trimmedValue.startsWith('[');
    if (!looksLikeJson) {
        return {};
    }
    try {
        return json5.parse(trimmedValue);
    } catch (e) {
        try {
            return partialJsonParse(trimmedValue);
        } catch (parseError) {
            console.warn('Failed to parse HTML comment as JSON or partial JSON:', {
                value: trimmedValue,
                error: parseError
            });
        }
        console.warn('HTML comment parse fallback attempted:', e);
    }
    return {};
};
/**
 * 处理块级 HTML 元素
 */ var handleBlockHtml = function handleBlockHtml(currentElement, processedValue, isUnclosedComment, parseMarkdownFn) {
    var thinkElement = findThinkElement(currentElement.value);
    if (thinkElement) {
        return {
            type: 'code',
            language: 'think',
            value: thinkElement.content,
            children: [
                {
                    text: thinkElement.content
                }
            ]
        };
    }
    var answerElement = findAnswerElement(currentElement.value);
    if (answerElement) {
        return {
            text: answerElement.content
        };
    }
    var mediaElement = findImageElement(currentElement.value);
    if (mediaElement) {
        return createMediaNodeFromElement(mediaElement);
    }
    if (currentElement.value === '<br/>') {
        return {
            type: 'paragraph',
            children: [
                {
                    text: ''
                }
            ]
        };
    }
    if (currentElement.value.match(/^<\/(img|video|iframe)>/)) {
        return null;
    }
    var commentValue = isUnclosedComment ? processedValue : currentElement.value;
    var isComment = commentValue.trim().startsWith('<!--') && commentValue.trim().endsWith('-->');
    // 检查是否是 otherProps 序列化生成的 JSON 注释
    // 这些注释应该被跳过，不应该被解析为 HTML 代码块
    // 但是，如果注释包含图表配置（chartType），应该保留为 code 节点以便表格解析器使用
    if (isComment) {
        try {
            var _parsed_;
            var commentContent = commentValue.replace('<!--', '').replace('-->', '').trim();
            var parsed = JSON.parse(commentContent);
            // 检查是否是图表配置
            var isChartConfig = // 对象格式：{"chartType": ...}
            (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && parsed !== null && !Array.isArray(parsed) && parsed.chartType || // 数组格式：[{"chartType": ...}]
            Array.isArray(parsed) && parsed.length > 0 && _type_of(parsed[0]) === 'object' && ((_parsed_ = parsed[0]) === null || _parsed_ === void 0 ? void 0 : _parsed_.chartType);
            // 如果能够成功解析为 JSON 对象，且是对象类型（不是数组或基本类型）
            // 注意：对象格式的图表配置已经在 handleHtml 中转换为数组格式了
            // 这里只处理非图表配置的对象格式注释
            if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && parsed !== null && !Array.isArray(parsed)) {
                // 如果包含 chartType 字段，说明是图表配置，应该已经在 handleHtml 中转换为数组格式
                // 这里不应该再匹配到对象格式的图表配置，继续正常处理
                if (isChartConfig && parsed.chartType) {
                // 继续正常处理，创建 code 节点（此时应该已经是数组格式了）
                } else {
                    // 否则认为是 otherProps 序列化生成的注释，应该返回空文本
                    // 这些注释应该在 parserMarkdownToSlateNode 中被跳过
                    return {
                        text: ''
                    };
                }
            }
        } catch (e) {
        // 解析失败，不是 JSON 格式的注释，继续正常处理
        }
    }
    if (isComment || isStandardHtmlElement(commentValue)) {
        // 优先处理 <p align="...">：将内部按 Markdown 解析以支持 ** 加粗等，保留 <p> 输出（不用注释）
        var pAlignMatch = commentValue.match(/<p\s+align="(left|right|center|justify)"[^>]*>([\s\S]*?)<\/p\s*>/i);
        if (pAlignMatch && parseMarkdownFn) {
            var align = pAlignMatch[1].toLowerCase();
            var schema = parseMarkdownFn(pAlignMatch[2]).schema;
            var first = schema === null || schema === void 0 ? void 0 : schema[0];
            if ((first === null || first === void 0 ? void 0 : first.type) === 'paragraph' && first.children) {
                return _object_spread_props(_object_spread({}, first), {
                    align: align,
                    otherProps: {
                        align: align
                    }
                });
            }
            if (first === null || first === void 0 ? void 0 : first.children) {
                return _object_spread_props(_object_spread({}, first), {
                    align: align,
                    otherProps: {
                        align: align
                    }
                });
            }
            return {
                type: 'paragraph',
                align: align,
                children: [
                    {
                        text: pAlignMatch[2].trim() || ''
                    }
                ],
                otherProps: {
                    align: align
                }
            };
        }
        if (commentValue.match(/<\/?(table|div|ul|li|ol|p|strong|h1|h2|h3|h4|h5|h6)[^\n>]*?>/)) {
            return htmlToFragmentList(commentValue, '');
        }
        return {
            type: 'code',
            language: 'html',
            render: true,
            value: commentValue,
            children: [
                {
                    text: commentValue
                }
            ]
        };
    }
    return {
        text: currentElement.value
    };
};
/**
 * 应用元素配置属性（纯函数版本）
 */ var applyElementConfig = function applyElementConfig(el, contextProps, processedValue, isUnclosedComment, currentElement) {
    var _valueToCheck_trim;
    if (!el || Array.isArray(el)) {
        return el;
    }
    var isPlainText = 'text' in el && Object.keys(el).length === 1;
    if (isPlainText) {
        return el;
    }
    var valueToCheck = isUnclosedComment ? processedValue : currentElement === null || currentElement === void 0 ? void 0 : currentElement.value;
    var otherProps = _object_spread({}, contextProps);
    // 只有当 finished === false 时才设置 finished 属性，否则删除
    if (isUnclosedComment) {
        otherProps.finished = false;
    }
    var result = _object_spread_props(_object_spread({}, el), {
        isConfig: valueToCheck === null || valueToCheck === void 0 ? void 0 : (_valueToCheck_trim = valueToCheck.trim()) === null || _valueToCheck_trim === void 0 ? void 0 : _valueToCheck_trim.startsWith('<!--')
    });
    // 只有当 otherProps 有内容时才设置，避免类型错误
    if (Object.keys(otherProps).length > 0) {
        result.otherProps = otherProps;
    }
    return result;
};
/**
 * 处理 span 标签的样式属性（纯函数版本）
 */ var processSpanTag = function processSpanTag(str, tag, htmlTag) {
    try {
        var styles = str.match(/style="([^"\n]+)"/);
        if (!styles) {
            return htmlTag;
        }
        var stylesMap = new Map(styles[1].split(';').map(function(item) {
            return item.split(':').map(function(item) {
                return item.trim();
            });
        }));
        var color = stylesMap.get('color');
        if (color) {
            return _to_consumable_array(htmlTag).concat([
                {
                    tag: tag,
                    color: color
                }
            ]);
        }
    } catch (e) {
        console.warn('Failed to parse span style attribute:', {
            str: str,
            error: e
        });
    }
    return htmlTag;
};
/**
 * 处理 a 标签的链接属性（纯函数版本）
 */ var processATag = function processATag(str, tag, htmlTag) {
    var url = str.match(/href="([\w:./_\-#\\]+)"/);
    if (url) {
        return _to_consumable_array(htmlTag).concat([
            {
                tag: tag,
                url: url[1]
            }
        ]);
    }
    return htmlTag;
};
/**
 * 处理 font 标签的颜色属性（纯函数版本）
 */ var processFontTag = function processFontTag(str, tag, htmlTag) {
    var colorMatch = str.match(/color="([^"\n]+)"/) || str.match(/color=([^"\n]+)/);
    if (colorMatch) {
        return _to_consumable_array(htmlTag).concat([
            {
                tag: tag,
                color: colorMatch[1].replaceAll('>', '')
            }
        ]);
    }
    return htmlTag;
};
/**
 * HTML 标签处理器映射表
 */ var htmlTagProcessors = {
    span: processSpanTag,
    a: processATag,
    font: processFontTag
};
/**
 * 处理HTML标签并添加到标签栈中（纯函数版本）
 * @param str - HTML标签字符串
 * @param tag - 标签名称
 * @param htmlTag - HTML标签栈
 * @returns 返回新的标签栈数组
 */ var processHtmlTag = function processHtmlTag(str, tag, htmlTag) {
    var processor = htmlTagProcessors[tag];
    if (processor) {
        return processor(str, tag, htmlTag);
    }
    return _to_consumable_array(htmlTag).concat([
        {
            tag: tag
        }
    ]);
};
/**
 * 处理内联HTML元素（纯函数版本）
 * @param currentElement - 当前处理的HTML元素
 * @param htmlTag - HTML标签栈
 * @returns 返回处理后的元素对象和新的标签栈，如果是标签则返回null
 */ var processInlineHtml = function processInlineHtml(currentElement, htmlTag) {
    var value = currentElement.value;
    if (value.match(/<br\/?>/)) {
        return {
            el: {
                type: 'break',
                children: [
                    {
                        text: '\n'
                    }
                ]
            },
            htmlTag: htmlTag
        };
    }
    var answerElement = findAnswerElement(value);
    if (answerElement) {
        return {
            el: {
                text: answerElement.content
            },
            htmlTag: htmlTag
        };
    }
    if (!isStandardHtmlElement(value)) {
        return {
            el: {
                text: value
            },
            htmlTag: htmlTag
        };
    }
    var htmlMatch = value.match(/<\/?(b|i|del|font|code|span|sup|sub|strong|a)[^\n>]*?>/);
    if (htmlMatch) {
        var _htmlMatch = _sliced_to_array(htmlMatch, 2), str = _htmlMatch[0], tag = _htmlMatch[1];
        var isClosingTag = str.startsWith('</');
        var isMatchingTag = isClosingTag && htmlTag.length && htmlTag[htmlTag.length - 1].tag === tag;
        var newHtmlTag = htmlTag;
        if (isMatchingTag) {
            newHtmlTag = htmlTag.slice(0, -1);
        }
        if (!isClosingTag) {
            newHtmlTag = processHtmlTag(str, tag, newHtmlTag);
        }
        return {
            el: null,
            htmlTag: newHtmlTag
        };
    }
    var mediaElement = findImageElement(value);
    return {
        el: mediaElement ? createMediaNodeFromElement(mediaElement) : {
            text: value
        },
        htmlTag: htmlTag
    };
};
/**
 * 查找附件链接
 */ export var findAttachment = function findAttachment(str) {
    try {
        var match = str.match(/^\s*<a[^>\n]*download[^>\n]*\/?>(.*<\/a>:?)?\s*$/);
        if (match) {
            var url = match[0].match(/href="([^"\n]+)"/);
            var size = match[0].match(/data-size="(\d+)"/);
            if (url) {
                return {
                    url: url[1],
                    size: Number((size === null || size === void 0 ? void 0 : size[1]) || 0)
                };
            }
        }
        return null;
    } catch (e) {
        return null;
    }
};
/**
 * 处理HTML节点
 * @param currentElement - 当前处理的HTML元素
 * @param parent - 父级元素，用于判断上下文
 * @param htmlTag - HTML标签栈，用于跟踪嵌套的HTML标签
 * @param parseMarkdownFn - 可选，解析 Markdown 得到 schema，用于 <p align> 内部按 Markdown 解析（如 ** 加粗）
 * @returns 返回包含解析后元素和上下文属性的对象
 */ export var handleHtml = function handleHtml(currentElement, parent, htmlTag, parseMarkdownFn) {
    var _currentElement_value;
    var trimmedValue = (currentElement === null || currentElement === void 0 ? void 0 : (_currentElement_value = currentElement.value) === null || _currentElement_value === void 0 ? void 0 : _currentElement_value.trim()) || '';
    var isUnclosedComment = trimmedValue.startsWith('<!--') && !trimmedValue.endsWith('-->');
    var processedValue = isUnclosedComment ? trimmedValue + '-->' : (currentElement === null || currentElement === void 0 ? void 0 : currentElement.value) || '';
    // 检查是否是对象格式的图表配置，如果是则转换为数组格式
    var isComment = processedValue.trim().startsWith('<!--') && processedValue.trim().endsWith('-->');
    if (isComment) {
        try {
            var commentContent = processedValue.replace('<!--', '').replace('-->', '').trim();
            var parsed = JSON.parse(commentContent);
            // 如果是对象格式且包含 chartType，转换为数组格式
            if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && parsed !== null && !Array.isArray(parsed) && parsed.chartType) {
                var arrayFormat = [
                    parsed
                ];
                var convertedContent = JSON.stringify(arrayFormat);
                processedValue = "<!--".concat(convertedContent, "-->");
                // 同时更新 currentElement.value，以便后续处理使用
                currentElement.value = processedValue;
            }
        } catch (e) {
        // 解析失败，不是 JSON 格式的注释，继续正常处理
        }
    }
    var value = (processedValue === null || processedValue === void 0 ? void 0 : processedValue.replace('<!--', '').replace('-->', '').trim()) || '{}';
    var contextProps = parseCommentContextProps(value, processedValue);
    var isBlockLevel = !parent || [
        'listItem',
        'blockquote'
    ].includes(parent.type);
    var el;
    var updatedHtmlTag = htmlTag;
    if (isBlockLevel) {
        el = handleBlockHtml(currentElement, processedValue, isUnclosedComment, parseMarkdownFn);
    } else {
        var inlineResult = processInlineHtml(currentElement, htmlTag);
        el = inlineResult.el;
        updatedHtmlTag = inlineResult.htmlTag;
    }
    var configuredEl = applyElementConfig(el, contextProps, processedValue, isUnclosedComment, currentElement);
    return {
        el: configuredEl,
        contextProps: contextProps,
        htmlTag: updatedHtmlTag
    };
};
/**
 * 预处理特殊标签（think/answer），将其转换为代码块格式
 * @param markdown - 原始 Markdown 字符串
 * @param tagName - 标签名称（think 或 answer）
 * @returns 处理后的 Markdown 字符串
 */ export function preprocessSpecialTags(markdown, tagName) {
    var tagRegex = new RegExp("<".concat(tagName, ">([\\s\\S]*?)<\\/").concat(tagName, ">"), 'g');
    return markdown === null || markdown === void 0 ? void 0 : markdown.replace(tagRegex, function(match, content) {
        var trimmedContent = content.trim();
        // 如果内容中包含代码块标记（三个反引号），需要进行转义
        // 策略：使用特殊标记替换代码块，保持原始格式
        var processedContent = trimmedContent === null || trimmedContent === void 0 ? void 0 : trimmedContent.replace(/```(\w*)\n?([\s\S]*?)```/g, function(_, lang, code) {
            // 使用特殊标记包裹，保留语言和代码内容
            // 格式：【CODE_BLOCK:lang】code【/CODE_BLOCK】
            var marker = '\u200B'; // 零宽空格，用于标记
            return "".concat(marker, "【CODE_BLOCK:").concat(lang || '', "】\n").concat(code, "\n【/CODE_BLOCK】").concat(marker);
        });
        // 构建对应类型的代码块
        return "```".concat(tagName, "\n").concat(processedContent, "\n```");
    });
}
/**
 * 预处理 <think> 标签，将其转换为 ```think 代码块格式
 * @param markdown - 原始 Markdown 字符串
 * @returns 处理后的 Markdown 字符串
 */ export function preprocessThinkTags(markdown) {
    return preprocessSpecialTags(normalizeThinkTagAliases(markdown), 'think');
}
/**
 * 预处理所有非标准 HTML 标签，提取其内容（删除标签本身）
 * @param markdown - 原始 Markdown 字符串
 * @returns 处理后的 Markdown 字符串
 */ export function preprocessNonStandardHtmlTags(markdown) {
    var result = markdown;
    var hasNonStandardTags = true;
    // 循环处理，直到没有非标准标签（处理嵌套情况）
    while(hasNonStandardTags){
        var before = result;
        // 匹配所有 HTML 标签对：<tagname>content</tagname>
        result = result.replace(/<(\w+)>([\s\S]*?)<\/\1>/g, function(match, tagName, content) {
            // 检查是否为标准 HTML 元素
            if (STANDARD_HTML_ELEMENTS.has(tagName.toLowerCase())) {
                // 标准元素保持不变
                return match;
            }
            // 非标准元素只保留内容（不 trim，保持原始格式）
            return content;
        });
        // 如果没有变化，说明处理完成
        hasNonStandardTags = before !== result;
    }
    return result;
}
