@ant-design/agentic-ui 2.21.0 → 2.23.0

package/dist/MarkdownEditor/editor/parser/parse/parseHtml.js

@@ -0,0 +1,781 @@
+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";
+/**
+ * 解码 URI 组件，处理错误情况
+ */ export var decodeURIComponentUrl = function(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(str) {
+    try {
+        // 匹配 <think>内容</think> 格式
+        var thinkMatch = str.match(/^\s*<think>([\s\S]*?)<\/think>\s*$/);
+        if (thinkMatch) {
+            return {
+                content: thinkMatch[1].trim()
+            };
+        }
+        return null;
+    } catch (e) {
+        return null;
+    }
+};
+/**
+ * 检测和解析 answer 标签
+ * @param str - 要检测的字符串
+ * @returns answer 标签的内容，如果不是 answer 标签则返回 null
+ */ var findAnswerElement = function(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(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(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(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(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(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(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 {};
+    }
+    try {
+        return json5.parse(value);
+    } catch (e) {
+        try {
+            return partialJsonParse(value);
+        } catch (parseError) {
+            console.warn('Failed to parse HTML comment as JSON or partial JSON:', {
+                value: value,
+                error: parseError
+            });
+        }
+        console.warn('HTML comment parse fallback attempted:', e);
+    }
+    return {};
+};
+/**
+ * 处理块级 HTML 元素
+ */ var handleBlockHtml = function(currentElement, processedValue, isUnclosedComment) {
+    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 代码块
+    if (isComment) {
+        try {
+            var commentContent = commentValue.replace('<!--', '').replace('-->', '').trim();
+            var parsed = JSON.parse(commentContent);
+            // 如果能够成功解析为 JSON 对象，且是对象类型（不是数组或基本类型），
+            // 则认为是 otherProps 序列化生成的注释，应该返回 null 或空文本
+            // 这些注释应该在 parserMarkdownToSlateNode 中被跳过
+            if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                return {
+                    text: ''
+                };
+            }
+        } catch (e) {
+        // 解析失败，不是 JSON 格式的注释，继续正常处理
+        }
+    }
+    if (isComment || isStandardHtmlElement(commentValue)) {
+        return commentValue.match(/<\/?(table|div|ul|li|ol|p|strong)[^\n>]*?>/) ? htmlToFragmentList(commentValue, '') : {
+            type: 'code',
+            language: 'html',
+            render: true,
+            value: commentValue,
+            children: [
+                {
+                    text: commentValue
+                }
+            ]
+        };
+    }
+    return {
+        text: currentElement.value
+    };
+};
+/**
+ * 应用元素配置属性（纯函数版本）
+ */ var applyElementConfig = function(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(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(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(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(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(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(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标签
+ * @returns 返回包含解析后元素和上下文属性的对象
+ */ export var handleHtml = function(currentElement, parent, htmlTag) {
+    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 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);
+    } 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(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;
+}