@ant-design/agentic-ui 2.20.2 → 2.22.0

package/dist/MarkdownEditor/editor/parser/parserSlateNodeToMarkdown.js

@@ -336,6 +336,7 @@ var inlineNode = new Set([
             var configProps = _object_spread({}, node.otherProps);
             delete configProps['columns'];
             delete configProps['dataSource'];
+            delete configProps['finished'];
             if (node.type === 'link-card') {
                 configProps.type = 'card';
                 configProps.url = encodeURI(node === null || node === void 0 ? void 0 : node.url);
@@ -356,9 +357,107 @@ var inlineNode = new Set([
                 }
             });
             // 只有当 configProps 不为空对象时才生成注释
-            if (Object.keys(configProps).length > 0) {
-                var propsToSerialize = node.type === 'chart' && configProps.config ? configProps.config : configProps;
-                str += "<!--".concat(JSON.stringify(propsToSerialize), "-->\n");
+            // 检查 configProps 是否为空对象（删除 finished 后可能变成空对象）
+            var hasValidProps = Object.keys(configProps).length > 0;
+            if (hasValidProps) {
+                /**
+         * 将对象转换为数组（处理 {0: {...}, 1: {...}} 这种错误格式）
+         * @param obj - 要转换的对象
+         * @returns 转换后的数组，如果不是数字键对象则返回原对象
+         */ var convertObjectToArray = function(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') {
+                    var chartConfig = configProps.config;
+                    // 如果 config 不存在，但 configProps 看起来像图表配置（有 chartType），使用 configProps
+                    if (!chartConfig && configProps.chartType) {
+                        chartConfig = configProps;
+                    }
+                    // 如果 chartConfig 是对象且键都是数字（如 {0: {...}}），转换为数组
+                    chartConfig = convertObjectToArray(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) || {};
@@ -549,25 +648,51 @@ export var isMix = function(t) {
     if (!t.text && !t.tag) return '';
     var str = (t === null || t === void 0 ? void 0 : (_t_text = t.text) === null || _t_text === void 0 ? void 0 : _t_text.replace(RegExp("(?<!\\\\)\\\\", "g"), '\\').replace(/\n/g, '  \n')) || '';
     var preStr = '', afterStr = '';
-    // Extract whitespace
-    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();
-    }
     // 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) {
-            str = "`".concat("${placeholder:".concat((t === null || t === void 0 ? void 0 : t.placeholder) || '-', ",value:").concat(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 = "`".concat(str || "${placeholder:".concat((t === null || t === void 0 ? void 0 : t.placeholder) || '-', "}") || '', "`");
+            // 都没有，使用默认值（不保留空白字符）
+            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

package/dist/MarkdownEditor/editor/parser/remarkParse.d.ts

@@ -1,3 +1,13 @@
+/**
+ * 将段落节点转换为相应的节点类型（根据内容开头字符）
+ * - ! 开头 → image
+ * - | 开头 → table
+ * - [ 开头 → link
+ *
+ * @returns {(tree: any) => void}
+ *   Transformer function.
+ */
+export declare function convertParagraphToImage(): (tree: any) => void;
 /**
  * Plugin to fix bold text containing special characters like **$9.698M**, **57%**, etc.
  *
@@ -5,5 +15,5 @@
  *   Transformer function.
  */
 export declare function fixStrongWithSpecialChars(): (tree: any) => void;
-declare const markdownParser: import("unified").Processor<import("mdast").Root, import("hast").Root, import("hast").Root, import("mdast").Root, string>;
+declare const markdownParser: import("unified").Processor<import("mdast").Root, undefined, undefined, import("mdast").Root, string>;
 export default markdownParser;

package/dist/MarkdownEditor/editor/parser/remarkParse.js

@@ -23,16 +23,129 @@ function _unsupported_iterable_to_array(o, minLen) {
     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 rehypeKatex from "rehype-katex";
-import rehypeRaw from "rehype-raw";
 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 remarkRehype from "remark-rehype";
 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.
  *
@@ -47,13 +160,18 @@ import { visit } from "unist-util-visit";
                 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;
-                            var newNodes = [];
-                            var lastIndex = 0;
+                            hasMatch = true;
                             var match = void 0;
                             // 分割文本并创建新的节点结构
                             while((match = strongPattern.exec(child.value)) !== null){
@@ -83,22 +201,52 @@ import { visit } from "unist-util-visit";
                             if (lastIndex < child.value.length) {
                                 var afterText = child.value.slice(lastIndex);
                                 if (afterText) {
-                                    newNodes.push({
-                                        type: 'text',
-                                        value: 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
+                                        });
+                                    }
                                 }
                             }
-                            // 替换当前文本节点
-                            if (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; // 调整索引以跳过新插入的节点
+                        } 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; // 调整索引以跳过新插入的节点
+                        }
                     }
                 }
             }
@@ -106,13 +254,18 @@ import { visit } from "unist-util-visit";
         // 处理所有文本节点（作为备用方案）
         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;
-                    var newNodes = [];
-                    var lastIndex = 0;
+                    hasMatch = true;
                     var match;
                     // 分割文本并创建新的节点结构
                     while((match = strongPattern.exec(node.value)) !== null){
@@ -142,33 +295,66 @@ import { visit } from "unist-util-visit";
                     if (lastIndex < node.value.length) {
                         var afterText = node.value.slice(lastIndex);
                         if (afterText) {
-                            newNodes.push({
-                                type: 'text',
-                                value: 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
+                                });
+                            }
                         }
                     }
-                    // 替换原节点
-                    if (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)));
+                } 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)));
+                }
             }
         });
     };
 }
