react-ai-renderer 0.1.2 → 0.1.3

package/dist/index-53d781f0.js

@@ -0,0 +1,1476 @@
+'use strict';
+
+var React = require('react');
+var runtime = require('react/jsx-runtime');
+var RemarkMath = require('remark-math');
+var RemarkBreaks = require('remark-breaks');
+var RemarkGfm = require('remark-gfm');
+var mdx = require('@mdx-js/mdx');
+var RehypeKatex = require('rehype-katex');
+var RehypeHighlight = require('rehype-highlight');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+var runtime__namespace = /*#__PURE__*/_interopNamespaceDefault(runtime);
+
+var MDXStreamingParser = /** @class */function () {
+  function MDXStreamingParser(components) {
+    // 将组件名称存储在Set中，而不是整个组件对象
+    this.registeredComponents = new Set(components.map(function (c) {
+      return c.name;
+    }));
+    this.messages = new Map();
+  }
+  // 检查组件是否已注册
+  MDXStreamingParser.prototype.isComponentRegistered = function (name) {
+    return this.registeredComponents.has(name);
+  };
+  MDXStreamingParser.prototype.parse = function (messageId, input) {
+    var state = {
+      position: 0,
+      stack: [],
+      buffer: ''
+    };
+    var result = [];
+    var i = state.position;
+    while (i < input.length) {
+      var char = input[i];
+      if (char === '<') {
+        // Handle closing tags
+        if (input[i + 1] === '/') {
+          var closeTagEnd = input.indexOf('>', i);
+          if (closeTagEnd === -1) {
+            state.buffer += input.slice(i);
+            break;
+          }
+          var tagName = input.slice(i + 2, closeTagEnd);
+          // 检查组件是否已注册
+          var isRegistered = this.isComponentRegistered(tagName);
+          // 如果组件未注册，则作为文本处理
+          if (!isRegistered) {
+            state.buffer += input.slice(i, closeTagEnd + 1);
+            i = closeTagEnd + 1;
+            continue;
+          }
+          if (/^[A-Z][A-Za-z0-9]*$/.test(tagName)) {
+            // Handle text content in the buffer
+            var trimmedContent = state.buffer.trim();
+            if (trimmedContent && state.stack.length > 0) {
+              var currentComponent = state.stack[state.stack.length - 1];
+              if (!currentComponent.children) {
+                currentComponent.children = [];
+              }
+              if (typeof currentComponent.children === 'string') {
+                currentComponent.children = [{
+                  type: "text",
+                  value: currentComponent.children
+                }];
+              }
+              currentComponent.children.push({
+                type: "text",
+                value: trimmedContent
+              });
+            }
+            state.buffer = '';
+            state.stack.pop();
+            i = closeTagEnd + 1;
+            continue;
+          }
+        }
+        // Handle opening tags
+        var tagMatch = input.slice(i).match(/^<([A-Z][A-Za-z0-9]*)/);
+        if (tagMatch) {
+          // Handle accumulated text before the tag
+          var componentName = tagMatch[1];
+          // 检查组件是否已注册
+          var isRegistered = this.isComponentRegistered(componentName);
+          // 如果组件未注册，将整个标签作为文本处理
+          if (!isRegistered) {
+            state.buffer += input[i];
+            i++;
+            continue;
+          }
+          var trimmedText = state.buffer.trim();
+          if (trimmedText && state.stack.length === 0) {
+            result.push({
+              type: "text",
+              value: trimmedText
+            });
+          } else if (trimmedText && state.stack.length > 0) {
+            var currentComponent = state.stack[state.stack.length - 1];
+            if (!currentComponent.children) {
+              currentComponent.children = [];
+            }
+            if (typeof currentComponent.children === 'string') {
+              currentComponent.children = [{
+                type: "text",
+                value: currentComponent.children
+              }];
+            }
+            currentComponent.children.push({
+              type: "text",
+              value: trimmedText
+            });
+          }
+          state.buffer = '';
+          // 动态解析标签形式，不再依赖预先注册的 selfClosing 属性
+          var _a = this.parseComponentTag(input.slice(i)),
+            props = _a.props,
+            endIndex = _a.endIndex,
+            selfClosing = _a.selfClosing;
+          var component = {
+            type: "component",
+            value: componentName,
+            props: props,
+            selfClosing: selfClosing // 使用实际解析出的标签形式
+          };
+          if (!selfClosing) {
+            state.stack.push(component);
+            if (state.stack.length === 1) {
+              result.push(component);
+            } else {
+              var parent_1 = state.stack[state.stack.length - 2];
+              if (!parent_1.children || typeof parent_1.children === 'string') {
+                parent_1.children = [];
+              }
+              parent_1.children.push(component);
+            }
+          } else {
+            if (state.stack.length === 0) {
+              result.push(component);
+            } else {
+              var parent_2 = state.stack[state.stack.length - 1];
+              if (!parent_2.children || typeof parent_2.children === 'string') {
+                parent_2.children = [];
+              }
+              parent_2.children.push(component);
+            }
+          }
+          i += endIndex;
+          char = input[i];
+          continue;
+        }
+      }
+      state.buffer += char;
+      i++;
+    }
+    // Handle any remaining text in the buffer
+    var finalText = state.buffer.trim();
+    if (finalText && state.stack.length === 0) {
+      if (finalText === '<') {
+        result.push({
+          type: "text",
+          value: ''
+        });
+      } else {
+        result.push({
+          type: "text",
+          value: finalText
+        });
+      }
+    } else if (finalText && state.stack.length > 0) {
+      var currentComponent = state.stack[state.stack.length - 1];
+      if (!currentComponent.children) {
+        currentComponent.children = [];
+      }
+      if (typeof currentComponent.children === 'string') {
+        currentComponent.children = [{
+          type: "text",
+          value: currentComponent.children
+        }];
+      }
+      currentComponent.children.push({
+        type: "text",
+        value: finalText
+      });
+    }
+    state.position = i;
+    return result;
+  };
+  MDXStreamingParser.prototype.findComponentClose = function (input, startIndex) {
+    var depth = 1;
+    var i = startIndex;
+    var openclose = false; // 内嵌开闭标签要成对
+    while (i < input.length) {
+      if (input[i] === '/' && input[i + 1] === '>') {
+        depth--;
+        if (depth === 0) return i + 2;
+        i += 2;
+      } else if (input[i] === '<') {
+        openclose = true;
+        depth++;
+        i++;
+      } else if (input[i] === '>') {
+        if (openclose) {
+          openclose = false;
+          depth--;
+        }
+        if (depth === 0) return i + 1;
+        i++;
+      } else {
+        i++;
+      }
+    }
+    return input.length;
+  };
+  MDXStreamingParser.prototype.parseComponentTag = function (input) {
+    var props = {};
+    var i = 0;
+    // 跳过组件名
+    while (i < input.length && input[i] !== ' ' && input[i] !== '>') i++;
+    // 使用 parsePropsCommon 方法解析属性，该方法会返回标签形式信息
+    var _a = this.parsePropsCommon(input),
+      parsedProps = _a.props,
+      endIndex = _a.endIndex,
+      selfClosing = _a.selfClosing;
+    Object.assign(props, parsedProps);
+    return {
+      props: props,
+      endIndex: endIndex,
+      selfClosing: selfClosing
+    };
+  };
+  MDXStreamingParser.prototype.parsePropsCommon = function (input) {
+    var props = {};
+    var i = 0;
+    var inQuote = false;
+    var quoteChar = '';
+    var bracketCount = 0;
+    var selfClosing = false;
+    // 跳过组件名
+    while (i < input.length && input[i] !== ' ' && input[i] !== '>') i++;
+    while (i < input.length) {
+      var char = input[i];
+      if (char === '"' || char === "'") {
+        if (!inQuote) {
+          inQuote = true;
+          quoteChar = char;
+        } else if (char === quoteChar && bracketCount === 0) {
+          inQuote = false;
+        }
+      } else if (char === '{' && !inQuote) {
+        bracketCount++;
+      } else if (char === '}' && !inQuote) {
+        bracketCount--;
+      } else if (char === '/' && input[i + 1] === '>' && !inQuote && bracketCount === 0) {
+        selfClosing = true;
+        return {
+          props: props,
+          endIndex: i + 2,
+          selfClosing: selfClosing
+        };
+      } else if (char === '>' && !inQuote && bracketCount === 0) {
+        return {
+          props: props,
+          endIndex: i + 1,
+          selfClosing: selfClosing
+        };
+      }
+      if (char === '=' && !inQuote && bracketCount === 0) {
+        var propName = '';
+        var j = i - 1;
+        while (j >= 0 && /[\w-]/.test(input[j])) {
+          propName = input[j] + propName;
+          j--;
+        }
+        var value = '';
+        j = i + 1;
+        if (input[j] === '{') {
+          // 处理 JSON 值
+          var startBracket = j;
+          bracketCount = 1;
+          j++;
+          while (j < input.length && bracketCount > 0) {
+            if (input[j] === '{') bracketCount++;
+            if (input[j] === '}') bracketCount--;
+            j++;
+          }
+          value = input.slice(startBracket + 1, j - 1);
+          try {
+            // 处理属性值中的模板字符串
+            value = value.replace(/`([^`]*)`/g, function (match, p1) {
+              return JSON.stringify(p1);
+            });
+            // 处理可能的对象字面量
+            if (value.trim().startsWith('{')) {
+              props[propName] = JSON.parse(value);
+            } else {
+              // 处理其他 JSON 值
+              try {
+                props[propName] = JSON.parse(value);
+              } catch (_a) {
+                // 如果不是有效的 JSON，保持原值
+                props[propName] = value;
+              }
+            }
+          } catch (e) {
+            console.warn("Failed to parse prop value for ".concat(propName, ":"), value);
+            props[propName] = value;
+          }
+          i = j;
+          continue;
+        } else if (input[j] === '"' || input[j] === "'") {
+          // 处理字符串值
+          var quote = input[j];
+          j++;
+          while (j < input.length && input[j] !== quote) {
+            value += input[j];
+            j++;
+          }
+          props[propName] = value;
+          i = j + 1;
+          continue;
+        }
+      }
+      i++;
+    }
+    return {
+      props: props,
+      endIndex: i,
+      selfClosing: selfClosing
+    };
+  };
+  MDXStreamingParser.prototype.parsePropsSelfClosing = function (content) {
+    var props = {};
+    // 先找到当前标签的结束位置
+    var endIndex = content.indexOf('/>');
+    if (endIndex === -1) return props;
+    // 只处理当前标签内的内容
+    var tagContent = content.slice(0, endIndex);
+    // 使用更精确的正则匹配属性
+    var propRegex = /(\w+)=(?:"([^"]*)"|'([^']*)'|{([^}]*)})/g;
+    var match;
+    while ((match = propRegex.exec(tagContent)) !== null) {
+      var propName = match[1];
+      var value = void 0;
+      if (match[2] !== undefined) {
+        // 处理双引号值
+        value = match[2];
+      } else if (match[3] !== undefined) {
+        // 处理单引号值
+        value = match[3];
+      } else if (match[4] !== undefined) {
+        // 处理花括号值
+        try {
+          value = JSON.parse(match[4]);
+        } catch (e) {
+          value = match[4]; // 解析失败保留原始值
+        }
+      }
+      props[propName] = value;
+    }
+    return props;
+  };
+  MDXStreamingParser.prototype.reset = function () {
+    this.messages.clear();
+  };
+  return MDXStreamingParser;
+}();
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var CodeHighlight = function (_a) {
+  var textContent = _a.textContent,
+    _b = _a.language,
+    language = _b === void 0 ? "txt" : _b,
+    darkMode = _a.darkMode;
+  var _c = __read(React.useState(false), 2),
+    showCopy = _c[0],
+    setShowCopy = _c[1];
+  var copyToClipboard = function (text) {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var textarea;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            _a.trys.push([0, 2,, 3]);
+            return [4 /*yield*/, navigator.clipboard.writeText(text)];
+          case 1:
+            _a.sent();
+            // 简单的复制成功提示
+            alert('代码已复制到剪贴板');
+            return [3 /*break*/, 3];
+          case 2:
+            _a.sent();
+            textarea = document.createElement("textarea");
+            textarea.value = text;
+            document.body.appendChild(textarea);
+            textarea.select();
+            try {
+              document.execCommand("copy");
+              alert('代码已复制到剪贴板');
+            } catch (error) {
+              console.error("Fallback copy failed", error);
+            }
+            document.body.removeChild(textarea);
+            return [3 /*break*/, 3];
+          case 3:
+            return [2 /*return*/];
+        }
+      });
+    });
+  };
+  // 标准化语言名称，增强对 mermaid 语言的识别
+  var normalizedLanguage = language.toLowerCase();
+  // 检查是否为 mermaid 语言的变体
+  if (normalizedLanguage.includes('mermaid')) {
+    normalizedLanguage = "mermaid";
+  }
+  if (language === "mermaid") {
+    // 动态导入 MermaidRenderer 组件
+    var MermaidRenderer = /*#__PURE__*/React.lazy(function () {
+      return Promise.resolve().then(function () { return require('./MermaidRenderer-b23c2eec.js'); }).catch(function () {
+        return {
+          default: function () {
+            return /*#__PURE__*/runtime.jsx("div", {});
+          }
+        };
+      });
+    });
+    return /*#__PURE__*/runtime.jsx(React.Suspense, {
+      fallback: /*#__PURE__*/runtime.jsx("div", {}),
+      children: /*#__PURE__*/runtime.jsx(MermaidRenderer, {
+        chart: String(textContent)
+      }, Date.now())
+    });
+  }
+  // 简单的代码高亮样式
+  var codeStyle = {
+    backgroundColor: darkMode ? '#2d2d2d' : '#f5f5f5',
+    color: darkMode ? '#f8f8f2' : '#333',
+    padding: '12px',
+    borderRadius: '4px',
+    fontFamily: 'monospace',
+    fontSize: '14px',
+    lineHeight: '1.4',
+    overflowX: 'auto',
+    border: "1px solid ".concat(darkMode ? '#555' : '#ddd')
+  };
+  return /*#__PURE__*/runtime.jsxs("div", {
+    style: {
+      position: "relative"
+    },
+    children: [/*#__PURE__*/runtime.jsx("button", {
+      style: {
+        position: "absolute",
+        right: "10px",
+        top: "5px",
+        zIndex: 1,
+        background: darkMode ? "#555" : "#333",
+        color: "#fff",
+        border: "none",
+        padding: "4px 8px",
+        fontSize: "12px",
+        cursor: "pointer",
+        borderRadius: "4px"
+      },
+      onClick: function (e) {
+        e.preventDefault();
+        copyToClipboard(String(textContent));
+      },
+      onMouseEnter: function () {
+        return setShowCopy(true);
+      },
+      onMouseLeave: function () {
+        return setShowCopy(false);
+      },
+      children: showCopy ? "点击复制" : "复制"
+    }), /*#__PURE__*/runtime.jsx("pre", {
+      style: codeStyle,
+      children: /*#__PURE__*/runtime.jsx("code", {
+        children: String(textContent).replace(/\n$/, "")
+      })
+    })]
+  });
+};
+
+var Think = function (_a) {
+  var content = _a.content,
+    children = _a.children;
+  var _b = __read(React.useState(true), 2),
+    isExpanded = _b[0],
+    setIsExpanded = _b[1];
+  var thinkContent = content || children;
+  if (!thinkContent) {
+    return /*#__PURE__*/runtime.jsx("div", {});
+  }
+  return /*#__PURE__*/runtime.jsxs("div", {
+    className: "funq-think border rounded-lg p-3 mb-3 bg-blue-50 border-blue-200",
+    children: [/*#__PURE__*/runtime.jsxs("div", {
+      className: "flex items-center justify-between cursor-pointer",
+      onClick: function () {
+        return setIsExpanded(!isExpanded);
+      },
+      children: [/*#__PURE__*/runtime.jsxs("div", {
+        className: "flex items-center gap-2",
+        children: [/*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 rounded-full bg-blue-500 flex items-center justify-center",
+          children: /*#__PURE__*/runtime.jsx("svg", {
+            className: "w-3 h-3 text-white",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/runtime.jsx("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: "2",
+              d: "M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z"
+            })
+          })
+        }), /*#__PURE__*/runtime.jsx("span", {
+          className: "font-medium text-sm",
+          children: "AI \u601D\u8003\u8FC7\u7A0B"
+        })]
+      }), /*#__PURE__*/runtime.jsx("div", {
+        className: "w-4 h-4 text-muted-foreground",
+        children: isExpanded ? /*#__PURE__*/runtime.jsx("svg", {
+          fill: "none",
+          stroke: "currentColor",
+          viewBox: "0 0 24 24",
+          children: /*#__PURE__*/runtime.jsx("path", {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: "2",
+            d: "M5 15l7-7 7 7"
+          })
+        }) : /*#__PURE__*/runtime.jsx("svg", {
+          fill: "none",
+          stroke: "currentColor",
+          viewBox: "0 0 24 24",
+          children: /*#__PURE__*/runtime.jsx("path", {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: "2",
+            d: "M19 9l-7 7-7-7"
+          })
+        })
+      })]
+    }), isExpanded && /*#__PURE__*/runtime.jsx("div", {
+      className: "mt-3 pt-3 border-t border-blue-200",
+      children: /*#__PURE__*/runtime.jsx("blockquote", {
+        className: "text-sm text-blue-800 bg-blue-100 p-2 rounded",
+        children: typeof thinkContent === 'string' ? decodeURIComponent(thinkContent) : thinkContent
+      })
+    })]
+  });
+};
+
+var ToolCall = function (_a) {
+  var toolCall = _a.toolCall,
+    children = _a.children;
+  var _b = __read(React.useState(false), 2),
+    isExpanded = _b[0],
+    setIsExpanded = _b[1];
+  var getStateIcon = function () {
+    switch (toolCall.state) {
+      case 'loading':
+        return /*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 animate-spin border-2 border-blue-500 border-t-transparent rounded-full"
+        });
+      case 'done':
+        return /*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 rounded-full bg-green-500 flex items-center justify-center",
+          children: /*#__PURE__*/runtime.jsx("svg", {
+            className: "w-3 h-3 text-white",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/runtime.jsx("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: "2",
+              d: "M5 13l4 4L19 7"
+            })
+          })
+        });
+      case 'error':
+        return /*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 rounded-full bg-red-500 flex items-center justify-center",
+          children: /*#__PURE__*/runtime.jsx("svg", {
+            className: "w-3 h-3 text-white",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/runtime.jsx("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: "2",
+              d: "M6 18L18 6M6 6l12 12"
+            })
+          })
+        });
+      default:
+        return /*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 animate-spin border-2 border-blue-500 border-t-transparent rounded-full"
+        });
+    }
+  };
+  var getStateText = function () {
+    switch (toolCall.state) {
+      case 'loading':
+        return '执行中...';
+      case 'done':
+        return '执行完成';
+      case 'error':
+        return '执行出错';
+      default:
+        return '执行中...';
+    }
+  };
+  var getStateClass = function () {
+    switch (toolCall.state) {
+      case 'loading':
+        return 'bg-blue-50 border-blue-200';
+      case 'done':
+        return 'bg-green-50 border-green-200';
+      case 'error':
+        return 'bg-red-50 border-red-200';
+      default:
+        return 'bg-blue-50 border-blue-200';
+    }
+  };
+  // 解析工具调用结果，如果是JSON字符串则格式化显示
+  var formatResult = function (result) {
+    if (!result) return result;
+    try {
+      // 尝试解析为JSON
+      var parsed = JSON.parse(result);
+      return JSON.stringify(parsed, null, 2);
+    } catch (e) {
+      // 如果不是有效的JSON，直接返回原始字符串
+      return result;
+    }
+  };
+  return /*#__PURE__*/runtime.jsxs("div", {
+    className: "funq-tool-call border rounded-lg p-3 mb-3 ".concat(getStateClass()),
+    children: [/*#__PURE__*/runtime.jsxs("div", {
+      className: "flex items-center justify-between cursor-pointer",
+      onClick: function () {
+        return setIsExpanded(!isExpanded);
+      },
+      children: [/*#__PURE__*/runtime.jsxs("div", {
+        className: "flex items-center gap-2",
+        children: [getStateIcon(), /*#__PURE__*/runtime.jsxs("span", {
+          className: "font-medium text-sm",
+          children: ["\u5DE5\u5177\u8C03\u7528: ", toolCall.toolCallName]
+        }), /*#__PURE__*/runtime.jsx("span", {
+          className: "text-xs text-muted-foreground",
+          children: getStateText()
+        })]
+      }), /*#__PURE__*/runtime.jsxs("div", {
+        className: "flex items-center gap-2",
+        children: [toolCall.startTime && /*#__PURE__*/runtime.jsxs("span", {
+          className: "text-xs text-muted-foreground",
+          children: ["\u5F00\u59CB: ", new Date(toolCall.startTime).toLocaleTimeString()]
+        }), toolCall.endTime && toolCall.executionTime && /*#__PURE__*/runtime.jsxs("span", {
+          className: "text-xs text-muted-foreground",
+          children: ["\u8017\u65F6: ", toolCall.executionTime, "ms"]
+        }), /*#__PURE__*/runtime.jsx("div", {
+          className: "w-4 h-4 text-muted-foreground",
+          children: isExpanded ? /*#__PURE__*/runtime.jsx("svg", {
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/runtime.jsx("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: "2",
+              d: "M5 15l7-7 7 7"
+            })
+          }) : /*#__PURE__*/runtime.jsx("svg", {
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/runtime.jsx("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: "2",
+              d: "M19 9l-7 7-7-7"
+            })
+          })
+        })]
+      })]
+    }), isExpanded && /*#__PURE__*/runtime.jsxs("div", {
+      className: "mt-3 pt-3 border-t border-border",
+      children: [toolCall.toolCallArgs && /*#__PURE__*/runtime.jsxs("div", {
+        className: "mb-3",
+        children: [/*#__PURE__*/runtime.jsx("h4", {
+          className: "text-sm font-medium mb-1",
+          children: "\u53C2\u6570:"
+        }), /*#__PURE__*/runtime.jsx("pre", {
+          className: "text-xs bg-muted p-2 rounded overflow-x-auto break-words whitespace-pre-wrap",
+          children: toolCall.toolCallArgs
+        })]
+      }), (toolCall.delta || toolCall.state === 'error') && /*#__PURE__*/runtime.jsxs("div", {
+        children: [/*#__PURE__*/runtime.jsx("h4", {
+          className: "text-sm font-medium mb-1",
+          children: "\u7ED3\u679C:"
+        }), /*#__PURE__*/runtime.jsx("div", {
+          className: "text-sm p-2 rounded ".concat(toolCall.state === 'error' ? 'bg-red-100 text-red-800' : 'bg-muted'),
+          children: toolCall.state === 'error' ? /*#__PURE__*/runtime.jsx("pre", {
+            className: "whitespace-pre-wrap break-words overflow-x-auto",
+            children: formatResult(toolCall.delta) || '工具执行出错'
+          }) : /*#__PURE__*/runtime.jsx("pre", {
+            className: "whitespace-pre-wrap break-words overflow-x-auto",
+            children: formatResult(toolCall.delta)
+          })
+        })]
+      }), children && /*#__PURE__*/runtime.jsx("div", {
+        className: "mt-2",
+        children: children
+      })]
+    })]
+  });
+};
+
+var VideoComponent = function (_a) {
+  _a.node;
+    var props = __rest(_a, ["node"]);
+  var videoNode = {
+    props: {}
+  };
+  try {
+    props.children.map(function (item) {
+      if (item.props && item.type === 'source') {
+        videoNode = item;
+      }
+    });
+  } catch (e) {}
+  return /*#__PURE__*/runtime.jsxs("video", {
+    controls: true,
+    ...props,
+    children: [/*#__PURE__*/runtime.jsx("source", {
+      src: videoNode.props.src || '',
+      type: videoNode.props.type || 'video/mp4'
+    }), "\u4F60\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301video\u6807\u7B7E"]
+  });
+};
+// 音频组件
+var AudioComponent = function (_a) {
+  _a.node;
+    var props = __rest(_a, ["node"]);
+  var audioNode = {
+    props: {}
+  };
+  try {
+    props.children.map(function (item) {
+      if (item.props && item.type === 'source') {
+        audioNode = item;
+      }
+    });
+  } catch (e) {
+    console.error('Error processing audio children:', e);
+  }
+  return /*#__PURE__*/runtime.jsxs("audio", {
+    controls: true,
+    ...props,
+    children: [/*#__PURE__*/runtime.jsx("source", {
+      src: audioNode.props.src || '',
+      type: audioNode.props.type || 'audio/mpeg'
+    }), "\u4F60\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 audio \u6807\u7B7E"]
+  });
+};
+// 代码组件
+var CodeComponent = function (props) {
+  var children = props.children,
+    className = props.className;
+    props.node;
+    var rest = __rest(props, ["children", "className", "node"]);
+  var match = /language-(\w+)/.exec(className || "");
+  String(children).replace(/\n$/, '');
+  var extractText = function (children) {
+    return React.Children.toArray(children).reduce(function (acc, child) {
+      if (typeof child === 'string') {
+        return acc + child;
+      } else if (/*#__PURE__*/React.isValidElement(child) && child.props && child.props.children) {
+        return acc + extractText(child.props.children);
+      }
+      return acc;
+    }, '');
+  };
+  var content = extractText(children);
+  // 增强语言检测逻辑，检查内容中是否包含mermaid特征
+  var language = match ? match[1] : "txt";
+  // 如果内容包含mermaid特征且语言未正确识别，则强制设置为mermaid
+  if (!match || match[1] !== "mermaid") {
+    var trimmedContent = content.trim();
+    if (trimmedContent.startsWith('graph') || trimmedContent.startsWith('flowchart') || trimmedContent.startsWith('sequenceDiagram') || trimmedContent.startsWith('gantt') || trimmedContent.startsWith('classDiagram') || trimmedContent.startsWith('stateDiagram') || trimmedContent.startsWith('pie') || trimmedContent.startsWith('erDiagram') || trimmedContent.startsWith('journey') || trimmedContent.startsWith('requirementDiagram') || trimmedContent.startsWith('gitGraph')) {
+      language = "mermaid";
+    }
+  }
+  return language !== "txt" ? /*#__PURE__*/runtime.jsx(CodeHighlight, {
+    ...rest,
+    language: language,
+    textContent: content,
+    children: content
+  }) : /*#__PURE__*/runtime.jsx("code", {
+    className: className,
+    ...props,
+    children: content
+  });
+};
+// 段落组件
+var PComponent = function (pProps) {
+  return /*#__PURE__*/runtime.jsx("p", {
+    ...pProps,
+    dir: "auto"
+  });
+};
+// 链接组件
+var AComponent = function (aProps) {
+  var _a;
+  var href = aProps.href || "";
+  var isInternal = /^\/#/i.test(href);
+  var target = isInternal ? "_self" : (_a = aProps.target) !== null && _a !== void 0 ? _a : "_blank";
+  // 增强链接样式，使其更加明显
+  var linkStyle = {
+    color: '#1a73e8',
+    fontWeight: '600',
+    borderBottom: '2px solid #1a73e8',
+    paddingBottom: '2px',
+    transition: 'all 0.2s ease'
+  };
+  // 鼠标悬停效果
+  var hoverStyle = {
+    color: '#0d47a1',
+    borderBottom: '2px solid #0d47a1',
+    backgroundColor: 'rgba(26, 115, 232, 0.1)'
+  };
+  // 合并原有属性和新样式
+  return /*#__PURE__*/runtime.jsx("a", {
+    ...aProps,
+    target: target,
+    style: __assign(__assign({}, linkStyle), aProps.style),
+    onMouseEnter: function (e) {
+      var target = e.target;
+      Object.assign(target.style, hoverStyle);
+      aProps.onMouseEnter && aProps.onMouseEnter(e);
+    },
+    onMouseLeave: function (e) {
+      var target = e.target;
+      Object.assign(target.style, linkStyle);
+      aProps.onMouseLeave && aProps.onMouseLeave(e);
+    }
+  });
+};
+// Pre 组件
+var PreComponent = function (props) {
+  return /*#__PURE__*/runtime.jsx("div", {
+    ...props
+  });
+};
+var BuiltInComponents = {
+  _THINK: Think,
+  _TOOL_CALL: ToolCall,
+  pre: PreComponent,
+  code: CodeComponent,
+  p: PComponent,
+  a: AComponent,
+  video: VideoComponent,
+  audio: AudioComponent
+};
+
+var ErrorBoundary = /** @class */function (_super) {
+  __extends(ErrorBoundary, _super);
+  function ErrorBoundary(props) {
+    var _this = _super.call(this, props) || this;
+    _this.state = {
+      hasError: false
+    };
+    return _this;
+  }
+  ErrorBoundary.getDerivedStateFromError = function () {
+    return {
+      hasError: true
+    };
+  };
+  ErrorBoundary.prototype.componentDidCatch = function (error, errorInfo) {
+    // 可以在这里记录错误信息
+  };
+  ErrorBoundary.prototype.render = function () {
+    if (this.state.hasError) {
+      return /*#__PURE__*/runtime.jsx("div", {
+        children: this.props.content
+      });
+    }
+    return this.props.children;
+  };
+  return ErrorBoundary;
+}(React.Component);
+
+function MdxLayout(_a) {
+  var children = _a.children;
+  return /*#__PURE__*/runtime.jsx("div", {
+    children: children
+  });
+}
+
+var THINK_BEGIN_TAG = '<think>';
+var THINK_END_TAG = '</think>';
+var CUSTOMER_THINK_COMPONENT_DISPLAY = '_THINK';
+var TOOLCALL_BEGIN_TAG = '<toolcall>';
+var TOOLCALL_END_TAG = '</toolcall>';
+var CUSTOMER_TOOLCALL_COMPONENT_DISPLAY = '_TOOLCALL';
+function fixMDXContent(content) {
+  // 替换中文括号为英文括号
+  return content.replace(/\\\[/g, '$$').replace(/\\\]/g, '$$')
+  // 确保LaTeX公式正确转义
+  .replace(/\\\(/g, '$').replace(/\\\)/g, '$');
+}
+function generateRandomName(length) {
+  if (length === void 0) {
+    length = 6;
+  }
+  var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  var result = '';
+  for (var i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return result;
+}
+function remarkLLMTagUpdate(content) {
+  var thinkContent = '';
+  var toolCallContent = '';
+  var resultContent = '';
+  // 处理 Think 标签
+  var thinkBeginIndex = content.indexOf(THINK_BEGIN_TAG);
+  var thinkEndIndex = content.lastIndexOf(THINK_END_TAG);
+  if (thinkBeginIndex !== -1 && thinkEndIndex === -1) {
+    // 有开始，无结束
+    thinkContent = content.slice(THINK_BEGIN_TAG.length);
+    thinkContent = "<".concat(CUSTOMER_THINK_COMPONENT_DISPLAY, "  content=\"").concat(encodeURIComponent(thinkContent), "\" />");
+  } else if (thinkBeginIndex !== -1 && thinkEndIndex !== -1) {
+    // 有开始，有结束
+    var anotherEndIndex = content.indexOf(THINK_END_TAG);
+    if (anotherEndIndex !== thinkEndIndex) {
+      thinkContent = content.slice(THINK_BEGIN_TAG.length, anotherEndIndex);
+      resultContent = content.slice(thinkEndIndex + THINK_END_TAG.length);
+      thinkContent = "<".concat(CUSTOMER_THINK_COMPONENT_DISPLAY, "  content=\"").concat(encodeURIComponent(thinkContent), "\" />");
+    } else {
+      thinkContent = content.slice(THINK_BEGIN_TAG.length, thinkEndIndex);
+      thinkContent = "<".concat(CUSTOMER_THINK_COMPONENT_DISPLAY, "  content=\"").concat(encodeURIComponent(thinkContent), "\" />");
+      resultContent = content.slice(thinkEndIndex + THINK_END_TAG.length);
+    }
+  } else if (thinkBeginIndex == -1) {
+    resultContent = content;
+  }
+  // 处理 ToolCall 标签
+  var toolCallBeginIndex = resultContent.indexOf(TOOLCALL_BEGIN_TAG);
+  var toolCallEndIndex = resultContent.lastIndexOf(TOOLCALL_END_TAG);
+  if (toolCallBeginIndex !== -1 && toolCallEndIndex === -1) {
+    // 有开始，无结束
+    // 提取工具调用信息
+    var toolCallData = resultContent.slice(TOOL_CALL_BEGIN_TAG.length);
+    try {
+      var toolCallObj = JSON.parse(toolCallData);
+      toolCallContent = "<".concat(CUSTOMER_TOOLCALL_COMPONENT_DISPLAY, " toolCall={").concat(JSON.stringify(toolCallObj).replace(/"/g, '&quot;'), "} />");
+      resultContent = ''; // 清空剩余内容，因为工具调用是流式的
+    } catch (e) {
+      // 如果解析失败，将内容作为普通文本处理
+      toolCallContent = "<".concat(CUSTOMER_TOOLCALL_COMPONENT_DISPLAY, " toolCall={").concat(JSON.stringify({
+        toolCallName: 'Unknown',
+        state: 'loading',
+        delta: toolCallData
+      }).replace(/"/g, '&quot;'), "} />");
+      resultContent = '';
+    }
+  } else if (toolCallBeginIndex !== -1 && toolCallEndIndex !== -1) {
+    // 有开始，有结束
+    // 提取完整的工具调用信息
+    var toolCallData = resultContent.slice(TOOL_CALL_BEGIN_TAG.length, toolCallEndIndex);
+    var remainingContent = resultContent.slice(toolCallEndIndex + TOOL_CALL_END_TAG.length);
+    try {
+      var toolCallObj = JSON.parse(toolCallData);
+      toolCallContent = "<".concat(CUSTOMER_TOOLCALL_COMPONENT_DISPLAY, " toolCall={").concat(JSON.stringify(toolCallObj).replace(/"/g, '&quot;'), "} />");
+    } catch (e) {
+      // 如果解析失败，将内容作为普通文本处理
+      toolCallContent = "<".concat(CUSTOMER_TOOLCALL_COMPONENT_DISPLAY, " toolCall={").concat(JSON.stringify({
+        toolCallName: 'Unknown',
+        state: 'done',
+        delta: toolCallData
+      }).replace(/"/g, '&quot;'), "} />");
+    }
+    resultContent = remainingContent;
+  }
+  return {
+    thinkContent: thinkContent,
+    toolCallContent: toolCallContent,
+    resultContent: resultContent
+  };
+}
+/**
+ * 转义流式内容中的特殊字符，防止MDX解析错误
+ * @param content 需要转义的内容
+ * @returns 转义后的内容
+ */
+function escapeContentForStream(content) {
+  if (typeof content !== 'string') return content;
+  return content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/{/g, '&#123;').replace(/}/g, '&#125;');
+}
+
+var renderTimer = null;
+// 辅助函数：格式化props
+function formatProps(props) {
+  return Object.entries(props).map(function (_a) {
+    var _b = __read(_a, 2),
+      key = _b[0],
+      value = _b[1];
+    if (typeof value === 'string') {
+      return "".concat(key, "=\"").concat(value, "\"");
+    }
+    try {
+      value = JSON.stringify(value);
+    } catch (e) {
+      console.error('Error stringifying prop value:', e);
+    }
+    return "".concat(key, "={").concat(value, "}");
+  }).join(' ');
+}
+function renderMdx(mdxContent, scope, registeredComponents) {
+  return __awaiter(this, void 0, void 0, function () {
+    var componentTagRegex, usedComponents, match, vf, XComponent;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          _a.trys.push([0, 3,, 4]);
+          renderTimer && clearTimeout(renderTimer);
+          componentTagRegex = /<([A-Z][a-zA-Z]*)\b/g;
+          usedComponents = new Set();
+          match = void 0;
+          while ((match = componentTagRegex.exec(mdxContent)) !== null) {
+            usedComponents.add(match[1]);
+          }
+          return [4 /*yield*/, mdx.compile(mdxContent, {
+            outputFormat: "function-body",
+            remarkPlugins: [[RemarkMath, {
+              strict: true
+            }], RemarkGfm, RemarkBreaks],
+            rehypePlugins: [[RehypeKatex], [RehypeHighlight, {
+              detect: false,
+              ignoreMissing: true,
+              plainText: ['mermaid'] // 将mermaid作为纯文本处理，避免被错误高亮
+            }]]
+          })];
+        case 1:
+          vf = _a.sent();
+          return [4 /*yield*/, mdx.run(vf, __assign(__assign(__assign({}, runtime__namespace), scope), {
+            Fragment: MdxLayout
+          }))];
+        case 2:
+          XComponent = _a.sent().default;
+          return [2 /*return*/, /*#__PURE__*/React__namespace.createElement(XComponent, {
+            components: registeredComponents,
+            scope: scope
+          })];
+        case 3:
+          _a.sent();
+          return [2 /*return*/, new Promise(function (resolve) {
+            renderTimer = setTimeout(function () {
+              resolve(/*#__PURE__*/React__namespace.createElement('div', {
+                style: {
+                  backgroundColor: 'transparent'
+                }
+              }, mdxContent));
+              clearTimeout(renderTimer); // 清理定时器
+            }, 2000); // 1秒延迟
+          })];
+        case 4:
+          return [2 /*return*/];
+      }
+    });
+  });
+}
+// 递归解析组件的函数
+function parseComponentRecursively(allComponentHandlers, item, scope) {
+  return __awaiter(this, void 0, void 0, function () {
+    var componentHandler, componentString_1, parsedChildren, props, propsString, childrenContent_1, parsedChildren_1, componentString;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          if (item.type === 'text') {
+            return [2 /*return*/, item.value];
+          }
+          if (!(item.type === 'component')) return [3 /*break*/, 8];
+          componentHandler = allComponentHandlers.find(function (c) {
+            return c.name === item.value;
+          });
+          if (!!componentHandler) return [3 /*break*/, 5];
+          componentString_1 = "<".concat(item.value);
+          if (item.props) {
+            componentString_1 += ' ' + Object.entries(item.props).map(function (_a) {
+              var _b = __read(_a, 2),
+                key = _b[0],
+                value = _b[1];
+              if (typeof value === 'string') {
+                return "".concat(key, "=\"").concat(value, "\"");
+              }
+              try {
+                return "".concat(key, "={").concat(JSON.stringify(value), "}");
+              } catch (e) {
+                return "".concat(key, "=\"[object Object]\"");
+              }
+            }).join(' ');
+          }
+          if (!item.selfClosing) return [3 /*break*/, 1];
+          componentString_1 += ' />';
+          return [3 /*break*/, 4];
+        case 1:
+          componentString_1 += '>';
+          if (!(item.children && Array.isArray(item.children))) return [3 /*break*/, 3];
+          return [4 /*yield*/, Promise.all(item.children.map(function (child) {
+            return parseComponentRecursively(allComponentHandlers, child, scope);
+          }))];
+        case 2:
+          parsedChildren = _a.sent();
+          componentString_1 += parsedChildren.join('');
+          _a.label = 3;
+        case 3:
+          componentString_1 += "</".concat(item.value, ">");
+          _a.label = 4;
+        case 4:
+          return [2 /*return*/, componentString_1];
+        case 5:
+          props = __assign(__assign({}, item.props), {
+            key: generateRandomName()
+          });
+          propsString = formatProps(props);
+          propsString += " scope={props.scope}";
+          childrenContent_1 = '';
+          if (!(item.children && Array.isArray(item.children))) return [3 /*break*/, 7];
+          return [4 /*yield*/, Promise.all(item.children.map(function (child) {
+            return parseComponentRecursively(allComponentHandlers, child, scope);
+          }))];
+        case 6:
+          parsedChildren_1 = _a.sent();
+          item.children.map(function (item, index) {
+            if (item.type === 'text') {
+              childrenContent_1 += escapeContentForStream(parsedChildren_1[index]); // encodeURIComponent(parsedChildren[index]);
+            } else {
+              childrenContent_1 += parsedChildren_1[index];
+            }
+          });
+          _a.label = 7;
+        case 7:
+          // 调用组件的渲染钩子
+          if (componentHandler.onRender) {
+            componentHandler.onRender(item, scope);
+          }
+          componentString = componentHandler.selfClosing ? "<".concat(item.value, " ").concat(propsString, " />") : "\t\n<".concat(item.value, " ").concat(propsString, ">\n").concat(childrenContent_1, "\n</").concat(item.value, ">\t\n");
+          return [2 /*return*/, componentString];
+        case 8:
+          return [2 /*return*/, null];
+      }
+    });
+  });
+}
+
+// 使用 WeakMap 作为缓存，避免重复检测相同组件类型
+var componentDetectionCache = new WeakMap();
+/**
+ * 检测组件是否为自闭合组件
+ * 通过检查组件是否接受 children 属性来判断
+ * @param component - 要检测的 React 组件
+ * @returns boolean - true 表示自闭合组件（不支持 children），false 表示非自闭合组件（支持 children）
+ */
+function isSelfClosingComponent(component) {
+  // 首先检查缓存
+  if (componentDetectionCache.has(component)) {
+    return componentDetectionCache.get(component);
+  }
+  try {
+    // 对于函数组件，使用更可靠的方法检测
+    if (typeof component === 'function') {
+      // 优先检查组件的 propTypes（如果存在）
+      if ('propTypes' in component && component.propTypes) {
+        var propTypes = component.propTypes;
+        var hasChildrenPropType = 'children' in propTypes;
+        var result_1 = !hasChildrenPropType;
+        componentDetectionCache.set(component, result_1);
+        return result_1;
+      }
+      // 检查组件的 defaultProps（如果存在）
+      if ('defaultProps' in component && component.defaultProps) {
+        var defaultProps = component.defaultProps;
+        // 如果 defaultProps 中包含 children，则组件支持 children
+        if ('children' in defaultProps) {
+          componentDetectionCache.set(component, false);
+          return false;
+        }
+      }
+      // 检查函数签名（如果可用）
+      var componentString = component.toString();
+      // 移除注释和多余空格
+      var cleanString = componentString.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '').trim();
+      // 检查是否显式接受 children 参数
+      var hasChildrenDestructuring = /\(\s*\{[^}]*\bchildren\b[^}]*\}/.test(cleanString);
+      // 如果组件参数中明确包含 children，则认为是非自闭合组件
+      if (hasChildrenDestructuring) {
+        componentDetectionCache.set(component, false);
+        return false;
+      } else {
+        componentDetectionCache.set(component, true);
+        return true;
+      }
+    }
+    // 对于类组件，默认假设是非自闭合的
+    var result = false;
+    componentDetectionCache.set(component, result);
+    return result;
+  } catch (error) {
+    // 如果检测过程中出现错误，默认返回 false（非自闭合）
+    var result = false;
+    componentDetectionCache.set(component, result);
+    return result;
+  }
+}
+
+function ReactAIRenderer(_a) {
+  var _this = this;
+  var content = _a.content,
+    _b = _a.scope,
+    scope = _b === void 0 ? {} : _b,
+    _c = _a.components,
+    components = _c === void 0 ? {} : _c,
+    children = _a.children,
+    _d = _a.componentHandlers,
+    componentHandlers = _d === void 0 ? [] : _d;
+  content = content || children || '';
+  var allComponents = __assign(__assign({}, BuiltInComponents), components);
+  // 修复：确保 components 是一个对象后再使用 Object.entries
+  var allComponentHandlers = __spreadArray(__spreadArray([], __read(components ? Object.entries(components).filter(function (_a) {
+    var _b = __read(_a, 1),
+      name = _b[0];
+    return !componentHandlers.some(function (handler) {
+      return handler.name === name;
+    });
+  }).map(function (_a) {
+    var _b = __read(_a, 2),
+      name = _b[0],
+      component = _b[1];
+    var selfClosing = isSelfClosingComponent(component);
+    return {
+      component: component,
+      name: name,
+      selfClosing: selfClosing
+    };
+  }) : []), false), __read(componentHandlers), false);
+  var _e = __read(React.useState(null), 2),
+    component = _e[0],
+    setComponent = _e[1];
+  var parser = new MDXStreamingParser(allComponentHandlers);
+  var mdxContent = content || '';
+  React.useEffect(function () {
+    var parseMDX = function () {
+      return __awaiter(_this, void 0, void 0, function () {
+        var ThinkComponent, ToolCallComponent, ResultComponent, _a, thinkContent, toolCallContent, resultContent, parsedData, parsedComponents, finalComponent, i, _result, MDXComponent;
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              ThinkComponent = null;
+              ToolCallComponent = null;
+              ResultComponent = null;
+              _a = remarkLLMTagUpdate(mdxContent), thinkContent = _a.thinkContent, toolCallContent = _a.toolCallContent, resultContent = _a.resultContent;
+              if (!thinkContent) return [3 /*break*/, 2];
+              return [4 /*yield*/, renderMdx(thinkContent, scope, allComponents)];
+            case 1:
+              ThinkComponent = _b.sent();
+              _b.label = 2;
+            case 2:
+              if (!toolCallContent) return [3 /*break*/, 4];
+              return [4 /*yield*/, renderMdx(toolCallContent, scope, allComponents)];
+            case 3:
+              ToolCallComponent = _b.sent();
+              _b.label = 4;
+            case 4:
+              if (!resultContent) return [3 /*break*/, 10];
+              resultContent = fixMDXContent(resultContent);
+              parsedData = parser.parse('magic', resultContent);
+              return [4 /*yield*/, Promise.all(parsedData.map(function (item) {
+                return parseComponentRecursively(allComponentHandlers, item, scope);
+              }))];
+            case 5:
+              parsedComponents = _b.sent();
+              finalComponent = [];
+              i = 0;
+              _b.label = 6;
+            case 6:
+              if (!(i < parsedComponents.length)) return [3 /*break*/, 9];
+              return [4 /*yield*/, renderMdx(parsedComponents[i], scope, allComponents)];
+            case 7:
+              _result = _b.sent();
+              finalComponent.push(_result);
+              _b.label = 8;
+            case 8:
+              i++;
+              return [3 /*break*/, 6];
+            case 9:
+              ResultComponent = /*#__PURE__*/runtime.jsx("div", {
+                children: finalComponent
+              });
+              _b.label = 10;
+            case 10:
+              MDXComponent = /*#__PURE__*/runtime.jsxs(React.Fragment, {
+                children: [ThinkComponent, ToolCallComponent, ResultComponent]
+              });
+              setComponent(MDXComponent);
+              return [2 /*return*/];
+          }
+        });
+      });
+    };
+    parseMDX();
+  }, [content]);
+  return /*#__PURE__*/runtime.jsx(ErrorBoundary, {
+    content: content,
+    children: component
+  });
+}
+
+// 导出 MDXStreamingParser 类
+
+exports.MDXStreamingParser = MDXStreamingParser;
+exports.ReactAIRenderer = ReactAIRenderer;
+exports.Think = Think;
+exports.ToolCall = ToolCall;
+exports.__awaiter = __awaiter;
+exports.__generator = __generator;
+exports.__read = __read;
+//# sourceMappingURL=index-53d781f0.js.map