-// 完整的 HTML 渲染解析器
-var markdownParser = unified().use(remarkParse).use(remarkHtml).use(remarkGfm) // GFM 插件
+// Markdown 解析器（用于解析 Markdown 为 mdast AST）
+// 注意：这个解析器只用于解析，不包含 HTML 渲染相关的插件
+var markdownParser = unified().use(remarkParse) // 解析 Markdown
+.use(remarkHtml).use(remarkFrontmatter, [
+    'yaml'
+]) // 处理前置元数据
+.use(remarkGfm) // GFM 插件
 .use(fixStrongWithSpecialChars) // 修复包含特殊字符的加粗文本
+.use(convertParagraphToImage) // 将以 ! 开头的段落转换为图片,将 | 开头的段落转换为表格
 .use(remarkMath, {
     singleDollarTextMath: true
-}).use(remarkRehype, {
-    allowDangerousHtml: true
-}).use(rehypeRaw).use(rehypeKatex).use(remarkFrontmatter, [
-    'yaml'
-]);
+});
+// 默认导出解析器（用于解析 Markdown 为 mdast AST）
 export default markdownParser;

package/dist/MarkdownEditor/editor/plugins/elements.js

@@ -24,7 +24,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 import { Editor, Node, Path, Point, Range, Transforms } from "slate";
-import { decodeURIComponentUrl } from "../parser/parserMarkdownToSlateNode";
+import { decodeURIComponentUrl } from "../parser/parse/parseHtml";
 import { EditorUtils } from "../utils/editorUtils";
 export var insertAfter = function(editor, path) {
     var node = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {

package/dist/MarkdownEditor/editor/types/Table.d.ts

@@ -3,6 +3,7 @@ export type TableCustomElement = TableNode | TableHeadNode | TableFooterNode | T
 export interface TableNode {
     type: 'table';
     children: Array<TableHeadNode | TrNode | TableFooterNode>;
+    finished?: boolean;
     otherProps?: {
         mergeCells?: Array<{
             row: number;
@@ -10,7 +11,7 @@ export interface TableNode {
             rowSpan: number;
             colSpan: number;
         }>;
-        finish?: boolean;
+        finished?: boolean;
         config?: any;
         columns?: Array<any>;
     };

package/dist/MarkdownEditor/editor/utils/markdownToHtml.js

@@ -166,7 +166,7 @@ import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import { unified } from "unified";
 import { visit } from "unist-util-visit";
-import { fixStrongWithSpecialChars } from "../parser/remarkParse";
+import { convertParagraphToImage, fixStrongWithSpecialChars } from "../parser/remarkParse";
 // HTML 转义相关的正则表达式和工具
 var ESCAPE_TEST_NO_ENCODE = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
 var ESCAPE_TEST = /[&<>"']/;
@@ -295,6 +295,7 @@ export var DEFAULT_MARKDOWN_REMARK_PLUGINS = [
     remarkParse,
     remarkGfm,
     fixStrongWithSpecialChars,
+    convertParagraphToImage,
     [
         remarkMath,
         INLINE_MATH_WITH_SINGLE_DOLLAR

package/dist/MarkdownEditor/el.d.ts

@@ -74,6 +74,7 @@ export type ListNode<T = Record<string, any>> = {
     order?: boolean;
     start?: number;
     task?: boolean;
+    finished?: boolean;
     h?: number;
 };
 export type ChartTypeConfig<T = Record<string, any>> = {
@@ -139,6 +140,7 @@ export type MediaNode<T = Record<string, any>> = {
     url?: string;
     alt: string;
     downloadUrl?: string;
+    finished?: boolean;
     height?: number;
     width?: number;
     docId?: string;
@@ -164,6 +166,7 @@ export type LinkCardNode<T = Record<string, any>> = {
     title?: string;
     name?: string;
     alt: string;
+    finished?: boolean;
     children: BaseElement['children'];
 };
 export type AttachNode<T = Record<string, any>> = {

package/dist/MarkdownEditor/style.js

@@ -83,6 +83,8 @@ var genStyle = function(token) {
         '&-edit-area': {
             outline: 'none !important'
         },
+        '&-container': {
+        },
         '&-content': _define_property({
             // 默认 padding，可以通过 contentStyle 覆盖
             // 使用 CSS 变量，允许通过内联样式覆盖

package/dist/Plugins/chart/index.js

@@ -316,7 +316,7 @@ export { ChartFilter, ChartToolBar, downloadChart } from "./components";
     ]);
     var columns = ((_node_otherProps2 = node.otherProps) === null || _node_otherProps2 === void 0 ? void 0 : _node_otherProps2.columns) || [];
     // 检查图表是否未闭合
-    var isUnclosed = (node === null || node === void 0 ? void 0 : (_node_otherProps3 = node.otherProps) === null || _node_otherProps3 === void 0 ? void 0 : _node_otherProps3.finish) === false;
+    var isUnclosed = (node === null || node === void 0 ? void 0 : (_node_otherProps3 = node.otherProps) === null || _node_otherProps3 === void 0 ? void 0 : _node_otherProps3.finished) === false;
     // 获取编辑器更新函数
     var _useMEditor = _sliced_to_array(useMEditor(node), 2), update = _useMEditor[1];
     // 判断是否是最后一个节点
@@ -334,11 +334,11 @@ export { ChartFilter, ChartToolBar, downloadChart } from "./components";
     useEffect(function() {
         if (isUnclosed && !readonly && !isLastNode) {
             var _node_otherProps;
-            // 检查 finish 是否仍然是 false（可能已经被其他逻辑更新）
-            if ((node === null || node === void 0 ? void 0 : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.finish) === false) {
+            // 检查 finished 是否仍然是 false（可能已经被其他逻辑更新）
+            if ((node === null || node === void 0 ? void 0 : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.finished) === false) {
                 update({
                     otherProps: _object_spread_props(_object_spread({}, node === null || node === void 0 ? void 0 : node.otherProps), {
-                        finish: true
+                        finished: true
                     })
                 }, node);
             }
@@ -355,11 +355,11 @@ export { ChartFilter, ChartToolBar, downloadChart } from "./components";
         if (isUnclosed && !readonly && isLastNode) {
             var timer = setTimeout(function() {
                 var _node_otherProps;
-                // 检查 finish 是否仍然是 false（可能已经被其他逻辑更新）
-                if ((node === null || node === void 0 ? void 0 : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.finish) === false) {
+                // 检查 finished 是否仍然是 false（可能已经被其他逻辑更新）
+                if ((node === null || node === void 0 ? void 0 : (_node_otherProps = node.otherProps) === null || _node_otherProps === void 0 ? void 0 : _node_otherProps.finished) === false) {
                     update({
                         otherProps: _object_spread_props(_object_spread({}, node === null || node === void 0 ? void 0 : node.otherProps), {
-                            finish: true
+                            finished: true
                         })
                     }, node);
                 }